CS 696 Emerging Technologies: Distributed Objects

1. References
2. Threads
   1. Creating Threads
   2. Thread Scheduling
      1. Preemptive
      2. Single Processor -Time-slicing or not time-sliced
      3. Native Threads and Parallelism
   3. Simple Yield Example
   4. Sleep Example
3. Suspend, Resume and Stop
   1. Suspend and Resume
   2. Join - Waiting for Thread to end
4. Synchronize
5. DeadLock
6. Synchonized and Inheritance
7. wait and notify
   1. wait - How to use
   2. notify - How to Use
8. The End of an Application
   1. Types of Threads: user and daemon

Doc 14, Java Threads Slide # 2

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 14, Java Threads Slide # 3

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 14, Java Threads Slide # 4

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 14, Java Threads Slide # 5

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 14, Java Threads Slide # 6

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 14, Java Threads Slide # 7

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-3
0 From: Thread-2
1 From: Thread-3
2 From: Thread-3
1 From: Thread-2
3 From: Thread-3
2 From: Thread-2
4 From: Thread-3
3 From: Thread-2
4 From: Thread-2
Doc 14, Java Threads Slide # 8

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" );
      }
   }

Doc 14, Java Threads Slide # 9

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 14, Java Threads Slide # 10

java -native className

Doc 14, Java Threads Slide # 11

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 14, Java Threads Slide # 12

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
0From: Thread-2
0From: Thread-3
1From: Thread-2
1From: Thread-3
2From: Thread-2
2From: Thread-3
3From: Thread-2
3From: Thread-3
Doc 14, Java Threads Slide # 13

class  SleepyThread  extends Thread
   {
   int maxCount = 4;
   public  SleepyThread(  String  name, int count )
      {
      super( name );
      maxCount = count;
      }

   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 14, Java Threads Slide # 14

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 14, Java Threads Slide # 15

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 14, Java Threads Slide # 16

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 14, Java Threads Slide # 17

Doc 14, Java Threads Slide # 18

Doc 14, Java Threads Slide # 19

class Test {
   public  static  void  main( String  args[] ) throws Exception{
      NiceThread  missManners  = new NiceThread( );
      missManners.setPriority( 2 );
      missManners.start();
      Thread.currentThread().sleep( 5 );
      missManners.pleaseStop();
   }
}

class  NiceThread  extends Thread {
   protected boolean stopRequested = false;
   
   public void pleaseStop() { stopRequested = true; }

   public void run() {
      while (!stopRequested)
         System.out.println(  "From: " + getName()  );
      System.out.println( "The End" );
   }
}

From: Thread-2
From: Thread-2
From: Thread-2
From: Thread-2
From: Thread-2
The End
Doc 14, Java Threads Slide # 20

Doc 14, Java Threads Slide # 21

 class Test {
   public  static  void  main( String  args[] ) throws Exception{
      OccupiedThread  missManners  = new OccupiedThread ( );
      missManners.setPriority( 2 );
      missManners.start();
      Thread.currentThread().sleep( 5 );
      missManners.interrupt();
   }
}

class  OccupiedThread  extends Thread {
   protected boolean stopRequested = false;
   
   public void pleaseStop() { stopRequested = true; }

   public void run() {
      try {
         while (!stopRequested) {
            read();
            System.out.println(  "From: " + getName()  );
         }
         System.out.println( "The End" );
      }
      catch (InterruptedException threadInterrupted) {
         System.out.println( "Good bye" );
      }
      catch (IllegalMonitorStateException threadInterrupted) {
      System.out.println( "Dear me" );
      }
   }
   
   public void read() throws InterruptedException {
      System.out.println( "In read" );
      wait();
   }
}
Doc 14, Java Threads Slide # 22

class Test {
   public  static  void  main( String  args[] ) throws Exception{
      TroubleThread  missManners  = new TroubleThread( );
      missManners.setPriority( 2 );
      missManners.start();
      Thread.currentThread().sleep( 5 );
      missManners.interrupt(); //Does not work
   }
}

class  TroubleThread  extends Thread {
   protected boolean stopRequested = false;
   public void pleaseStop() { stopRequested = true; }

   public void run() {
      try{
         while (!stopRequested) {
            read();
         }
      }
      catch (InterruptedException threadInterrupted){
         System.out.println( "Good bye" );
      }
      catch (IllegalMonitorStateException threadInterrupted) {
         System.out.println( "Dear me" );
      }
   }
   
   public void read() throws InterruptedException {
      try{
         System.out.println( "In read" );
         int input = System.in.read();   //Don't type anything
      }
      catch (IOException readError){}
   }
}
Doc 14, Java Threads Slide # 23

class Test {
   public  static  void  main( String  args[] ) throws Exception{
      TroubleThread  missManners  = new TroubleThread( );
      missManners.setPriority( 2 );
      missManners.start();
      Thread.currentThread().sleep( 5 );
      missManners.stop();          //This works
   }
}
Doc 14, Java Threads Slide # 24

Doc 14, Java Threads Slide # 25

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 14, Java Threads Slide # 26

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 14, Java Threads Slide # 27

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 14, Java Threads Slide # 28

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 here
         }

      // More non-critical code can go here
      }

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

      synchronized (  getClass()  )
         {
         // put critical code here
         }

      // More non-critical code can go here
      }
   }
