1

Chapter 16 – Multithreading
Outline
16.1 Introduction
16.2 Thread States: Life Cycle of a Thread
16.3 Thread Priorities and Thread Scheduling
16.4 Creating and Executing Threads
16.5 Thread Synchronization
16.6 Producer/Consumer Relationship without
Synchronization
16.7 Producer/Consumer Relationship with
Synchronization
16.8 Producer/Consumer Relationship: Circular Buffer
16.9 Daemon Threads
16.10 Runnable Interface
16.12 Discovering Design Patterns: Concurrent Design
Patterns

 2003 Prentice Hall, Inc. All rights reserved.

 2

16.1 Introduction

• Concurrency = performing operations in parallel

• Computer supports concurrency with multiple
processors
• Single processor computers simulate concurrency
(time slicing)
• Ada was first major programming language to
support concurrency
• Standard C and C++ do not
• Java provides built-in multithreading
– “Threads of execution” improve the performance of some
programs
 2003 Prentice Hall, Inc. All rights reserved.
 3

16.1 Introduction

• Thread class is in [Link]

• Examples of threads
– Search multiple files for the same item
– Continue to run applet while image, sound, or video file is
loading
• Threads may be synchronized
• Garbage collection is done via thread in Java
• Thread behavior not as portable as we would like
(usually because of underlying operating system)
• Each thread has a priority

 2003 Prentice Hall, Inc. All rights reserved.

 4
16.2 Thread States: Life Cycle of a
Thread
• Thread states
– Born state
• Thread has been created
– Ready (Runnable) state
• Thread’s start method invoked
• Thread can now execute
– Running state
• Thread is assigned a processor and running (dispatching the
thread)
– Dead state
• Thread has completed or exited
• Eventually disposed of by system

 2003 Prentice Hall, Inc. All rights reserved.

 5
16.2 Thread States: Life Cycle of a
Thread
• Thread states
– Blocked state
• Thread must wait on something
– Waiting state
• Thread waits on notification from another thread
– Sleeping state
• Thread waits until designated sleep time expires

 2003 Prentice Hall, Inc. All rights reserved.

 6

Fig. 16.1 Thread life-cycle statechart diagram

Born

start

Ready

thread dispatch
quantum expiration (assign a
yield processor)
timeout expires

I/O completes
notifyAll

interrupt

interrupt
acquire lock
notify

en
Running te
r
iss stasyn
re ue t e c hr
qu I m on

co m
e s /O en iz
it
p
t t ed
ee

wa

ple
sl

te
Waiting Sleeping Blocked

sleep interval When a thread completes

expires (returns from its run method),
interrupt it reaches the Dead state
(shown here as the final
state)

 2003 Prentice Hall, Inc. All rights reserved.

 7
16.3 Thread Priorities and Thread
Scheduling
• Java thread priority
– Priority in range 1-10
– Threads with higher priority more important, should be
allocated processor time before lower priority threads
• Timeslicing
– Each thread assigned time on the processor (called a
quantum)
• Thread scheduler keeps highest priority thread(s)
running
• Starvation = lower priority threads never get run

 2003 Prentice Hall, Inc. All rights reserved.

 8

Fig. 16.2 Thread priority scheduling example

Ready threads

Thread.MAX_PRIORITY Priority 10 A B

Priority 9 C

Priority 8

Priority 7 D E F

Priority 6 G

Thread.NORM_PRIORITY Priority 5 H I

Priority 4

Priority 3

Priority 2 J K

Thread.MIN_PRIORITY Priority 1

 2003 Prentice Hall, Inc. All rights reserved.

 9

16.4 Creating and Executing Threads

• Threads must be started via start() and must

have a run() method
• Sleep state
– Thread method sleep called
– Thread sleeps for a set time interval (int
milliseconds) then awakens
– While sleeping a thread might throw an
InterruptedException
• Good idea to name all threads (for debugging and
in case of run time errors)
• Program that starts thread(s) will not terminate
until last thread dies
 2003 Prentice Hall, Inc. All rights reserved.
 10
