Chapter 16 - Multithreading: Runnable Interface

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.11 (Optional Case Study) Thinking About Objects:
Multithreading
16.12 (Optional) Discovering Design Patterns: Concurrent Design
Patterns
 2003 Prentice Hall, Inc. All rights reserved.

16.1 Introduction
• Concurrency normally available in OS primitives

• Java provides built-in multithreading
– Multithreading improves the performance of some programs

16.2 Thread States: Life Cycle of a Thread
• Thread states
– Born state
• Thread was just created
– Ready state
• Thread’s start method invoked
• Thread can now execute
– Running state
• Thread is assigned a processor and running
– Dead state
• Thread has completed or exited
• Eventually disposed of by system

Fig. 16.1 Thread life-cycle statechart diagram
Born
start
Ready
thread dispatch
quantum expiration (assign a
yield
timeout expires
processor)
I/O completes
interrupt
notifyAll
interrupt
acquire lock
notify
Running
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)

16.3 Thread Priorities and Thread
Scheduling
• Java thread priority
– Priority in range 1-10
• Timeslicing
– Each thread assigned time on the processor (called a
quantum)
– Keeps highest priority threads running

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

16.4 Creating and Executing Threads
• Sleep state
– Thread method sleep called
– Thread sleeps for a set time interval then awakens

1 // Fig. 16.3: ThreadTester.java Outline
2 // Multiple threads printing at different intervals.
3
4 public class ThreadTester { ThreadTester.ja
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 four
Lines 15-17
PrintThreads
12
13 System.err.println( "Starting threads" );
14
15 thread1.start(); // start thread1 and place it in ready state
16 thread2.start(); // start thread2 and place it in ready state call start methods
17 thread3.start(); // start thread3 and place it in ready state
18
19 System.err.println( "Threads started, main ends\n" );
20
21 } // end main
22
23 } // end class ThreadTester
24
 2003 Prentice Hall, Inc.

All rights reserved.
25 // class PrintThread controls thread execution Outline
26 class PrintThread extends Thread {
27 private int sleepTime;
28 ThreadTester.ja
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 ) ( Math.random() * 5001 );
36 } Constructor initializes
37 Line 39
38 // method run is the code to be executed by new thread
sleepTime
39 public void run()
40 { When the thread
41 // put thread to sleep for sleepTime amount of time enters the running
42 try {
43 System.err.println(
state, run is called
44 getName() + " going to sleep for " + sleepTime );
45
46 Thread.sleep( sleepTime );
47 }
48

49 // if thread interrupted during sleep, print stack trace Outline
50 catch ( InterruptedException exception ) {
51 exception.printStackTrace();
52 } ThreadTester.ja
53
54 // print thread name
va
55 System.err.println( 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

thread3 done sleeping

Outline
Starting threads
thread2 going to sleep for 1990 ThreadTester.ja
Threads started, main ends
va

16.5 Thread Synchronization
• 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

16.6 Producer/Consumer Relationship
without Synchronization
• Buffer
– Shared memory region
• Producer thread
– Generates data to add to buffer
– Calls wait if consumer has not read previous message in
buffer
– Writes to empty buffer and calls notify for consumer
• Consumer thread
– Reads data from buffer
– Calls wait if buffer empty
• Synchronize threads to avoid corrupted data

1 // Fig. 16.4: Buffer.java Outline
2 // Buffer interface specifies methods called by Producer and Consumer.
3
4 public interface Buffer { Buffer.java
5 public void set( int value ); // place value into Buffer
6 public int get(); // return value from Buffer
7 }

1 // Fig. 16.5: Producer.java Outline
2 // Producer's run method controls a thread that
3 // stores values from 1 to 4 in sharedLocation.
4 Producer
Producer.java
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 Thread.sleep( ( int ) ( Math.random() * 3001 ) ); The thread goes to sleep,
23 sharedLocation.set( count );
then the buffer is set
24 }
25

26 // if sleeping thread interrupted, print stack trace Outline
29 } Producer.java
30
31 } // end for
32
33 System.err.println( getName() + " done producing." +
34 "\nTerminating " + getName() + ".");
35
37
38 } // end class Producer

