programming language semantics java threads and locks informal introduction the java specification...

Programming Language SemanticsJava Threads and LocksInformal Introduction

The Java Specification Language

Chapter 17

Motivation• Show that the techniques presented in the course can

handle real programming language

Java Language Features

o Higher order types

o Dynamic memory allocation

o Pointers

o Procedures and recursion

o Parameter passing

o Concurrency

Introduction to

Primary Goals of Java

• Portable

• Secured

• Object Oriented

Portable – Platform Independent

Source Code

Java Compiler

ByteCode

JVMinput output

Secured

• ByteCode instructions• Download through

Network• Verify Code• Run it

Network

Object Oriented Programming

• Encapsulation

• Inheritance

• Polymorphism

C vs. Java

• Macros• Low-level memory

management– Pointer arithmetic p++– Casts – Free– Unsafe arrays– Stack allocation– Big and small L-values

• Object Oriented• Portable• Well defined semantics• Dynamic class loading• References instead of

arbitrary pointers• Heap only• No free (Garbage

collection)• Exceptions

Java Concurrency

• JVM supports threads of execution– Many threads can be executed “simultaneously”– Communicate via shared memory– Synchronize activities using locks

• Standard methods for efficient transfer of control– wait– notify– …

• Special rules about allowed orders of executions

Rules on orders of executions

• Proper use of synchronization allow reliable transmission of values

• Used values are not corrupted– Written by threads

• Provides freedom to the implementation to update memory in an efficient (but surprising) way– (in an absence of synchronization)

Java code fragment

synchronized(p) { p.y = 2; } a = p.x; b = p.y; c = p.y;

synchronized(p) { p.y = 3; p.y = 100; } p.x = 1;

[p.x0, p.y0]

Plan

• Terminology

• (Partial) rules for execution orders

• Example programs

• Threads

• Locks and synchronization

• Wait sets and notification

• Conclusion

Terminology

• Variable any location in the program with an L-value

• Main memory shared by all threads• Working memory local to every thread• Data exchange is asynchronous • thread actions

– use, assign, load, store, lock, unlock

• Main memory actions– read, write, lock, unlock

Main memorywrite

read

lock

workingmemory

Threadengine

asign

use

store

load

lock

Java Memory Model

unlock

unlock

workingmemory

Threadengine

assign

use

store

load

unlock

lock

Action Summary

• use (thread) transfer content of variables to thread’s execution engine

• assign (thread) transfer content of variables into working copy

• read (main memory) transmit content of master

• load (thread) put the transmitted value into a working copy

• store (thread) transmit the working copy to main memory

• write (main memory) puts the transmitted value into main memory

• lock (thread and main memory) a thread acquires a lock

• unlock (thread and main memory) a thread releases the lock

Execution Order

• Actions performed on any thread are totally ordered

• Actions performed by main memory on the same variable are totally ordered

• Actions performed by memory on the same lock are totally ordered

• No action can follow itself

Memory-Thread Interactions

• lock/unlock operations are performed jointly• thread load is uniquely paired with memory read• thread store is uniquely paired with memory write• Other rules constrain the order of actions

– Affect the semantics

– Programmers need to understand in order to write correct and portable programs

– Many possible implementations

Variable Rules

• T thread• V variable• A use or assign by T on V is permitted only when

dictated by the bytecode of T– Executed in order specified by the thread

• A store by T on V must intervene between assign by T on V and subsequent load by T on V

• An assign by T on V must intervene between load/store by T on V and subsequent store by T on V

Variable Rules (cont)

• T thread

• V variable

• After T is created it must perform assign/load on V before use/store on V

• After V is created, every thread must perform assign/load before use/store on V

Variable Rules (main memory)

• Every load performed by T on its working copy of V there exists a corresponding read by main memory from the master copy of V

• Every store performed by T of its working copy of V there exists a corresponding write by main memory of V into the master copy

Variable Rules (main memory)

• A be a load/store performed by T – P be the corresponding read/write by main

memory

• B be a load/store performed by T – Q be the corresponding read/write by main

memory

• If A precedes B then P precedes Q

Locks Rules

• T thread• L lock• lock by T on L may occur only if every thread S

other T the number of preceding unlocks by S on L = the number of preceding locks on L by S

• unlock by T may occur only if the number preceding unlocks by T < the number of preceding locks by T

• lock/unlock performed in sequential order

Interactions of Locks and Variables

• Between assign by T of V and a subsequent unlock by T on L– store of V by T must intervene

– The corresponding write must precede the unlock

• Between lock by T on L and a subsequent use/store by T of V– assign/load of V by T must intervene

– For load, the corresponding read must follow the lock

Example: Possible Swap