1 // Fig. 16.3: [Link] Outline
2 // Multiple threads printing at different intervals.
3
4 public class ThreadTester { [Link]
5
6 public static void main( String [] args )
va
7 {
8 // create and name each thread Lines 9-11
9 PrintThread thread1 = new PrintThread( "thread1" ); create three
10 PrintThread thread2 = new PrintThread( "thread2" );
Lines 15-17
PrintThreads
11 PrintThread thread3 = new PrintThread( "thread3" );
12
13 [Link]( "Starting threads" );
14
15 [Link](); // start thread1 and place it in ready state
16 [Link](); // start thread2 and place it in ready state call start methods
17 [Link](); // start thread3 and place it in ready state
18
19 [Link]( "Threads started, main ends\n" );
20
21 } // end main
22
23 } // end class ThreadTester
24

 2003 Prentice Hall, Inc.

All rights reserved.
 11
25 // class PrintThread controls thread execution Outline
26 class PrintThread extends Thread {
27 private int sleepTime;
28 [Link]
29 // assign name to thread by calling superclass constructor PrintThread
va
30 public PrintThread( String name )
extends Thread
31 {
32 super( name ); Line 26
33
34 // pick random sleep time between 0 and 5 seconds
Line 35
35 sleepTime = ( int ) ( [Link]() * 5001 );
36 } Constructor initializes
37 Line 39
sleepTime to 0-
38 // method run is the code to be executed by new thread
39 public void run() 5000
40 { When the thread
41 // put thread to sleep for sleepTime amount of time enters the running
42 try {
state, run is called
43 [Link](
44 getName() + " going to sleep for " + sleepTime );
45
46 [Link]( sleepTime );
47 }
48

 2003 Prentice Hall, Inc.

All rights reserved.
 12
49 // if thread interrupted during sleep, print stack trace Outline
50 catch ( InterruptedException exception ) {
51 [Link]();
52 } [Link]
53
54 // print thread name
va
55 [Link]( getName() + " done sleeping" );
56
57 } // end method run
58
59 } // end class PrintThread

Starting threads
Threads started, main ends

thread1 going to sleep for 1217

thread2 going to sleep for 3989
thread3 going to sleep for 662
thread3 done sleeping
thread1 done sleeping
thread2 done sleeping

 2003 Prentice Hall, Inc.

All rights reserved.
 13
Outline
Starting threads
thread1 going to sleep for 314
thread2 going to sleep for 1990 [Link]
Threads started, main ends
va
thread3 going to sleep for 3016
thread1 done sleeping
thread2 done sleeping
thread3 done sleeping

 2003 Prentice Hall, Inc.

All rights reserved.
 14

16.5 Thread Synchronization

• Multiple threads may share an object (database,

printer, buffer, …) and may need to be
synchronized
• Java uses monitors for thread synchronization
• The sychronized keyword
– Every synchronized method of an object has a monitor
– One thread inside a synchronized method at a time
– All other threads block until method finishes
– Next highest priority thread runs when method finishes
– Thread can wait to allow other synchronized threads to run
– Thread can notify waiting threads or notifyAll

 2003 Prentice Hall, Inc. All rights reserved.

 15
16.6 Producer/Consumer
Relationship without Synchronization
• Buffer
– Shared memory region
• Producer thread
– Calls wait if consumer has not read previous message in
buffer
– Writes to empty buffer and calls notify for consumer
• Consumer thread
– Calls wait if buffer empty or unchanged
– Reads data from buffer and calls notify for producer
• Without synchronization
– Produced data might not be consumed
– Some data might be consumed multiple times
 2003 Prentice Hall, Inc. All rights reserved.
 16
1 // Fig. 16.4: [Link] Outline
2 // Buffer interface specifies methods called by Producer and Consumer.
3
4 public interface Buffer { [Link]
5 public void set( int value ); // place value into Buffer
6 public int get(); // return value from Buffer
7 }

 2003 Prentice Hall, Inc.

All rights reserved.
 17
1 // Fig. 16.5: [Link] Outline
2 // Producer's run method controls a thread that
3 // stores values from 1 to 4 in sharedLocation.
4 Producer
[Link]
extends
5 public class Producer extends Thread {
6 private Buffer sharedLocation; // reference to shared object
Thread
7 Line 5
8 // constructor
This is a shared object
9 public Producer( Buffer shared ) Line 6
10 {
11 super( "Producer" );
12 sharedLocation = shared;
Line 16
13 }
14 Lines 22-23
15 // store values from 1 to 4 in sharedLocation
16 public void run() Method run is overridden
17 {
18 for ( int count = 1; count <= 4; count++ ) {
19
20 // sleep 0 to 3 seconds, then place value in Buffer
21 try {
22 [Link]( ( int ) ( [Link]() * 3001 ) ); The thread goes to sleep,
23 [Link]( count ); then the buffer is set
24 }
25

 2003 Prentice Hall, Inc.

All rights reserved.
 18
26 // if sleeping thread interrupted, print stack trace Outline
27 catch ( InterruptedException exception ) {
28 [Link]();
29 } [Link]
30
31 } // end for
32
33 [Link]( getName() + " done producing." +
34 "\nTerminating " + getName() + ".");
35
36 } // end method run
37
38 } // end class Producer

 2003 Prentice Hall, Inc.