1 // Fig. 16.6: Consumer.java Outline
2 // Consumer's run method controls a thread that loops four
3 // times and reads a value from sharedLocation each time.
4 Consumer
Consumer.java
extends
5 public class Consumer extends Thread {
Thread
7 Line 5
8 // constructor
This is a shared object
9 public Consumer( Buffer shared ) Line 6
10 {
11 super( "Consumer" );
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
21
22 // sleep 0 to 3 seconds, read value from Buffer and add to sum
23 try {
24 Thread.sleep( ( int ) ( Math.random() * 3001 ) ); The thread goes to sleep,
25 sum += sharedLocation.get(); then the buffer is read
26 }
27

28 // if sleeping thread interrupted, print stack trace Outline
31 } Consumer.java
32 }
33
34 System.err.println( getName() + " read values totaling: " + sum +
35 ".\nTerminating " + getName() + ".");
36
38
39 } // end class Consumer

1 // Fig. 16.7: UnsynchronizedBuffer.java 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
uffer.java
7 // place value into buffer
8 public void set( int value )
The data is a single
Line 4integer
9 {
10 System.err.println( Thread.currentThread().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 System.err.println( Thread.currentThread().getName() +
20 " reads " + buffer );
This method reads the
21 value in the buffer
22 return buffer;
23 }
24
25 } // end class UnsynchronizedBuffer

1 // Fig. 16.8: SharedBufferTest.java Outline
2 // SharedBufferTest creates producer and consumer threads.
3
4 public class SharedBufferTest { SharedBufferTes
5
t.java
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
13 Consumer consumer = new Consumer( sharedLocation ); Lines 15-16
a Consumer
14
15 producer.start(); // start producer thread
16 consumer.start(); // start consumer thread Start the Producer and
17 Consumer threads
18 } // end main
19
20 } // end class SharedCell

Outline
Consumer reads -1
Producer writes 1
Consumer reads 1 SharedBufferTes
Consumer reads 1
Consumer reads 1
t.java
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
Consumer reads 4
Consumer reads 4

Outline
Producer writes 1
Consumer reads 1
Producer writes 2 SharedBufferTes
Consumer reads 2
Producer writes 3
t.java
Consumer reads 3
Producer writes 4
Consumer reads 4

16.7 Producer/Consumer Relationship with
Synchronization
• Synchronize threads to ensure correct data

1 // Fig. 16.9: SynchronizedBuffer.java This class implements the
Outline
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
6
Remember
private int occupiedBufferCount = 0; // count of occupied buffers
fer.java
the number of
7 filled spaces
8 // place value into buffer Line 4
9 public synchronized void set( int value )
Method set is declared
10 { synchronized
Line 6
11 // for output purposes, get name of thread that called this method
12 String name = Thread.currentThread().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 and 21
is filled
19 System.err.println( name + " tries to write." );
20 displayState( "Buffer full. " + name + " waits." );
21 wait();
22 }
23
24 // if waiting thread interrupted, print stack trace
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
fer.java
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
44 public synchronized int get()
Method get is declared
45 { synchronized
Line 47
47 String name = Thread.currentThread().getName(); Get the name of the thread
48

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 System.err.println( name + " tries to read." );
fer.java
55 displayState( "Buffer empty. " + name + " waits." );
56 wait(); Lines 50 and 56
57 }
58
Line 68
61 exception.printStackTrace(); 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

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 {
fer.java
81 StringBuffer outputLine = new StringBuffer( operation );
82 outputLine.setLength( 40 );
83 outputLine.append( buffer + "\t\t" + occupiedBufferCount );
84 System.err.println( outputLine );
85 System.err.println();
86 }
87
88 } // end class SynchronizedBuffer

