CS 596: Client-Server Programming
Spring Semester, 1997
Doc 7, Threads

1. Threads
   1. Creating Threads
   2. Thread Scheduling - Preemptive
   3. Simple Yield Example
   4. Sleep Example
   5. Suspend and Resume
   6. Join - Waiting for Thread to end
2. Synchronize
   1. Synchonized and Inheritance
   2. wait and notify
      1. wait - How to use
      2. notify - How to Use

Doc 7, Threads Slide # 1

Child process gets a copy of parents variables

Relatively expensive to start

Don't have to worry about concurrent access to variables

Child process shares parents variables

Relatively cheap to start

Concurrent access to variables is an issue

Doc 7, Threads Slide # 2

class  SimpleThread  extends Thread
   {
   public  void run()
      {
      for  ( int  count = 0;  count < 4; count++)
         System.out.println( "Message " + count +
                          "From: Mom" );
      }
   }

class  TestThread
   {
   public static void main( String[]  args )
      {
      SimpleThread  parallel  = new SimpleThread();
      System.out.println( "Create the thread");
      parallel.start();
      System.out.println( "Started the thread" );
      System.out.println( "End" );
      }
   }

Doc 7, Threads Slide # 3

class  SecondMethod  implements  Runnable
   {
   public  void  run()
      {
      for  ( int  count = 0;  count < 4; count++)
         System.out.println( "Message " + count +  " From: Dad");
      }
   }

class  TestThread
   {
   public static void main( String[]  args )
      {
      SecondMethod  notAThread  = new SecondMethod();
      Thread  parallel  =  new Thread( notAThread );

      System.out.println( "Create the thread");
      parallel.start();
      System.out.println( "Started the thread" );
      System.out.println( "End" );
      }
   }

Doc 7, Threads Slide # 4

class  SecondMethod  implements  Runnable
   {
   public  void  run()
      {
      for  ( int  count = 0;  count < 4; count++)
         System.out.println( "Message " + count +  " From: " + 
                        Thread.currentThread().getName() );
      }
   }

class  TestThread
   {
   public static void main( String[]  args )
      {
      SecondMethod  notAThread  = new SecondMethod();
      Thread  parallel  =  new Thread( notAThread, "Mom" );

      System.out.println( "Create the thread");
      parallel.start();
      System.out.println( "Started the thread" );
      System.out.println( "End" );
      }
   }

Doc 7, Threads Slide # 5

class  SimpleThread  extends Thread
   {
   private  int  maxCount =  32;

   public  SimpleThread(  String  name )
      {
      super( name );
      }

   public  SimpleThread(  String  name, int repetitions )
      {
      super( name );
      maxCount  =  repetitions;
      }

   public  SimpleThread(  int repetitions )
      {
      maxCount  =  repetitions;
      }


   public  void run()
      {
      for  ( int  count = 0;  count < maxCount; count++)
         {
         System.out.println( count + " From: " + getName() );
         }
      }
   }

Doc 7, Threads Slide # 6

class  TestThread
   {
   public static void main( String[]  args )
      {
      SimpleThread  first      = new SimpleThread( 5 );
      SimpleThread  second  = new SimpleThread( 5 );
      first.start();
      second.start();
      System.out.println( "End" );
      }
   }

End
0 From: Thread-4
1 From: Thread-4
2 From: Thread-4
3 From: Thread-4
4 From: Thread-4
0 From: Thread-5
1 From: Thread-5
2 From: Thread-5
3 From: Thread-5
4 From: Thread-5
Doc 7, Threads Slide # 7

public final static int MIN_PRIORITY = 1

public final static int NORM_PRIORITY = 5

public final static int MAX_PRIORITY = 10

class  TestThread
   {
   public static void main( String[]  args )
      {
      SimpleThread  first      = new SimpleThread( 5 );
      SimpleThread  second  = new SimpleThread( 5 );
      second.setPriority( 8 );
      first.start();
      second.start();
      System.out.println( "End" );
      }
   }

0 From: Thread-5
1 From: Thread-5
2 From: Thread-5
3 From: Thread-5
4 From: Thread-5
0 From: Thread-4
1 From: Thread-4
2 From: Thread-4
3 From: Thread-4
4 From: Thread-4
End
Doc 7, Threads Slide # 8