All rights reserved.
 19
1 // Fig. 16.6: [Link] Outline
2 // Consumer's run method controls a thread that loops four
3 // times and reads a value from sharedLocation each time.
4 Consumer
[Link]
extends
5 public class Consumer extends Thread {
6 private Buffer sharedLocation; // reference to shared object
Thread
7 Line 5
8 // constructor
This is a shared object
9 public Consumer( Buffer shared ) Line 6
10 {
11 super( "Consumer" );
12 sharedLocation = shared;
Line 16
13 }
14 Lines 24-25
15 // read sharedLocation's value four times and sum the values
16 public void run() Method run is overridden
17 {
18 int sum = 0;
19
20 for ( int count = 1; count <= 4; count++ ) {
21
22 // sleep 0 to 3 seconds, read value from Buffer and add to sum
23 try {
24 [Link]( ( int ) ( [Link]() * 3001 ) ); The thread goes to sleep,
25 sum += [Link](); then the buffer is read
26 }
27

 2003 Prentice Hall, Inc.

All rights reserved.
 20
28 // if sleeping thread interrupted, print stack trace Outline
29 catch ( InterruptedException exception ) {
30 [Link]();
31 } [Link]
32 }
33
34 [Link]( getName() + " read values totaling: " + sum +
35 ".\nTerminating " + getName() + ".");
36
37 } // end method run
38
39 } // end class Consumer

 2003 Prentice Hall, Inc.

All rights reserved.
 21
1 // Fig. 16.7: [Link] Outline
2 // UnsynchronizedBuffer represents a single shared integer.
3
4 public class UnsynchronizedBuffer implements Buffer {
This class implements the
UnsynchronizedB
Buffer interface
5 private int buffer = -1; // shared by producer and consumer threads
6
[Link]
7 // place value into buffer
8 public void set( int value )
The data is a single
Line 4integer
9 {
10 [Link]( [Link]().getName() + This method sets
Linethe
5 value
11 " writes " + value ); in the buffer
12
13 buffer = value; Lines 8 and 13
14 }
15 Lines 17 and 22
16 // return value from buffer
17 public int get()
18 {
19 [Link]( [Link]().getName() +
This method reads the
20 " reads " + buffer );
21
value in the buffer
22 return buffer;
23 }
24
25 } // end class UnsynchronizedBuffer

 2003 Prentice Hall, Inc.

All rights reserved.
 22
1 // Fig. 16.8: [Link] Outline
2 // SharedBufferTest creates producer and consumer threads.
3
4 public class SharedBufferTest { SharedBufferTes
5
6 public static void main( String [] args )
[Link]
7 {
8 // create shared object used by threads Line 9
9 Buffer sharedLocation = new UnsynchronizedBuffer(); Create a Buffer object
10
Lines 12-13
11 // create producer and consumer objects
12 Producer producer = new Producer( sharedLocation ); Create a Producer and a
13 Consumer consumer = new Consumer( sharedLocation ); Lines 15-16
Consumer
14
15 [Link](); // start producer thread
16 [Link](); // start consumer thread Start the Producer and
17 Consumer threads
18 } // end main
19
20 } // end class SharedCell

 2003 Prentice Hall, Inc.

All rights reserved.
 23
Outline
Consumer reads -1
Producer writes 1
Consumer reads 1 SharedBufferTes
Consumer reads 1
Consumer reads 1
[Link]
Consumer read values totaling: 2.
Terminating Consumer.
Producer writes 2
Producer writes 3
Producer writes 4
Producer done producing.
Terminating Producer.

Producer writes 1
Producer writes 2
Consumer reads 2
Producer writes 3
Consumer reads 3
Producer writes 4
Producer done producing.
Terminating Producer.
Consumer reads 4
Consumer reads 4
Consumer read values totaling: 13.
Terminating Consumer.

 2003 Prentice Hall, Inc.