1 // Fig. 16.10: SharedBufferTest2.java Outline
2 // SharedBufferTest2creates producer and consumer threads.
3
4 public class SharedBufferTest2 { SharedBufferTes
5
t2.java
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 columnHeads.setLength( 40 );
16 columnHeads.append( "Buffer\t\tOccupied Count" );
17 System.err.println( columnHeads );
18 System.err.println();
19 sharedLocation.displayState( "Initial State" ); Output initial state
20
21 // create producer and consumer objects
22 Producer producer = new Producer( sharedLocation ); Create a Producer and
23 Consumer consumer = new Consumer( sharedLocation );
a Consumer
24

25 producer.start(); // start producer thread Outline
26 consumer.start(); // start consumer thread Start the Producer and
27 Consumer threads
28 } // end main SharedBufferTes
29
30 } // end class SharedBufferTest2
t2.java
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

Buffer empty. Consumer waits. 1 0

Outline
Consumer tries to read. SharedBufferTes

Buffer empty. Consumer waits. 3 0
t2.java

Initial State -1 0

Buffer empty. Consumer waits. -1 0

Producer tries to write. Outline
Buffer full. Producer waits. 2 1
Consumer reads 2 2 0 SharedBufferTes

t2.java


Initial State -1 0

Consumer reads 2 2 0 Outline
SharedBufferTes
t2.java



16.8 Producer/Consumer Relationship:
Circular Buffer
• Circular buffer
– Multiple memory cells
– Produce item if one or more empty cells
– Consume item if one or more filled cells

1 // Fig. 16.11: RunnableOutput.java Outline
2 // Class RunnableOutput updates JTextArea with output
3 import javax.swing.*;
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 SwingUtilities.invokeLater to update outputArea
17 public void run() Declare method run
18 {
19 outputArea.append( messageToAppend );
20 }
21
22 } // end class RunnableOutput

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

28 Outline
29 // if sleeping thread interrupted, print stack trace
31 exception.printStackTrace(); Producer.java
32 }
33 }
34 Lines 36-37
35 String name = getName();
36 SwingUtilities.invokeLater( new RunnableOutput( outputArea, "\n" +
37 name + " done producing.\n" + name + " terminated.\n" ) );
38
40
41 } // end class Producer
Update the output

1 // Fig. 16.13: Consumer.java Outline
2 // Consumer’s run method controls a thread that loops ten
3 // times and reads a value from sharedLocation each time.
4 import javax.swing.*; Consumer.java
5
6 public class Consumer extends Thread {
9
10 // constructor
11 public Consumer( Buffer shared, JTextArea output )
12 {
13 super( "Consumer" );
16 }
17
18 // read sharedLocation's value ten times and sum the values
20 {
21 int sum = 0;
22
24

25 // sleep 0 to 3 seconds, read value from Buffer and add to sum Outline
26 try {
27 Thread.sleep( ( int ) ( Math.random() * 3001 ) );
28 sum += sharedLocation.get();
Read the value
Consumer.java
from the buffer
29 }
30
31 // if sleeping thread interrupted, print stack trace Line 28
33 exception.printStackTrace(); Lines 38-40
34 }
35 }
36
37 String name = getName();
38 SwingUtilities.invokeLater( new RunnableOutput( outputArea,
39 "\nTotal " + name + " consumed: " + sum + ".\n" +
40 name + " terminated.\n ") );
41
43
44 } // end class Consumer Update the output

1 // Fig. 16.14: CircularBuffer.java Outline
2 // CircularBuffer synchronizes access to an array of shared buffers.
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
Remember the number
Line 11 of
11 private int occupiedBufferCount = 0;
12
filled spaces
13 // variables that maintain read and write buffer locations Line 14
14 private int readLocation = 0, writeLocation = 0;
Remember the read and
15 write positions
16 // reference to GUI component that displays output
18
19 // constructor
20 public CircularBuffer( JTextArea output )
21 {
23 }
24

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 = Thread.currentThread().getName();
30
java
31 // while there are no empty locations, place thread in waiting state
32 while ( occupiedBufferCount == buffers.length ) { Check Line
if the 26 is full
buffer
33
34 // output thread information and buffer information, then wait
Line 32
35 try {
37 "\nAll buffers full. " + name + " waits." ) ); Lines 36-37
38 wait();
39 } Line 50
40
42 catch ( InterruptedException exception ) Update the output
43 {
45 }
46
47 } // end while
48
49 // place value in writeLocation of buffers
50 buffers[ writeLocation ] = value; Write to the buffer
51