class sample {

int a = 1, b = 2;

void hither(){

a = b;

}

void yon(){

b = a ;

}

use b

assign a

load b

hitter thread main memory

use a

assign b

read b

[store a]

[write a]

read a

load a

[store b]

[write b]

yon thread

Example: Possible Swap

use b

assign a

load b

hitter thread main memory

use a

assign b

read b

[store a]

[write a]

read a

load a

[store b]

[write b]

yon thread

b=2

b=2

a=2

a=2

a=2

a=2

a=2

b=2

b=2

b=2

a=2b=2

Example: Possible Swap

use b

assign a

load b

hitter thread main memory

use a

assign b

read b

[store a]

[write a]

read a

load a

[store b]

[write b]

yon thread

b=1

b=1

a=1

a=1

a=1

a=1

a=1

b=1

b=1

b=1

a=1b=1

Example: Possible Swap

use b

assign a

load b

hitter thread main memory

use a

assign b

read b

[store a]

[write a]

read a

load a

[store b]

[write b]

yon thread

b=2

b=2

a=2

a=2

a=2

a=1

a=1

b=1

b=1

b=1

a=1b=2

(lock,1,o)

(assign,1,y,2)

(store,1,y,2)

(unlock,1,o)

(load,1,x,1)

(use,1,x,1)

(use,1,y,2)

(load,1,y,3)

(use,1,y,3)

(write,1,y,2)

(write,2,y,3)

(read,1,y,3)

(write,2,y,100)

(lock,2,o)

(assign,2,y,3)

(store,2,y,3)

(assign,2,y,100)

(store,2,y,100)

(unlock,2,o)

(assign,2,x,1)

(store,2,x,1)(write,2,x,1)

(read,1,x,1)

(1) synchronized(p) { p.y = 2; } a = p.x; b = p.y; c = p.y;(2) synchronized(p) { p.y = 3; p.y = 100; } p.x = 1;

(lock,1,o)

(assign,1,y,2)

(store,1,y,2)

(unlock,1,o)

(load,1,x,1)

(use,1,x,1)

(use,1,y,2)

(load,1,y,3)

(use,1,y,3)

(write,1,y,2)

(write,2,y,3)

(read,1,y,3)

(write,2,y,100)

(lock,2,o)

(assign,2,y,3)

(store,2,y,3)

(assign,2,y,100)

(store,2,y,100)

(unlock,2,o)

(assign,2,x,1)

(store,2,x,1)(write,2,x,1)

(read,1,x,1)

(1) synchronized(p) { p.y = 2; } a = p.x; b = p.y; c = p.y;(2) synchronized(p) { p.y = 3; p.y = 100; } p.x = 1;

(lock,1,o)

(assign,1,y,2)

(store,1,y,2)

(unlock,1,o)

(load,1,x,1)

(use,1,x,1)

(use,1,y,2)

(load,1,y,3)

(use,1,y,3)

(write,1,y,2)

(write,2,y,3)

(read,1,y,3)

(write,2,y,100)

(lock,2,o)

(assign,2,y,3)

(store,2,y,3)

(assign,2,y,100)

(store,2,y,100)

(unlock,2,o)

(assign,2,x,1)

(store,2,x,1)(write,2,x,1)

(read,1,x,1)

(1) synchronized(p) { p.y = 2; } a = p.x; b = p.y; c = p.y;(2) synchronized(p) { p.y = 3; p.y = 100; } p.x = 1;

(lock,1,o)

(assign,1,y,2)

(store,1,y,2)

(unlock,1,o)

(load,1,x,1)

(use,1,x,1)

(use,1,y,2)

(load,1,y,3)

(use,1,y,3)

(write,1,y,2)

(write,2,y,3)

(read,1,y,3)

(write,2,y,100)

(lock,2,o)

(assign,2,y,3)

(store,2,y,3)

(assign,2,y,100)

(store,2,y,100)

(unlock,2,o)

(assign,2,x,1)

(store,2,x,1)(write,2,x,1)

(read,1,x,1)

(1) synchronized(p) { p.y = 2; } a = p.x; b = p.y; c = p.y;(2) synchronized(p) { p.y = 3; p.y = 100; } p.x = 1;

(lock,1,o)

(assign,1,y,2)

(store,1,y,2)

(unlock,1,o)

(load,1,x,1)

(use,1,x,1)

(use,1,y,2)

(load,1,y,3)

(use,1,y,3)

(write,1,y,2)

(write,2,y,3)

(read,1,y,3)

(write,2,y,100)

(lock,2,o)

(assign,2,y,3)

(store,2,y,3)

(assign,2,y,100)

(store,2,y,100)

(unlock,2,o)

(assign,2,x,1)

(store,2,x,1)(write,2,x,1)

(read,1,x,1)

(1) synchronized(p) { p.y = 2; } a = p.x; b = p.y; c = p.y;(2) synchronized(p) { p.y = 3; p.y = 100; } p.x = 1;

(lock,1,o)

(assign,1,y,2)

(store,1,y,2)

(unlock,1,o)

(load,1,x,1)

(use,1,x,1)

(use,1,y,2)

(load,1,y,3)

(use,1,y,3)

(write,1,y,2)

(write,2,y,3)

(read,1,y,3)

(write,2,y,100)

(lock,2,o)

(assign,2,y,3)

(store,2,y,3)

(assign,2,y,100)

(store,2,y,100)

(unlock,2,o)

(assign,2,x,1)

(store,2,x,1)(write,2,x,1)

(read,1,x,1)

(1) synchronized(p) { p.y = 2; } a = p.x; b = p.y; c = p.y;(2) synchronized(p) { p.y = 3; p.y = 100; } p.x = 1;

Threads

• Created by the built-in class Thread

• The start method starts a thread

Locks and Synchronization

• Every object is a lock• The synchronized statement computes a

reference to an object and issues lock L • After lock L complete the body is executed• When the body is completed unlock L is

executed • A synchronized method is a sugar for

synchronizing the method body

Wait sets and notification

• Every object also has wait set of threads• Used by methods wait, notify, notifyAll

– wait releases the lock and adds thread to wait set

– The thread waits until• notify schedules and remove one thread from wait

set• notifyAll occurs• Specified timeout

Uncovered

• Volatile variables

• Prescient Store actions

• Non-atomic treatment of double of long

Summary

• Java provides a powerful low level model of concurrency

• Hard to understand

• But portable

• Next lesson SOS for Java concurrency