All rights reserved.
 24
Outline
Producer writes 1
Consumer reads 1
Producer writes 2 SharedBufferTes
Consumer reads 2
Producer writes 3
[Link]
Consumer reads 3
Producer writes 4
Producer done producing.
Terminating Producer.
Consumer reads 4
Consumer read values totaling: 10.
Terminating Consumer.

 2003 Prentice Hall, Inc.

All rights reserved.
 25
16.7 Producer/Consumer
Relationship with Synchronization
• Synchronize threads to ensure correct data
– Consumer consumes only after producer produces
– Producer produces only after consumer consumes

 2003 Prentice Hall, Inc. All rights reserved.

 26
1 // Fig. 16.9: [Link] This class implementsOutline
the
2 // SynchronizedBuffer synchronizes access to a single shared integer. Buffer interface
3
4 public class SynchronizedBuffer implements Buffer { SynchronizedBuf
5 private int buffer = -1; // shared by producer and consumer threads
Remember the number of
[Link]
6 private int occupiedBufferCount = 0; // count of occupied buffers
7 filled spaces
8 // place value into buffer Line 4
Method set is declared
9 public synchronized void set( int value )
10 { synchronized
Line 6
11 // for output purposes, get name of thread that called this method
12 String name = [Link]().getName(); Get the name of the thread
13 Line 9
14 // while there are no empty locations, place thread in waiting state
15 while ( occupiedBufferCount == 1 ) { Line 12
16
17 // output thread information and buffer information, then wait
18 try { Wait while the Lines
buffer15
is and
filled21
19 [Link]( name + " tries to write." );
20 displayState( "Buffer full. " + name + " waits." );
21 wait();
22 }
23
24 // if waiting thread interrupted, print stack trace
25 catch ( InterruptedException exception ) {
26 [Link]();
27 }

 2003 Prentice Hall, Inc.

All rights reserved.
 27
28 Outline
29 } // end while
30
31 buffer = value; // set new buffer value Write to the buffer
SynchronizedBuf
32
33 // indicate producer cannot store another value
[Link]
34 // until consumer retrieves current buffer value
35 ++occupiedBufferCount; Line 31
Increment the buffer count
36
37 displayState( name + " writes " + buffer );
Line 35
38
39 notify(); // tell waiting thread to enter ready state Alert a waiting thread
40 Line 39
41 } // end method set; releases lock on SynchronizedBuffer
42 Line 44
43 // return value from buffer
Method get is declared
44 public synchronized int get()
45 {
Line 47
synchronized
46 // for output purposes, get name of thread that called this method
47 String name = [Link]().getName(); Get the name of the thread
48

 2003 Prentice Hall, Inc.

All rights reserved.
 28
49 // while no data to read, place thread in waiting state Outline
50 while ( occupiedBufferCount == 0 ) {
51
52 // output thread information and buffer information, then wait SynchronizedBuf
53 try { Wait while the buffer is empty
54 [Link]( name + " tries to read." );
[Link]
55 displayState( "Buffer empty. " + name + " waits." );
56 wait(); Lines 50 and 56
57 }
58
Line 68
59 // if waiting thread interrupted, print stack trace
60 catch ( InterruptedException exception ) {
61 [Link](); Line 72
62 }
63 Line 74
64 } // end while
65
66 // indicate that producer can store another value
67 // because consumer just retrieved buffer value
68 --occupiedBufferCount; Decrement the buffer count
69
70 displayState( name + " reads " + buffer );
71
72 notify(); // tell waiting thread to become ready to execute Alert a waiting thread
73
74 return buffer; Return the buffer

 2003 Prentice Hall, Inc.

All rights reserved.
 29
75 Outline
76 } // end method get; releases lock on SynchronizedBuffer
77
78 // display current operation and buffer state SynchronizedBuf
79 public void displayState( String operation )
80 {
[Link]
81 StringBuffer outputLine = new StringBuffer( operation );
82 [Link]( 40 );
83 [Link]( buffer + "\t\t" + occupiedBufferCount );
84 [Link]( outputLine );
85 [Link]();
86 }
87
88 } // end class SynchronizedBuffer

 2003 Prentice Hall, Inc.

All rights reserved.
 30