Doc 14, Java Threads Slide # 29

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 ) );
      }
   }
   public void unprotected()
      { System.out.println( "From unprotected" ); }
   }

class Cheat extends Loop   {
   SyncLoop myReference;

   public Cheat( SyncLoop aReference ) {
      myReference = aReference;
   }
   public  void  doLoop( int size, String name )  {
      for  ( int  count = 0;  count < size; count++) 
         myReference.unprotected();
   }
}

Doc 14, Java Threads Slide # 30

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 14, Java Threads Slide # 31

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 14, Java Threads Slide # 32

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 14, Java Threads Slide # 33

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 14, Java Threads Slide # 34

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

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

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

Doc 14, Java Threads Slide # 35

class  Friendly  extends Thread {
   private  Friendly  aFriend;

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

   public void setFriend( Friendly myFriend )
      { aFriend = myFriend;}
      
   public synchronized void hug() {
      try {
         System.out.println(  "I " + getName() + " am hugged ");
         sleep( 5 );
         aFriend.rehug();
      } catch ( InterruptedException notInThisExample ){}
   }

   public synchronized void rehug() {
      System.out.println( "I " + getName() + " am rehugged ");
   }
      
   public  void  run()   {aFriend.hug(); }
}

public class Test {
   public static void main( String args[] )  {
      Friendly  fred  =  new Friendly("Fred");
      Friendly  sam = new Friendly( "Sam");
      fred.setFriend( sam );
      sam.setFriend( fred );
      fred.start();
      sam.start();
      System.out.println( "End" );
      }
   }

End
I Fred am hugged
I Sam am hugged
Doc 14, Java Threads Slide # 36

class  Friendly  extends Thread   {
   private  Friendly  aFriend;
   private Object lock;

   public  Friendly(  String  name, Object lock )   {
      super( name );
      this.lock = lock;
   }

   public void setFriend( Friendly myFriend )   {
      aFriend = myFriend;
   }
      
   public synchronized void hug()    {
      try {
         System.out.println(  "I " + getName() + " am hugged ");
         sleep( 5 );
         aFriend.rehug();
      }
      catch ( InterruptedException notInThisExample ) {}
   }

   public synchronized void rehug()   {
      System.out.println( "I " + getName() + " am rehugged ");
   }
      
   public  void  run()    {
      synchronized ( lock)   {
         aFriend.hug();
      }
   }
}
Doc 14, Java Threads Slide # 37

public class Test
   {

   public static void main( String args[] ) //throws Exception
      {
      Object aLock = "Schalage";
      Friendly  fred  =  new Friendly("Fred", aLock);
      Friendly  sam = new Friendly( "Sam", aLock);
      fred.setFriend( sam );
      sam.setFriend( fred );
      fred.start();
      sam.start();
      System.out.println( "End" );
      }
   }

Doc 14, Java Threads Slide # 38

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 14, Java Threads Slide # 39

Doc 14, Java Threads Slide # 40

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 14, Java Threads Slide # 41

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 14, Java Threads Slide # 42

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 14, Java Threads Slide # 43

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 14, Java Threads Slide # 44

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 14, Java Threads Slide # 45

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

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

Doc 14, Java Threads Slide # 46

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

   notify();
   }

Doc 14, Java Threads Slide # 47

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.

Doc 14, Java Threads Slide # 48

Doc 14, Java Threads Slide # 49

class Test
   {
   public  static  void  main( String  args[] ) throws Exception{
      InfinityThread  shortLived      = new InfinityThread( );
      shortLived.setDaemon( true );
      shortLived.start();
      Thread.currentThread().sleep( 10 );
      System.out.println( "Bye");
      }
   }

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

From: Thread-4
From: Thread-4
From: Thread-4
From: Thread-4
From: Thread-4
From: Thread-4
From: Thread-4
From: Thread-4
From: Thread-4
Bye

Doc 14, Java Threads Slide # 50

Prints a stack trace for the current thread on System.out

Returns a String representation of the Thread, including the thread's name, priority and thread group.

Returns the number of stack frames in this Thread. The Thread must be suspended when this method is called.

visitors since 24-Feb-98