a thread is run for a short time slice and suspended,

resumes only when it gets its next "turn"

threads of the same priority share turns

they end

they are terminated

they are interrupted

Higher priority threads interrupts lower priority threads

they go to sleep

they block on some call

reading a socket

waiting for another thread

they yield

Doc 7, Threads Slide # 9

class  InfinityThread  extends Thread
   {
   public  void run()
      {
      while ( true )
         System.out.println(  "From: " + getName() );
      }
   }

class  TestThread
   {
   public static void main( String[]  args )
      {
      InfinityThread  first      = new InfinityThread( );
      InfinityThread  second  = new InfinityThread( );
      first.start();
      second.start();
      }
   }

Doc 7, Threads Slide # 10

class  YieldThread  extends Thread
   {
   public  void run()
      {
      for  ( int  count = 0;  count < 4; count++)
         {
         System.out.println( count + "From: " + getName() );
         yield();
         }
      }
   }

class  TestThread
   {
   public static void main( String[]  args ) 
      {
      YieldThread  first      = new YieldThread();
      YieldThread  second  = new YieldThread();

      first.start();
      second.start();
      System.out.println( "End" );
      }
   }

End
0 From: Thread-4
0 From: Thread-5
1 From: Thread-4
1 From: Thread-5
2 From: Thread-4
2 From: Thread-5
3 From: Thread-4
3 From: Thread-5
Doc 7, Threads Slide # 11

class  SleepyThread  extends Thread
   {

   public  SleepyThread(  String  name )
      {
      super( name );
      }

   public  void run()
      {
      for  ( int  count = 0;  count < 4; count++)
         {
         System.out.println( count + " From: " + getName() );

         try
            {
            sleep( 5 );   // in  milliseconds
            }

         catch  ( InterruptedException ignored )  {}
         }
      }
   }

Doc 7, Threads Slide # 12

class  TestSleep
   {
   public static void main( String[]  args )
      {
      SimpleThread  alert    = new SimpleThread( "Alert", 32 );
      SleepyThread  sleepy  = new SleepyThread( "Sleepy", 32 );
      sleepy.setPriority( 8 );
      alert.start();
      sleepy.start();
      System.out.println( "End" );
      }
   }

Doc 7, Threads Slide # 13

class Clock extends Thread
   {
   static int millisecondsHour = 1000 * 60 * 60;
   static long millisecondsPerDay = millisecondsHour * 24;
   
   int millSecondsPerSimDay;
   Date simDate = new Date();

   public Clock( int simDaysPerHour )
      {
      millSecondsPerSimDay  = millisecondsHour / simDaysPerHour;
      setPriority( Thread.MAX_PRIORITY );
      }
   
   public String toString() { return simDate.toString(); }
      
   public void run()
      {
      try
         {
         while (true)
            {
            // Advance one sim day
            long simTime = simDate.getTime();
            simDate.setTime( simTime + millisecondsPerDay);
            // wait until next day
            sleep( millSecondsPerSimDay );
            }
         }
      catch ( InterruptedException simulationOver )
         { return;}
      }
   }

Doc 7, Threads Slide # 14

import sdsu.io.Console;
import java.util.Date;

class Test
   {
   public static void main(String  args[] ) throws Exception
      {
      Clock fast = new Clock( 60 * 60 * 10 );
      fast.start();
      for ( int k = 0; k < 5; k++ )
         {
         System.out.println( fast.toString());
         Console.readInt( "Type an int" );
         }
      fast.stop();
      }   
   
   }

Doc 7, Threads Slide # 15

Doc 7, Threads Slide # 16

class  Suspended
   {
   public static void main( String[]  args ) throws 
      InterruptedException
      {
      SimpleThread  alert      = new SimpleThread( "Alert" );
      SleepyThread  sleepy  = new SleepyThread( "Sleepy" );
      sleepy.setPriority( 8 );
      alert.start();
      sleepy.start();

      sleepy.suspend();
      System.out.println( "now I can go" );
      Thread.sleep( 4 );
      sleepy.resume();
      }
   }

Doc 7, Threads Slide # 17

