1. Java threads Threaded class extends thread Synchronized class is a monitor Runnable interface gives thread methods All code is (C) Copyright 1999 by Deitel & Associates, Inc. and Prentice Hall.

2. ThreadTester.java // Fig. 15.3: ThreadTester.java // Show multiple threads printing at different intervals. public class ThreadTester { public static void main( String args[] ) { PrintThread thread1, thread2, thread3, thread4; thread1 = new PrintThread( "thread1" ); thread2 = new PrintThread( "thread2" ); thread3 = new PrintThread( "thread3" ); thread4 = new PrintThread( "thread4" ); System.err.println( "\nStarting threads" ); thread1.start(); thread2.start(); thread3.start(); thread4.start(); System.err.println( "Threads started\n" ); }

3. class PrintThread extends Thread class PrintThread extends Thread { private int sleepTime; // PrintThread constructor assigns name to thread // by calling Thread constructor public PrintThread( String name ) { super( name ); // sleep between 0 and 5 seconds sleepTime = (int) ( Math.random() * 5000 ); System.err.println( "Name: " + getName() + "; sleep: " + sleepTime ); }

4. execute the thread // execute the thread public void run() { // put thread to sleep for a random interval try { System.err.println( getName() + " going to sleep" ); Thread.sleep( sleepTime ); } catch ( InterruptedException exception ) { System.err.println( exception.toString() ); } // print thread name System.err.println( getName() + " done sleeping" ); }

5. ConsumeInteger.java // Fig. 15.4: ConsumeInteger.java // Definition of threaded class ConsumeInteger public class ConsumeInteger extends Thread { private HoldIntegerUnsynchronized cHold; public ConsumeInteger( HoldIntegerUnsynchronized h ) { super( "ConsumeInteger" ); cHold = h; }

6. The run() method public void run() { int val, sum = 0; do { // sleep for a random interval try { Thread.sleep( (int) ( Math.random() * 3000 ) ); } catch( InterruptedException e ) { System.err.println( e.toString() ); } val = cHold.getSharedInt(); sum += val; } while ( val != 10 ); System.err.println( getName() + " retrieved values totaling: " + sum + "\nTerminating " + getName() ); }

7. Definition of threaded class ProduceInteger // Fig. 15.4: ProduceInteger.java // Definition of threaded class ProduceInteger public class ProduceInteger extends Thread { private HoldIntegerUnsynchronized pHold; public ProduceInteger( HoldIntegerUnsynchronized h ) { super( "ProduceInteger" ); pHold = h; }

8. The run() method again public void run() { for ( int count = 1; count <= 10; count++ ) { // sleep for a random interval try { Thread.sleep( (int) ( Math.random() * 3000 ) ); } catch( InterruptedException e ) { System.err.println( e.toString() ); } pHold.setSharedInt( count ); } System.err.println( getName() + " finished producing values" + "\nTerminating " + getName() ); }

9. Multiple threads modifying shared object // Fig. 15.4: SharedCell.java // Show multiple threads modifying shared object. public class SharedCell { public static void main( String args[] ) { HoldIntegerUnsynchronized h = new HoldIntegerUnsynchronized(); ProduceInteger p = new ProduceInteger( h ); ConsumeInteger c = new ConsumeInteger( h ); p.start(); c.start(); }

10. Definition of threaded class ConsumeInteger // Fig. 15.5: ConsumeInteger.java // Definition of threaded class ConsumeInteger public class ConsumeInteger extends Thread { private HoldIntegerSynchronized cHold; public ConsumeInteger( HoldIntegerSynchronized h ) { super( "ConsumeInteger" ); cHold = h; }

11. Another run() method public void run() { int val, sum = 0; do { // sleep for a random interval try { Thread.sleep( (int) ( Math.random() * 3000 ) ); } catch( InterruptedException e ) { System.err.println( e.toString() ); } val = cHold.getSharedInt(); sum += val; } while ( val != 10 ); System.err.println( getName() + " retrieved values totaling: " + sum + "\nTerminating " + getName() ); }

12. Definition of class HoldIntegerSynchronized // Fig. 15.5: HoldIntegerSynchronized.java // Definition of class HoldIntegerSynchronized that uses thread synchronization to ensure that both // threads access sharedInt at the proper times. public class HoldIntegerSynchronized { private int sharedInt = -1; private boolean writeable = true; // condition variable public synchronized void setSharedInt( int val ) { while ( !writeable ) { // not the producer's turn try { wait(); } catch ( InterruptedException e ) { e.printStackTrace(); } System.err.println( Thread.currentThread().getName() + " setting sharedInt to " + val ); sharedInt = val; writeable = false; notify(); // tell a waiting thread to become ready }

13. public synchronized int getSharedInt() { while ( writeable ) { // not the consumer's turn try { wait(); } catch ( InterruptedException e ) { e.printStackTrace(); } writeable = true; notify(); // tell a waiting thread to become ready System.err.println( Thread.currentThread().getName() + " retrieving sharedInt value " + sharedInt ); return sharedInt; }

14. Definition of threaded class ProduceInteger // Fig. 15.5: ProduceInteger.java // Definition of threaded class ProduceInteger public class ProduceInteger extends Thread { private HoldIntegerSynchronized pHold; public ProduceInteger( HoldIntegerSynchronized h ) { super( "ProduceInteger" ); pHold = h; } public void run() { for ( int count = 1; count <= 10; count++ ) { // sleep for a random interval try { Thread.sleep( (int) ( Math.random() * 3000 ) ); } catch( InterruptedException e ) { System.err.println( e.toString() ); } pHold.setSharedInt( count ); } System.err.println( getName() + " finished producing values" + "\nTerminating " + getName() ); }

15. public void run() { for ( int count = 1; count <= 10; count++ ) { // sleep for a random interval try { Thread.sleep( (int) ( Math.random() * 3000 ) ); } catch( InterruptedException e ) { System.err.println( e.toString() ); } pHold.setSharedInt( count ); } System.err.println( getName() + " finished producing values" + "\nTerminating " + getName() ); }

16. Show multiple threads modifying shared object // Fig. 15.5: SharedCell.java // Show multiple threads modifying shared object. public class SharedCell { public static void main( String args[] ) { HoldIntegerSynchronized h = new HoldIntegerSynchronized(); ProduceInteger p = new ProduceInteger( h ); ConsumeInteger c = new ConsumeInteger( h ); p.start(); c.start(); }

17. Definition of threaded class ConsumeInteger // Fig. 15.6: ConsumeInteger.java // Definition of threaded class ConsumeInteger import javax.swing.JTextArea; public class ConsumeInteger extends Thread { private HoldIntegerSynchronized cHold; private JTextArea output; public ConsumeInteger( HoldIntegerSynchronized h, JTextArea o ) { super( "ConsumeInteger" ); cHold = h; output = o; }

18. Another run() method public void run() { int val, sum = 0; do { // sleep for a random interval try { Thread.sleep( (int) ( Math.random() * 3000 ) ); } catch( InterruptedException e ) { System.err.println( e.toString() ); } val = cHold.getSharedInt(); sum += val; } while ( val != 10 ); output.append( "\n" + getName() + " retrieved values totaling: " + sum + "\nTerminating " + getName() + "\n" ); }

19. Definition of class HoldIntegerSynchronized // Fig. 15.6: HoldIntegerSynchronized.java // Definition of class HoldIntegerSynchronized that // uses thread synchronization to ensure that both // threads access sharedInt at the proper times. import javax.swing.JTextArea; import java.text.DecimalFormat; public class HoldIntegerSynchronized { private int sharedInt[] = { -1, -1, -1, -1, -1 }; private boolean writeable = true; private boolean readable = false; private int readLoc = 0, writeLoc = 0; } public void displayBuffer( JTextArea out, int buf[] ) { DecimalFormat formatNumber = new DecimalFormat( " #;-#" ); output.append( "\tbuffer: " ); for ( int i = 0; i < buf.length; i++ ) out.append( " " + formatNumber.format( buf[ i ] )); }

20. private JTextArea output; sharedInt[ writeLoc ] = val; readable = true; output.append( "\nProduced " + val + " into cell " + writeLoc ); writeLoc = ( writeLoc + 1 ) % 5; output.append( "\twrite " + writeLoc + "\tread " + readLoc); displayBuffer( output, sharedInt ); if ( writeLoc == readLoc ) { writeable = false; output.append( "\nBUFFER FULL" ); } notify();

21. public synchronized int getSharedInt() { int val; while ( !readable ) { try { output.append( " WAITING TO CONSUME" ); wait(); } catch ( InterruptedException e ) { System.err.println( e.toString() ); } writeable = true; val = sharedInt[ readLoc ]; output.append( "\nConsumed " + val + " from cell " + readLoc ); readLoc = ( readLoc + 1 ) % 5; output.append( "\twrite " + writeLoc + "\tread " + readLoc ); displayBuffer( output, sharedInt ); if ( readLoc == writeLoc ) { readable = false; output.append( "\nBUFFER EMPTY" ); } notify(); return val;

22. public HoldIntegerSynchronized( JTextArea o ) { output = o; } public synchronized void setSharedInt( int val ) { while ( !writeable ) { try { output.append( " WAITING TO PRODUCE " + val ); wait(); } catch ( InterruptedException e ) { System.err.println( e.toString() ); }

23. Definition of threaded class ProduceInteger // Fig. 15.6: ProduceInteger.java // Definition of threaded class ProduceInteger import javax.swing.JTextArea; public class ProduceInteger extends Thread { private HoldIntegerSynchronized pHold; private JTextArea output; public ProduceInteger( HoldIntegerSynchronized h, JTextArea o ) { super( "ProduceInteger" ); pHold = h; output = o; }

24. public void run() { for ( int count = 1; count <= 10; count++ ) { // sleep for a random interval // Note: Interval shortened purposely to fill buffer try { Thread.sleep( (int) ( Math.random() * 500 ) ); } catch( InterruptedException e ) { System.err.println( e.toString() ); } pHold.setSharedInt( count ); } output.append( "\n" + getName() + " finished producing values" + "\nTerminating " + getName() + "\n" ); }

25. Multiple threads modifying shared object // Fig. 15.6: SharedCell.java // Show multiple threads modifying shared object. import java.text.DecimalFormat; import java.awt.*; import java.awt.event.*; import javax.swing.*; public class SharedCell extends JFrame { public SharedCell() { super( "Demonstrating Thread Synchronization" ); JTextArea output = new JTextArea( 20, 30 ); getContentPane().add( new JScrollPane( output ) ); setSize( 500, 500 ); show(); // set up threads and start threads HoldIntegerSynchronized h = new HoldIntegerSynchronized( output ); ProduceInteger p = new ProduceInteger( h, output ); ConsumeInteger c = new ConsumeInteger( h, output ); p.start(); c.start(); }

26. public static void main( String args[] ) { SharedCell app = new SharedCell(); app.addWindowListener( new WindowAdapter() { public void windowClosing( WindowEvent e ) { System.exit( 0 ); } ); }

27. Demonstrating the Runnableinterface // Fig. 15.7: RandomCharacters.java // Demonstrating the Runnableinterface import java.awt.*; import java.awt.event.*; import javax.swing.*; public class RandomCharacters extends JApplet implements Runnable, ActionListener { private String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; private JLabel outputs[]; private JCheckBox checkboxes[]; private final static int SIZE = 3; private Thread threads[]; private boolean suspended[];

28. public void init() { outputs = new JLabel[ SIZE ]; checkboxes = new JCheckBox[ SIZE ]; threads = new Thread[ SIZE ]; suspended = new boolean[ SIZE ]; Container c = getContentPane(); c.setLayout( new GridLayout( SIZE, 2, 5, 5 ) ); for ( int i = 0; i < SIZE; i++ ) { outputs[ i ] = new JLabel(); outputs[ i ].setBackground( Color.green ); outputs[ i ].setOpaque( true ); c.add( outputs[ i ] ); checkboxes[ i ] = new JCheckBox( "Suspended" ); checkboxes[ i ].addActionListener( this ); c.add( checkboxes[ i ] ); }

29. public void start() { // create threads and start every time start is called for ( int i = 0; i < threads.length; i++ ) { threads[ i ] = new Thread( this, "Thread " + (i + 1) ); threads[ i ].start(); }

30. public void run() { Thread currentThread = Thread.currentThread(); int index = getIndex( currentThread ); char displayChar; while ( threads[ index ] == currentThread ) { // sleep from 0 to 1 second try { Thread.sleep( (int) ( Math.random() * 1000 ) ); synchronized( this ) { while ( suspended[ index ] && threads[ index ] == currentThread ) wait(); } catch ( InterruptedException e ) { System.err.println( "sleep interrupted" ); } displayChar = alphabet.charAt( (int) ( Math.random() * 26 ) ); outputs[ index ].setText( currentThread.getName() + ": " + displayChar ); } System.err.println( currentThread.getName() + " terminating" ); }

31. private int getIndex( Thread current ) { for ( int i = 0; i < threads.length; i++ ) if ( current == threads[ i ] ) return i; return -1; } public synchronized void stop() { // stop threads every time stop is called // as the user browses another Web page for ( int i = 0; i < threads.length; i++ ) threads[ i ] = null; notifyAll(); }

32. public synchronized void actionPerformed( ActionEvent e ) { for ( int i = 0; i < checkboxes.length; i++ ) { if ( e.getSource() == checkboxes[ i ] ) { suspended[ i ] = !suspended[ i ]; outputs[ i ].setBackground( !suspended[ i ] ? Color.green : Color.red ); if ( !suspended[ i ] ) notify(); return; }