Java Thread and Memory Model

Java Thread and Memory Model By Xijun Zhang #104549

Question • Can this result in i = 0 and j = 0?

Contents • Thread review • Threads in Java • Programmer’s view of Java memory model

Threads • Has an execution state (running, ready, etc.) • Saves thread context when not running • Has an execution stack and some per-thread static storage for local variables • Has access to the memory address space and resources of its process • all threads of a process share this • when one thread alters a (non-private) memory item, all other threads (of the process) sees that • a file open with one thread, is available to others

Single Threaded and Multithreaded Process Models • Thread Control Block contains a register image, thread priority and thread state information

Benefits of Threads vs Processes • Takes less time to create a new thread than a process • Less time to terminate a thread than a process • Less time to switch between two threads within the same process

Benefits of Threads • Since threads within the same process share memory and files, they can communicate with each other without invoking the kernel • Therefore necessary to synchronize the activities of various threads so that they do not obtain inconsistent views of the data

Java Thread Support Reside in Three Places • The java.lang.Thread class • The java.lang.Object class • The Java language and virtual machine

Two ways to create threads • Extending the java.lang.Thread class • Implementing the java.lang.Runnable interface

Extending the Thread class • Can build a thread by extending java.lang.Thread class • You must supply a public void run() method • Start a thread by invoking the start() method • When a thread starts, it executes run() method • When run() finished, the thread is finished/dead

Interface Runnable • Extending Thread means can’t extend anything else • Instead implement Runnable (Declares an object has a void run() method) • Creating a new thread by giving is an object of type Runnable • Constructors: Thread(Runnable target) Thread(Runnable target, String name)

Thread States • Running: The state that all threads aspire to • Various waiting states: Waiting, Sleeping, Suspended, Blocked • Ready: Not waiting for anything except the CPU • Dead: All done

Two approaches to implement Thread schedulers • Preemptive scheduling (e.g. Solaris) • Time-sliced or round-robin scheduling e.g. Macintosh, Windows • Java Thread is platform dependent

Synchronization • Threads share the same memory space, i.e. they can share resources • It is desirable that only one thread at a time has access to a shared resource • Java use the key word synchronized for critical section

Monitors • At any given time, no more than one thread can own the monitor and thereby have access to the shared resource • A monitor thus implements a mutually exclusive locking mechanism • All Java objects have a monitor, and each object can be used as a mutually exclusive lock, providing the ability to synchronize access to shared resources

Synchronized Methods • A method can be synchronized (add synchronized before the return type) • Obtains a lock on object referenced by this before starting method ( releases lock when method completes) • A static synchronized method (locks the class object)

Synchronized statement • synchronized (obj) {block} • Obtains a lock on obj before executing block • Releases lock once block completes • Provides finer grain of control • Allows you to lock arguments to a method

Using wait • a.wait() --gives up locks on a --adds thread to wait set for a --suspends thread • a.wait(int m) --limits suspension to m milliseconds

Using notify • a.notify() resumes one thread from a’s waiting list and remove it from wait set, no control over which thread • a.notifyAll() resumes one thread on a’s waiting list • resumed task must reacquire lock before continuing

Synchronization • Atomicity --locking to obtain mutual exclusion --Atomic read/write granularity • Visibility --ensuring that changes in object fields on one object are seen in another thread • Ordering --ensuring that you aren’t surprised by the order in which statements are executed

Question • Can this result in i=0 and j=0?

Answer: Yes! • How can i=0 and j=0?

Working Memory v.s. Main Memory • Every thread has a working memory in which it keeps its own working copy of variables that it must use or assign. As the thread executes a program, it operates on these working copies. • The main memory contains the master copy of every variable.

Low level actions

How can this happen? • Compiler can reorder statement or keep values in registers • Processor can reorder them • On multiprocessor, values not synchronized in global memory • Must use synchronization to enforce visibility and ordering as well as mutual exclusion

Synchronization Action //block until obtain lock synchronized (anObject) { //get main memory value of field1 and field2 int x = anObject.field1; int y = anObject.field2; anObject.field3 = x + y; //commit value of field3 to main memory } // release lock moreCode();

When are actions visible to other thread?

What does volatile mean? • C/C++ spec --There is no implementation independent meaning of volatile • Situation a little better with Java Technology --volatile reads/writes guaranteed to go directly to main memory e.g. can’t be cached in registers or local memory

Using volatile • Volatile used to guarantee visibility of writes --stop() must be declared volatile --Otherwise, compiler could keep in register class Animator implements Runnable { private volatile boolean stop = false; public void stop() { stop = true;} public void run() { while (!stop) oneStep(); } private void oneStep() {/*……*/} }

Some problems of current Java Memory Model • Some JVMs do not implement volatile correctly • There are some corner cases • Experts are trying to fix the current JMM

Java Thread and Memory Model