class  Godot
   {
   public static void main( String[]  args ) throws 
      InterruptedException
      {
      SimpleThread  lowly      = new SimpleThread( "Lowly" );
      lowly.setPriority( 1 );
      lowly.start();

      System.out.println( "now I can go" );

      lowly.join();

      System.out.println( "Done" );
      }
   }

Doc 7, Threads Slide # 18

method?

data?

class  AccessExample
   {
   public  int[]  data  =  new  int[10];

   public  safeCode( int Size,  int  startValue)
      {
      int[]  verySafe  =  new  int[ Size ]; 

      for  ( int  index  = 0; index < Size;  index++ )
         verySafe[ index ]  =  (int ) Math.sin( index * startValue );
      }

   public  dangerousCode( int Size,  int  startValue)
      {
      for  ( int  index  = 0; index < Size;  index++ )
         data[ index ]  =  (int ) Math.sin( index * startValue );
      }
   }

Doc 7, Threads Slide # 19

class  SynchronizeSyntax
   {
   protected  int myValue;
   public  static  int  globalStuff;

   public  synchronized  void  synchronizedMethod()
      {
      myValue++;
      }

   public  ShowSynchronizedBlock(  Vector  criticalData  )
      {
      // Some non-critical code can go here

      synchronized (  criticalData  )
         {
         // put critical code relating to criticalData here
         }

      // More non-critical code can go here
      }

   public  SynchronizedClass(  )
      {
      // Some non-critical code can go here

      synchronized (  getClass()  )
         {
         // put critical code relating to class SynchronizeSyntax
         }

      // More non-critical code can go here
      }
   }
Doc 7, Threads Slide # 20

class  Loop
   {
   public  void  doLoop( int size, String name ) 
      {
      for  ( int  count = 0;  count < size; count++)
         {
         System.out.println( count + " From: " + name );
         double wasteTime  =  Math.sin( Math.cos ( count ) );
         }
      }
   }


class  SyncLoop  extends  Loop
   {
   public  synchronized  void  doLoop( int size, String name ) 
      {
      for  ( int  count = 0;  count < size; count++)
         {
         System.out.println( count + " From: " + name );
         double wasteTime  =  Math.sin( Math.cos( count ) );
         }
      }
   }


Doc 7, Threads Slide # 21

class  SimpleThread  extends Thread
   {
   private  int  maxCount;
   private  Loop  myCopyOfLoop;


   public  SimpleThread(  String  name, int count, Loop  copy )
      {
      super( name );
      maxCount  =  count;
      myCopyOfLoop  =  copy;
      }


   public  void  run()
      {
      myCopyOfLoop.doLoop( maxCount, getName() );
      }
   }

Doc 7, Threads Slide # 22

class  SleepyThread  extends Thread
   {
   private  Loop  myCopyOfLoop;
   private  int  maxCount;

   public  SleepyThread(  String  name, int count,  Loop  copy )
      {
      super( name );
      maxCount  =  count;
      myCopyOfLoop  =  copy;
      }


   public  void run()
      {
      for  ( int  count = 0;  count < 4; count++)
         {
         try
            {
            sleep( 5 );   // in  milliseconds
            myCopyOfLoop.doLoop( maxCount, getName() );
            }
         catch  ( InterruptedException ignored )  {}
         }
      }
   }

Doc 7, Threads Slide # 23

class  TestNoSynch
   {
   public static void main( String[]  args ) throws Exception
      {
      Loop  notSafe  =  new Loop();
      SimpleThread  alert;
      SleepyThread  sleepy;

      alert  = new SimpleThread( "Alert", 8, notSafe );
      sleepy  = new SleepyThread( "Sleepy", 2, notSafe );

      sleepy.setPriority( 8 );
      alert.start();
      sleepy.start();
      System.out.println( "End" );
      }
   }

Doc 7, Threads Slide # 24

class  TestSynch
   {
   public static void main( String[]  args ) throws Exception
      {
      Loop  safe  =  new SyncLoop();
      SimpleThread  alert;
      SleepyThread  sleepy;

      alert  = new SimpleThread( "Alert", 8, safe  );
      sleepy  = new SleepyThread( "Sleepy", 2, safe  );

      sleepy.setPriority( 8 );
      alert.start();
      sleepy.start();
      System.out.println( "End" );
      }
   }

Doc 7, Threads Slide # 25