52 // update Swing GUI component with produced value Outline
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 ) % buffers.length; Update the write location
61
Line 57
62 // display contents of shared buffers
63 SwingUtilities.invokeLater( 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
Method get is declared
71 public synchronized int get() Line 71
72 { synchronized
74 String name = Thread.currentThread().getName();
75

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 {
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
88 exception.printStackTrace(); 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
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

103 // update readLocation for future read operation Outline
104 readLocation = ( readLocation + 1 ) % buffers.length; Update the read location
105
106 // display contents of shared buffers CircularBuffer.
107 SwingUtilities.invokeLater( 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 < buffers.length; i++ )
124 output += " " + buffers[ i ] + " ";
125
126 // second line of state information
127 output += "\n ";
128

129 for ( int i = 0; i < buffers.length; 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 < buffers.length; 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

1 // Fig. 16.15: CircularBufferTest.java Outline
2 // CircularBufferTest shows two threads manipulating a circular buffer.
3 import java.awt.*;
4 import java.awt.event.*; CircularBufferT
6
est.java
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 outputArea.setFont( new Font( "Monospaced", Font.PLAIN, 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

28 // display initial state of buffers in CircularBuffer Outline
30 sharedLocation.createStateOutput() ) ); Update the output
31 CircularBufferT
32 // set up threads
33 Producer producer = new Producer( sharedLocation, outputArea );
est.java
Create a Producer and
34 Consumer consumer = new Consumer( sharedLocation, outputArea ); a Consumer
35 Lines 29-30
36 producer.start(); // start producer thread Start the Producer and
37 consumer.start(); // 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();
44 application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
class
45 }
46
47 } // end class CirclularBufferTest

Outline
CircularBufferT
est.java
Value placed in last

buffer. Next value will be
deposited in first buffer.

Outline
CircularBufferT
est.java
Circular buffer effect—the

fourth value is deposited
in the first buffer.
Value placed in last buffer.

Next value will be

seventh value is deposited
in the first buffer.

Outline
CircularBufferT
est.java
Value placed in last buffer.

Next value will be

tenth value is deposited in
the first buffer.

Outline
CircularBufferT
est.java

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 setDaemon

16.10 Runnable Interface
• A class cannot extend more than one class

• Implement Runnable for multithreading support

1 // Fig. 16.16: RandomCharacters.java Outline
2 // Class RandomCharacters demonstrates the Runnable interface
3 import java.awt.*;
4 import java.awt.event.*; RandomCharacter
6
s.java
7 public class RandomCharacters extends JApplet implements ActionListener {
8 private String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
9 private final static int SIZE = 3;
10 private JLabel outputs[];
11 private JCheckBox checkboxes[];
12 private Thread threads[];
13 private boolean suspended[];
14
15 // set up GUI and arrays
16 public void init()
17 {
18 outputs = new JLabel[ SIZE ];
19 checkboxes = new JCheckBox[ SIZE ];
20 threads = new Thread[ SIZE ];
21 suspended = new boolean[ SIZE ];
22
23 Container container = getContentPane();
24 container.setLayout( new GridLayout( SIZE, 2, 5, 5 ) );
25

26 // create GUI components, register listeners and attach Outline
27 // components to content pane
28 for ( int count = 0; count < SIZE; count++ ) {
29 outputs[ count ] = new JLabel(); RandomCharacter
30 outputs[ count ].setBackground( Color.GREEN );
31 outputs[ count ].setOpaque( true );
s.java
32 container.add( outputs[ count ] );
33 Line 43
34 checkboxes[ count ] = new JCheckBox( "Suspended" );
35 checkboxes[ count ].addActionListener( this );
Lines 48-49
36 container.add( checkboxes[ count ] );
37 }
38
Applet start51method
Line
39 } // end method init
40
41 // create and start threads each time start is called (i.e., after
Create three Thread
42 // init and when user revists Web page containing this applet)
43 public void start() objects and initialize each
44 { with a RunnableObject
45 for ( int count = 0; count < threads.length; count++ ) {
46
47 // create Thread; initialize object that implements Runnable
48 threads[ count ] =
49 new Thread( new RunnableObject(), "Thread " + ( count + 1 ) );
50
51 threads[ count ].start(); // begin executing Thread
52 } Call thread start
method

53 } Outline
54
55 // determine thread location in threads array
56 private int getIndex( Thread current ) RandomCharacter
57 {
58 for ( int count = 0; count < threads.length; count++ )
s.java
59 if ( current == threads[ count ] )
60 return count; Line 66
61
62 return -1;
Line 70
63 }
64
65 // called when user switches Web pages; stops all threads Line 72
66 public synchronized void stop()
Method stop stops
67 { all threads
68 // set references to null to terminate each thread's run method
69 for ( int count = 0; count < threads.length; count++ ) Set thread references
70 threads[ count ] = null;
in array threads to
71
72 notifyAll(); // notify all waiting threads, so they can terminate
null
Invoke method
73 }
notifyAll to
74
75 // handle button events
ready waiting threads
76 public synchronized void actionPerformed( ActionEvent event )
77 {

78 for ( int count = 0; count < checkboxes.length; count++ ) { Outline
79
80 if ( event.getSource() == checkboxes[ count ] ) {
81 suspended[ count ] = !suspended[ count ]; RandomCharacter
82
// change label color on suspend/resume
s.java
83 Toggle boolean
84 outputs[ count ].setBackground(
value in array
85 suspended[ count ] ? Color.RED : Color.GREEN ); Line 81
86 suspended
87 // if thread resumed, make sure it starts executing
Line 89
88 if ( !suspended[ count ] )
89 notifyAll();
90 Line 98
91 return;
92 } Line 102
93 }
94
95 } // end method actionPerformed
Call notifyAll to
96 start ready threads
97 // private inner class that implements Runnable to control threads
98 private class RunnableObject implements Runnable {
Class RunnableObject
99
100 // place random characters in GUI, variables currentThread and
implements Runnable
101 // index are final so can be used in an anonymous inner class interface
103 {
Declare method run

104 // get reference to executing thread Outline
105 final Thread currentThread = Thread.currentThread();
106
107 // determine thread's position in array RandomCharacter
108 final int index = getIndex( currentThread );
109
s.java
110 // loop condition determines when thread should stop; loop The while loop executes
111 // terminates when reference threads[ index ] becomes null Line 112
112 while ( threads[ index ] == currentThread ) {
as long as the index of
113 array threads equals
Line 120
114 // sleep from 0 to 1 second currentThread
115 try {
116 Thread.sleep( ( int ) ( Math.random() * 1000 ) ); Line 126
117
118 // determine whether thread should suspend execution;
119 // synchronize on RandomCharacters applet object
120 synchronized( RandomCharacters.this ) {
121
The
122 while ( suspended[ index ] &&
123 threads[ index ] == currentThread ) {
synchronized
124 block helps suspend
125 // temporarily suspend thread execution currently executing
126 RandomCharacters.this.wait(); thread
127 }
128 } // end synchronized statement Invoke method wait
on applet to place
thread in waiting
state

129 Outline
130 } // end try
131
132 // if thread interrupted during wait/sleep, print stack trace RandomCharacter
s.java
135 }
136 Line 139
137 // display character on corresponding JLabel
138 SwingUtilities.invokeLater(
139 new Runnable() {
140 Anonymous inner
141 // pick random character and display it class implements
142 public void run() Runnable interface
143 {
144 char displayChar =
145 alphabet.charAt( ( int ) ( Math.random() * 26 ) );
146
147 outputs[ index ].setText(
148 currentThread.getName() + ": " + displayChar );
149 }
150
151 } // end inner class
152
153 ); // end call to SwingUtilities.invokeLater

154 Outline
155 } // end while
156
157 System.err.println( currentThread.getName() + " terminating" ); RandomCharacter
158
s.java
160
161 } // end private inner class RunnableObject
162
163 } // end class RandomCharacters

16.11 (Optional Case Study) Thinking About
Objects: Multithreading
• Concurrent models
– UML contains support for building concurrent models
– Discus how simulation benefits from multithreading
• waitingPassenger must wait for ridingPassenger
to exit Elevator
• Use synchronized method
– Guarantees only one Person in Elevator at a time

• Threads, Active Classes and Synchronized method
– UML represents a thread as an active class
• Thick black border in UML diagram indicates an active class

• Sequence Diagrams
– Shows interactions among objects
• Shows messages passed among objects over time
– Rectangle enclosing an object name represents that object
• Use same naming conventions as collaboration diagrams
– Lifeline
• Dotted line running down from an object name
• Actions occur on lifeline in chronological order, top to bottom
– Arrows
• Dashed arrows
– Represent “return messages,” return of control to object
• Solid arrows
– A message sent from one object to another

• Class diagram now uses active classes
– Elevator and Person are now active classes

Fig. 16.17 Sequence diagram that models a
Person requesting and entering an Elevator
Person ElevatorShaft elevatorDoor : ElevatorDoor
floorButton : Button elevator: Elevator floorDoor : Door
[ !floorDoor.isDoorOpen() ]
pressButton( ) buttonPressed( )
requestElevator( )
*[ !floorDoor.isDoorOpen() ] wait( )
[Elevator on opposite
Floor of request]
elevator travels
to other floor
elevatorArrived( )
openDoor( )
openDoor( )
setLocation( elevator )
Sequence
continues in
Fig. 16.18

Fig. 16.18 Sequence diagram that models a
Person traveling in an Elevator
Person elevatorButton : Button : Elevator elevatorDoor : ElevatorDoor
pressButton( ) buttonPressed( )
setMoving( true )
Sequence
continued from
Fig. 16.17
closeDoor( )
== 5
*[ !elevatorDoor.isDoorOpen() ] wait( ) seconds
setMoving( false )
changeFloors()
elevatorArrived( )
openDoor( )
setLocation( elevator.getCurrentFloor() )

Fig. 16.19 Revised class diagram of the
elevator simulation
1
Turns 1 2
on/off
Light 1
ElevatorSimulation Floor
2 1
Signals
arrival 1
1
1
ElevatorShaft
Signals
1 arrival
1
Informs of
pressing
Closes Resets
2 1
1 2 Presses
Door Button Person
1 Signals 1 1
1 arrival 1
1 1 1 1
Waits for
opening
Opens/Closes
1 1
1 1
Signals
to move Occupies
ElevatorDoor Elevator
1 Signals
1 1 Signals 1 1 arrival
arrival
Opens/Closes Travels to
Signals
arrival 2 1
Rings
1
Location
1
1 Bell

Fig. 16.20 Final class diagram with attributes
and operations
Location Light
- locationName : String
- lightOn : Boolean = false
# setLocationName( String ) : void
+ getLocationName( ) : String + turnOnLight( ) : void
+ getButton( ) : Button + turnOffLight( ) : void
+ getDoor( ) : Door
ElevatorSimulation
- numberOfPeople : Integer = 0
Person + addPerson( ) : void
- ID : Integer
- moving : Boolean = true Floor
- location : Location
- maxTravelTime : Integer = 10 * 60 + getButton( ) : Button
+ doorOpened( ) : void + getDoor( ) : Door
Bell
Elevator + ringBell( ) : void
- moving : Boolean = false
- summoned : Boolean = false
- currentFloor : Location Button
- destinationFloor : Location - pressed : Boolean = false
- travelTime : Integer = 5
+ resetButton( ) : void
+ pressButton( ) : void
+ ride( ) : void
+ requestElevator( ) : void
– setMoving( Boolean ) : void Door
+ getButton( ) : Button - open : Boolean = false
+ getDoor( ) : Door
+ getLocation( ) : Location + openDoor( ) : void
+ closeDoor( ) : void

16.12 (Optional) Discovering Design
Patterns: Concurrent Design Patterns
• Concurrency Design Patterns
– Single-Threaded Execution design pattern
• Stops several threads from invoking a method concurrently
– Guarded Suspension design pattern
• Suspends and resumes a threads activity when a condition met
– Balking design pattern
• Causes method to balk if an object occupies a certain state
– Read/Write Lock design pattern
• Multiple read on an object but exclusive write
– Two-Phase Termination design pattern
• Uses two-phase termination process to ensure resources freed

Chapter 16 - Multithreading: Runnable Interface

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Chapter 16 - Multithreading: Runnable Interface

Uploaded by

Copyright:

Available Formats

Chapter 16 – Multithreading

 2003 Prentice Hall, Inc. All rights reserved.

• Concurrency normally available in OS primitives

 2003 Prentice Hall, Inc. All rights reserved.

 2003 Prentice Hall, Inc. All rights reserved.

Waiting Sleeping Blocked

sleep interval When a thread completes

 2003 Prentice Hall, Inc. All rights reserved.

 2003 Prentice Hall, Inc. All rights reserved.

 2003 Prentice Hall, Inc. All rights reserved.

 2003 Prentice Hall, Inc. All rights reserved.

 2003 Prentice Hall, Inc.

 2003 Prentice Hall, Inc.

thread1 going to sleep for 1217

 2003 Prentice Hall, Inc.

 2003 Prentice Hall, Inc.

• Java uses monitors for thread synchronization

 2003 Prentice Hall, Inc. All rights reserved.

 2003 Prentice Hall, Inc. All rights reserved.

 2003 Prentice Hall, Inc.

 2003 Prentice Hall, Inc.

 2003 Prentice Hall, Inc.

 2003 Prentice Hall, Inc.

 2003 Prentice Hall, Inc.

 2003 Prentice Hall, Inc.

 2003 Prentice Hall, Inc.

 2003 Prentice Hall, Inc.

 2003 Prentice Hall, Inc.

 2003 Prentice Hall, Inc. All rights reserved.

 2003 Prentice Hall, Inc.

 2003 Prentice Hall, Inc.

 2003 Prentice Hall, Inc.

 2003 Prentice Hall, Inc.

 2003 Prentice Hall, Inc.

Consumer tries to read.

Consumer tries to read.

 2003 Prentice Hall, Inc.

Consumer tries to read. SharedBufferTes

Consumer read values totaling: 10.

Operation Buffer Occupied Count

Consumer tries to read.

 2003 Prentice Hall, Inc.

Consumer reads 2 2 0 SharedBufferTes

Producer done producing.

Consumer read values totaling: 10.

Operation Buffer Occupied Count

 2003 Prentice Hall, Inc.

Producer done producing.

Consumer read values totaling: 10.

 2003 Prentice Hall, Inc.

 2003 Prentice Hall, Inc. All rights reserved.

 2003 Prentice Hall, Inc.

 2003 Prentice Hall, Inc.

Update the output

 2003 Prentice Hall, Inc.

 2003 Prentice Hall, Inc.

 2003 Prentice Hall, Inc.

 2003 Prentice Hall, Inc.

 2003 Prentice Hall, Inc.

 2003 Prentice Hall, Inc.

 2003 Prentice Hall, Inc.

 2003 Prentice Hall, Inc.