1 // Fig. 16.10: [Link] Outline
2 // SharedBufferTest2creates producer and consumer threads.
3
4 public class SharedBufferTest2 { SharedBufferTes
5
6 public static void main( String [] args )
[Link]
7 { Create a Buffer object
8 // create shared object used by threads; we use a SynchronizedBuffer Line 11
9 // reference rather than a Buffer reference so we can invoke
10 // SynchronizedBuffer method displayState from main
Line 19
11 SynchronizedBuffer sharedLocation = new SynchronizedBuffer();
12
13 // Display column heads for output Lines 22-23
14 StringBuffer columnHeads = new StringBuffer( "Operation" );
15 [Link]( 40 );
16 [Link]( "Buffer\t\tOccupied Count" );
17 [Link]( columnHeads );
18 [Link]();
19 [Link]( "Initial State" ); Output initial state
20
21 // create producer and consumer objects
22 Producer producer = new Producer( sharedLocation ); Create a Producer and a
23 Consumer consumer = new Consumer( sharedLocation ); Consumer
24

 2003 Prentice Hall, Inc.

All rights reserved.
 31
25 [Link](); // start producer thread Outline
26 [Link](); // start consumer thread Start the Producer and
27 Consumer threads
28 } // end main SharedBufferTes
29
30 } // end class SharedBufferTest2
[Link]

Lines 25-26
Operation Buffer Occupied Count

Initial State -1 0

Consumer tries to read.

Buffer empty. Consumer waits. -1 0

Producer writes 1 1 1

Consumer reads 1 1 0

Consumer tries to read.

Buffer empty. Consumer waits. 1 0

Producer writes 2 2 1

Consumer reads 2 2 0

Producer writes 3 3 1

 2003 Prentice Hall, Inc.

All rights reserved.
 32
Outline
Consumer reads 3 3 0

Consumer tries to read. SharedBufferTes

Buffer empty. Consumer waits. 3 0
[Link]
Producer writes 4 4 1

Consumer reads 4 4 0
Producer done producing.
Terminating Producer.

Consumer read values totaling: 10.

Terminating Consumer.

Operation Buffer Occupied Count

Initial State -1 0

Consumer tries to read.

Buffer empty. Consumer waits. -1 0

Producer writes 1 1 1

Consumer reads 1 1 0

Producer writes 2 2 1
 2003 Prentice Hall, Inc.
All rights reserved.
 33
Producer tries to write. Outline
Buffer full. Producer waits. 2 1

Consumer reads 2 2 0 SharedBufferTes

Producer writes 3 3 1
[Link]

Consumer reads 3 3 0

Producer writes 4 4 1

Producer done producing.

Terminating Producer.
Consumer reads 4 4 0

Consumer read values totaling: 10.

Terminating Consumer.

Operation Buffer Occupied Count

Initial State -1 0

Producer writes 1 1 1

Consumer reads 1 1 0

Producer writes 2 2 1

 2003 Prentice Hall, Inc.

All rights reserved.
 34
Consumer reads 2 2 0 Outline
Producer writes 3 3 1
SharedBufferTes
Consumer reads 3 3 0
[Link]
Producer writes 4 4 1

Producer done producing.

Terminating Producer.
Consumer reads 4 4 0

Consumer read values totaling: 10.

Terminating Consumer.

 2003 Prentice Hall, Inc.

All rights reserved.
 35
16.8 Producer/Consumer
Relationship: Circular Buffer
• Circular buffer
– Multiple memory cells (more efficient than one)
– Produce item if one or more empty cells
– Consume item if one or more filled cells
• [Link] goes back
to event-dispatching thread (used in this example
to update GUI component appropriately)

 2003 Prentice Hall, Inc. All rights reserved.

 36
1 // Fig. 16.11: [Link] Outline
2 // Class RunnableOutput updates JTextArea with output
3 import [Link].*;
4 RunnableOutput.
This class implements the
5 public class RunnableOutput implements Runnable {
6 private JTextArea outputArea;
java
Runnable interface
7 private String messageToAppend;
8 Line 5
9 // initialize outputArea and message
10 public RunnableOutput( JTextArea output, String message )
Line 17
11 {
12 outputArea = output;
13 messageToAppend = message;
14 }
15
16 // method called by [Link] to update outputArea
17 public void run() Declare method run
18 {
19 [Link]( messageToAppend );
20 }
21
22 } // end class RunnableOutput

 2003 Prentice Hall, Inc.

