Java Thread and Memory Model

1
Java Thread and Memory Model

• By Xijun Zhang
• 104549

2
Question

• Can this result in i 0 and j 0?

3
Contents

• Thread review
• Threads in Java
• Programmers view of Java memory model

4
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

5
Single Threaded and Multithreaded Process Models

• Thread Control Block contains a register image,
  thread priority and thread state information

6
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

7
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

8
Java Thread Support Reside in Three Places

• The java.lang.Thread class
• The java.lang.Object class
• The Java language and virtual machine

9
Two ways to create threads

• Extending the java.lang.Thread class
• Implementing the java.lang.Runnable interface

10
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

11
Interface Runnable

• Extending Thread means cant 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)

12
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

13
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

14
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

15
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

16
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)

17
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

18
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

19
Using notify

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

20
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 arent surprised by the
  order in which statements are executed

21
Question

• Can this result in i0 and j0?

22
Answer Yes!

• How can i0 and j0?

23
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.

24
Low level actions
25
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

26
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()

27
When are actions visible to other thread?
28
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. cant be cached in registers or local
  memory

29
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() //

30
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