class Top
   {
   public void synchronized left()
      {
      // do stuff
      }

   public void synchronized right()
      {
      // do stuff
      }
   }

class Bottom extends Top
   {
   public void left()
      {
      // not synchronized 
      }

   public void right()
      {
      // do stuff not synchronized
      super.right();   // synchronized here
      // do stuff not synchronized
      }

If you want a method in a subclass to be synchronized you must declare it to be synchronized.
Doc 7, Threads Slide # 26

Doc 7, Threads Slide # 27

class Queue
   {
   LinkedCell head;
   LinkedCell tail;
   
   public synchronized void append( Object item )
      {
      LinkedCell  newItem = new LinkedCell( item );

      if ( head == null )
         head = newItem;
      else
         tail.append( newItem );

      tail = newItem;
      notify();
      }

   public synchronized Object get( )
      {
      try
         {
         while ( head == null )
            wait();
         }
      catch (InterruptedException threadIsDone )
         {
         return null;
         }
      
      Object returnMe = head.element();
      head = head.next();
      return returnMe;
      }
   }
Doc 7, Threads Slide # 28

class LinkedCell
   {
   Object cellItem;
   LinkedCell next;

   public LinkedCell( Object value )
      {
      cellItem= value;
      }

   public Object element()
      { 
      return cellItem;
      }

   public void append( LinkedCell nextCell )
      {
      next = nextCell;
      }

   public LinkedCell next()
      { 
      return next; 
      }
   }


Doc 7, Threads Slide # 29

class Producer extends Thread
   {
   Queue factory;
   int workSpeed;
   
   public Producer( String name, Queue output, int speed )
      {
      setName(name);
      factory = output;
      workSpeed = speed;
      }
   
   public void run()
      {
      try
         {
         int product = 0;
         while (true) // work forever
            {
            System.out.println( getName() + " produced " + product);
            factory.append( getName() + String.valueOf( product) );
            product++;
            sleep( workSpeed);
            }
         }
      catch ( InterruptedException WorkedToDeath )
         { 
         return;
         }
      }
   }
   
   
Doc 7, Threads Slide # 30

class Consumer extends Thread
   {
   Queue localMall;
   int sleepDuration;
   
   public Consumer( String name, Queue input, int speed )
      {
      setName(name);
      localMall = input;
      sleepDuration = speed;
      }
   
   public void run()
      {
      try
         {
         while (true) // Shop until you drop
            {
            System.out.println( getName() + " got " + 
                              localMall.get());
            sleep( sleepDuration );
            }
         }
      catch ( InterruptedException endOfCreditCard )
         { 
         return;
         }
      }
   }

Doc 7, Threads Slide # 31

class Test
   {
   public  static  void  main( String  args[] ) throws Exception
      {
      Queue wallmart = new Queue();
      Producer nike = new Producer( "Nike", wallmart, 500 );
      Producer honda = new Producer( "Honda", wallmart, 1200 );
      Consumer valleyGirl = new Consumer( "Sue", wallmart, 400);
      Consumer valleyBoy = new Consumer( "Bob", wallmart, 900);
      Consumer dink = new Consumer( "Sam", wallmart, 2200);
      nike.start();
      honda.start();
      valleyGirl.start();
      valleyBoy.start();
      dink.start();
      }
   }

Doc 7, Threads Slide # 32

synchronized void waitingMethod()
   {
   while ( ! condition )
      wait();

   Now do what you need to do when condition is true
   }

Doc 7, Threads Slide # 33

synchronized void changeMethod()
   {
   Change some value used in a condition test

   notify();
   }

Doc 7, Threads Slide # 34

Causes a thread to wait until it is notified or the specified timeout expires.

Parameters:

timeout - the maximum time to wait in milliseconds

Throws: IllegalMonitorStateException

If the current thread is not the owner of the Object's monitor.

Throws: InterruptedException

Another thread has interrupted this thread.

Notifies all of the threads waiting for a condition to change. Threads that are waiting are generally waiting for another thread to change some condition. Thus, the thread effecting a change that more than one thread is waiting for notifies all the waiting threads using the method notifyAll(). Threads that want to wait for a condition to change before proceeding can call wait(). The method notifyAll() can only be called from within a synchronized method.