All rights reserved.
 37
1 // Fig. 16.12: [Link] Outline
2 // Producer’s run method controls a thread that
3 // stores values from 11 to 20 in sharedLocation.
4 import [Link].*; [Link]
5
6 public class Producer extends Thread {
7 private Buffer sharedLocation; Lines 21 and 26
8 private JTextArea outputArea;
9
10 // constructor
11 public Producer( Buffer shared, JTextArea output )
12 {
13 super( "Producer" );
14 sharedLocation = shared;
15 outputArea = output;
16 }
17
18 // store values from 11-20 and in sharedLocation's buffer
19 public void run()
20 {
21 for ( int count = 11; count <= 20; count ++ ) {
22
Write the values from 11 to
23 // sleep 0 to 3 seconds, then place value in Buffer
24 try {
20 to the buffer
25 [Link]( ( int ) ( [Link]() * 3000 ) );
26 [Link]( count );
27 }

 2003 Prentice Hall, Inc.

All rights reserved.
 38
28 Outline
29 // if sleeping thread interrupted, print stack trace
30 catch ( InterruptedException exception ) {
31 [Link](); [Link]
32 }
33 }
34 Lines 36-37
35 String name = getName();
36 [Link]( new RunnableOutput( outputArea, "\n" +
37 name + " done producing.\n" + name + " terminated.\n" ) );
38
39 } // end method run
40
41 } // end class Producer

Update the output

 2003 Prentice Hall, Inc.

All rights reserved.
 39
1 // Fig. 16.13: [Link] Outline
2 // Consumer’s run method controls a thread that loops ten
3 // times and reads a value from sharedLocation each time.
4 import [Link].*; [Link]
5
6 public class Consumer extends Thread {
7 private Buffer sharedLocation; // reference to shared object
8 private JTextArea outputArea;
9
10 // constructor
11 public Consumer( Buffer shared, JTextArea output )
12 {
13 super( "Consumer" );
14 sharedLocation = shared;
15 outputArea = output;
16 }
17
18 // read sharedLocation's value ten times and sum the values
19 public void run()
20 {
21 int sum = 0;
22
23 for ( int count = 1; count <= 10; count++ ) {
24

 2003 Prentice Hall, Inc.

All rights reserved.
 40
25 // sleep 0 to 3 seconds, read value from Buffer and add to sum Outline
26 try {
27 [Link]( ( int ) ( [Link]() * 3001 ) );
28 sum += [Link]();
Read the value
[Link]
from the buffer
29 }
30
31 // if sleeping thread interrupted, print stack trace Line 28
32 catch ( InterruptedException exception ) {
33 [Link](); Lines 38-40
34 }
35 }
36
37 String name = getName();
38 [Link]( new RunnableOutput( outputArea,
39 "\nTotal " + name + " consumed: " + sum + ".\n" +
40 name + " terminated.\n ") );
41
42 } // end method run
43
44 } // end class Consumer
Update the output

 2003 Prentice Hall, Inc.

All rights reserved.
 41
1 // Fig. 16.14: [Link] Outline
2 // CircularBuffer synchronizes access to an array of shared buffers.
3 import [Link].*;
4 CircularBuffer.
5 public class CircularBuffer implements Buffer {
6
java
7 // each array element is a buffer
The data is an array of
8 private int buffers[] = { -1, -1, -1 }; Line 8
9
three integers
10 // occupiedBufferCount maintains count of occupied buffers
Line 11 of
Remember the number
11 private int occupiedBufferCount = 0;
12
filled spaces
13 // variables that maintain read and write buffer locations Line 14
Remember the read and
14 private int readLocation = 0, writeLocation = 0;
15 write positions
16 // reference to GUI component that displays output
17 private JTextArea outputArea;
18
19 // constructor
20 public CircularBuffer( JTextArea output )
21 {
22 outputArea = output;
23 }
24

 2003 Prentice Hall, Inc.

All rights reserved.
 42
25 // place value into buffer
Method set is declared Outline
26 public synchronized void set( int value )
27 {
synchronized
28 // for output purposes, get name of thread that called this method CircularBuffer.
29 String name = [Link]().getName();
30
java
31 // while there are no empty locations, place thread in waiting state
32 while ( occupiedBufferCount == [Link] ) { Check Line
if the 26 is full
buffer
33
34 // output thread information and buffer information, then wait
Line 32
35 try {
36 [Link]( new RunnableOutput( outputArea,
37 "\nAll buffers full. " + name + " waits." ) ); Lines 36-37
38 wait();
39 } Line 50
40
41 // if waiting thread interrupted, print stack trace
42 catch ( InterruptedException exception ) Update the output
43 {
44 [Link]();
45 }
46
47 } // end while
48
49 // place value in writeLocation of buffers
50 buffers[ writeLocation ] = value; Write to the buffer
51

 2003 Prentice Hall, Inc.

All rights reserved.
 43
52 // update Swing GUI component with produced value Outline
53 [Link]( new RunnableOutput( outputArea,
54 "\n" + name + " writes " + buffers[ writeLocation ] + " ") ); Update the output
55 CircularBuffer.
56 // just produced a value, so increment number of occupied buffers
57 ++occupiedBufferCount; Increment thejava
buffer count
58
59 // update writeLocation for future write operation Lines 53-54
60 writeLocation = ( writeLocation + 1 ) % [Link]; Update the write location
61
Line 57
62 // display contents of shared buffers
63 [Link]( new RunnableOutput( Update the output
64 outputArea, createStateOutput() ) ); Line 60
65
66 notify(); // return waiting thread (if there is one) to ready state Alert aLines
waiting thread
63-64
67
68 } // end method set
69
Line 66
70 // return value from buffer
Method get isLine
declared
71
71 public synchronized int get()
72 { synchronized
73 // for output purposes, get name of thread that called this method
74 String name = [Link]().getName();
75

 2003 Prentice Hall, Inc.

All rights reserved.
 44
76 // while no data to read, place thread in waiting state Outline
77 while ( occupiedBufferCount == 0 ) { Check if the buffer is empty
78
79 // output thread information and buffer information, then wait CircularBuffer.
80 try {
81 [Link]( new RunnableOutput( outputArea,
java
82 "\nAll buffers empty. " + name + " waits.") );
83 wait(); Line 77
84 }
85
Lines 81-82
86 // if waiting thread interrupted, print stack trace Update the output
87 catch ( InterruptedException exception ) {
88 [Link](); Line 94
89 }
90 Lines 97-98
91 } // end while
92
93 // obtain value at current readLocation
Line 101
94 int readValue = buffers[ readLocation ]; Read a value from the buffer
95
96 // update Swing GUI component with consumed value
97 [Link]( new RunnableOutput( outputArea,
98 "\n" + name + " reads " + readValue + " ") ); Update the output
99
100 // just consumed a value, so decrement number of occupied buffers
101 --occupiedBufferCount; Decrement the buffer count
102

 2003 Prentice Hall, Inc.

All rights reserved.
 45
103 // update readLocation for future read operation Outline
104 readLocation = ( readLocation + 1 ) % [Link]; Update the read location
105
106 // display contents of shared buffers CircularBuffer.
107 [Link]( new RunnableOutput( Update the output
java
108 outputArea, createStateOutput() ) );
109
110 notify(); // return waiting thread (if there is one) to ready state Alert aLine 104 thread
waiting
111
112 return readValue; Return a valueLines
from 107-108
the buffer
113
114 } // end method get
115 Line 110
116 // create state output
117 public String createStateOutput() Line 112
118 {
119 // first line of state information
120 String output =
121 "(buffers occupied: " + occupiedBufferCount + ")\nbuffers: ";
122
123 for ( int i = 0; i < [Link]; i++ )
124 output += " " + buffers[ i ] + " ";
125
126 // second line of state information
127 output += "\n ";
128

 2003 Prentice Hall, Inc.

All rights reserved.
 46
129 for ( int i = 0; i < [Link]; i++ ) Outline
130 output += "---- ";
131
132 // third line of state information CircularBuffer.
133 output += "\n ";
134
java
135 // append readLocation (R) and writeLocation (W)
136 // indicators below appropriate buffer locations
137 for ( int i = 0; i < [Link]; i++ )
138
139 if ( i == writeLocation && writeLocation == readLocation )
140 output += " WR ";
141 else if ( i == writeLocation )
142 output += " W ";
143 else if ( i == readLocation )
144 output += " R ";
145 else
146 output += " ";
147
148 output += "\n";
149
150 return output;
151
152 } // end method createStateOutput
153
154 } // end class CircularBuffer

 2003 Prentice Hall, Inc.

All rights reserved.
 47
1 // Fig. 16.15: [Link] Outline
2 // CircularBufferTest shows two threads manipulating a circular buffer.
3 import [Link].*;
4 import [Link].*; CircularBufferT
5 import [Link].*;
6
[Link]
7 // set up the producer and consumer threads and start them
8 public class CircularBufferTest extends JFrame { Line 26
9 JTextArea outputArea;
10
11 // set up GUI
12 public CircularBufferTest()
13 {
14 super( "Demonstrating Thread Synchronizaton" );
15
16 outputArea = new JTextArea( 20,30 );
17 [Link]( new Font( "Monospaced", [Link], 12 ) );
18 getContentPane().add( new JScrollPane( outputArea ) );
19
20 setSize( 310, 500 );
21 setVisible( true );
22 Create a Buffer object
23 // create shared object used by threads; we use a CircularBuffer
24 // reference rather than a Buffer reference so we can invoke
25 // CircularBuffer method createStateOutput
26 CircularBuffer sharedLocation = new CircularBuffer( outputArea );
27

 2003 Prentice Hall, Inc.

All rights reserved.
 48
28 // display initial state of buffers in CircularBuffer Outline
29 [Link]( new RunnableOutput( outputArea,
30 [Link]() ) ); Update the output
31 CircularBufferT
32 // set up threads
33 Producer producer = new Producer( sharedLocation, outputArea ); [Link]
a Producer and a
34 Consumer consumer = new Consumer( sharedLocation, outputArea ); Consumer
35 Lines 29-30
36 [Link](); // start producer thread Start the Producer and
37 [Link](); // start consumer thread Consumer threads
Lines 33-34
38
39 } // end constructor
40 Lines 36-37
41 public static void main ( String args[] )
42 { Line
Create an 43
instance of this
43 CircularBufferTest application = new CircularBufferTest();
class
44 [Link]( JFrame.EXIT_ON_CLOSE );
45 }
46
47 } // end class CirclularBufferTest

 2003 Prentice Hall, Inc.

All rights reserved.
 49
Outline

CircularBufferT
[Link]

Value placed in last

buffer. Next value will be
deposited in first buffer.

 2003 Prentice Hall, Inc.

All rights reserved.
 50
Outline

CircularBufferT
[Link]

Circular buffer effect—the

fourth value is deposited
in the first buffer.

Value placed in last

buffer. Next value will be
deposited in first buffer.

Circular buffer effect—the

seventh value is deposited
in the first buffer.

 2003 Prentice Hall, Inc.

All rights reserved.
 51
Outline

CircularBufferT
[Link]

Value placed in last

buffer. Next value will be
deposited in first buffer.

Circular buffer effect—the

tenth value is deposited in
the first buffer.

 2003 Prentice Hall, Inc.

All rights reserved.
 52
Outline

CircularBufferT
[Link]

 2003 Prentice Hall, Inc.

All rights reserved.
 53

16.9 Daemon Threads

• Run for benefit of other threads

– Do not prevent program from terminating
– Garbage collector is a daemon thread
• Set daemon thread with method call
[Link](true)

 2003 Prentice Hall, Inc. All rights reserved.

 54

16.10 Runnable Interface

• A class cannot extend more than one class

• Implement Runnable for multithreading support
– public class UserInfo extends JFrame
implements Runnable
{
Thread st;
…
[Link]();
…
public void run()
{…}
}

 2003 Prentice Hall, Inc. All rights reserved.

 55
16.12 Discovering Design Patterns:
Concurrent Design Patterns
• Concurrency Design Patterns
– Single-Threaded Execution design pattern
• Stops several threads from invoking a method concurrently
(synchronized)
– Guarded Suspension design pattern
• Suspends and resumes a thread’s activity when a condition
met (wait and notify)
– Balking design pattern
• Causes method to balk if an object occupies a certain state
(wait or throw exception)

 2003 Prentice Hall, Inc. All rights reserved.

 56
16.12 Discovering Design Patterns:
Concurrent Design Patterns
• Concurrency Design Patterns
– Read/Write Lock design pattern
• Multiple read on an object but exclusive write (wait and
notify)
– Two-Phase Termination design pattern
• Uses two-phase termination process to ensure resources freed
(can be done in run method)

 2003 Prentice Hall, Inc. All rights reserved.