CS 580 Client-Server Spring Semester, 2004 Threads part 2
	Previous    Lecture Notes Index    Next     © 2004, All Rights Reserved, SDSU & Roger Whitney San Diego State University -- This page last updated 04-Mar-04

Doc 17, Threads part 2 Slide # 2

See course Store repository package ThreadLecture1 version 1.4

Doc 17, Threads part 2 Slide # 3

Thread Control

Java interrupt()

• wait
• join
• sleep

• I/O operation on an interruptible channel

• Interrupt status is set
• The thread returns from the selector call as normal

Doc 17, Threads part 2 Slide # 4

• Stream
• Reader/Writer
• Pre-JDK 1.4 style socket read/write

Doc 17, Threads part 2 Slide # 5

public class NoInterruptThread extends Thread {
   public void run() {
      while ( true) {
         System.out.println(  "From: " + getName()  );
      }
   }
   
   public static void main(String args[]) throws InterruptedException{
   
      NoInterruptThread focused  = new NoInterruptThread( );
      focused.setPriority( 2 );
      focused.start();
      Thread.currentThread().sleep( 5 ); // Let other thread run
      focused.interrupt();
      System.out.println( "End of main");
   }
}

From: Thread-0   (repeated many times)
End of main
From: Thread-0   (repeated until program is killed)

Doc 17, Threads part 2 Slide # 6

public class RepeatableNiceThread extends Thread {
   public void run() {
   
      while ( true ) {
         while ( !Thread.interrupted() )
            System.out.println(  "From: " + getName()  );
   
         System.out.println( "Clean up operations" );
      }
   }
   
   public static void main(String args[]) throws InterruptedException{
   
      RepeatableNiceThread  missManners  = 
            new RepeatableNiceThread( );
      missManners.setPriority( 2 );
      missManners.start();
   
      Thread.currentThread().sleep( 5 );
      missManners.interrupt();
      }
}

From: Thread-0
Clean up operations
From: Thread-0
From: Thread-0 (repeated)

Doc 17, Threads part 2 Slide # 7

Interrupt and sleep, join & wait

public class  NiceThread  extends Thread {
   public void run() {
      try {
         System.out.println( "Thread started");
         while ( !isInterrupted() ) {
            sleep( 5 );
            System.out.println(  "From: " + getName()  );
         }
         System.out.println( "Clean up operations" );
      } catch ( InterruptedException interrupted ) {
         System.out.println( "In catch" );
      }      
   }
   
   public static void main( String args[] )  {
      NiceThread  missManners  = new NiceThread( );
      missManners.setPriority( 6 );
      missManners.start();
      missManners.interrupt();
   }
}

Thread started
From: Thread-0
From: Thread-0
In catch
Doc 17, Threads part 2 Slide # 8

public class WhoSendsSleep extends Thread {
   public void run() {
      try {
         while ( !isInterrupted() ) {
            System.out.println(  "From: " + getName()  );
         }
         System.out.println( "Clean up operations" );
      } catch ( Exception interrupted ) {
         System.out.println( "In catch" );
      }      
   }
   
   public static void main( String args[] ) {
      try {
         NiceThread  missManners  = new NiceThread( );
         missManners.setPriority( 1 );
         missManners.start();
         missManners.sleep( 50);   //Which thread is sleeping?
         missManners.interrupt();
      } catch ( InterruptedException interrupted ) {
         System.out.println( "Caught napping" );
      }
   }
}

Thread started
From: Thread-0
From: Thread-0
Clean up operations

Doc 17, Threads part 2 Slide # 9

   missManners.sleep( 50);

Doc 17, Threads part 2 Slide # 10

Smalltalk interrupt

Force the receiver to interrupt whatever it is doing and to evaluate aBlock

Receiver continues what ever it was doing after evaluating aBlock

   | process result |
   result := WriteStream on: String new.
   process := 
         [1 to: 5000
            do: 
               [:each | 
               result
                  nextPutAll: each printString;
                  cr.
               Processor activeProcess yield]] 
               fork.
   (Delay forMilliseconds: 1) wait.
   process interruptWith: [result nextPutAll: 'Interrupt'].
	(Delay forMilliseconds: 100) wait.
   Transcript
      clear;
      show: result contents

Doc 17, Threads part 2 Slide # 11

Safety - Mutual Access

Doc 17, Threads part 2 Slide # 12

Java Safety - Synchronize

Synchronized Instance Methods

class SynchronizeExample {
   int[]  data;
   public String toString() {
      return "array length " + data.length + " array values " + data[0];
   }
   
   public synchronized void initialize( int size,  int  startValue){
      data  =  new  int[ size ];
      for  ( int  index  = 0; index < size;  index++ )
         data[ index ]  =  (int ) Math.sin( index * startValue );
   }
   
   public  void unSafeSetValue( int  newValue) {
      for  ( int  index  = 0; index < data.length;  index++ )
         data[ index ]  =  (int ) Math.sin( index * newValue );
   }
   
   public  synchronized void safeSetValue( int  newValue) {
      for  ( int  index  = 0; index < data.length;  index++ )
         data[ index ]  =  (int ) Math.sin( index * newValue );
   }
}
Doc 17, Threads part 2 Slide # 13

Synchronized Static Methods

class SynchronizeStaticExample {
   int[]  data;
   static int[] classData; 
   
   public synchronized void initialize( int size,  int  startValue){
      data  =  new  int[ size ];
      for  ( int  index  = 0; index < size;  index++ )
         data[ index ]  =  (int ) Math.sin( index * startValue );
   }
   
   public synchronized void initializeStatic( int size,  int  startValue){
      classData  =  new  int[ size ];
      for  ( int  index  = 0; index < size;  index++ )
         classData[ index ]  =  (int ) Math.sin( index * startValue );
   }
}

Doc 17, Threads part 2 Slide # 14

Synchronized Statements

synchronized ( expr ) {
   statements
}

   class LockTest {
      public synchronized void enter() {
         System.out.println( "In enter");
      }
   }

   class LockTest {
      public void enter() {
         synchronized ( this ) {
            System.out.println( "In enter");
         }
      }
   }
Doc 17, Threads part 2 Slide # 15

public class LockExample extends Thread {
   private Lock myLock;
   
   public LockExample( Lock aLock ) {
      myLock = aLock;
   }
   public void run()   {
      System.out.println( "Start run");
      myLock.enter();
      System.out.println( "End run");
   }
   public static void main( String args[] ) throws Exception {
      Lock aLock = new Lock();
      LockExample tester = new LockExample( aLock );
            
      synchronized ( aLock ) {
         System.out.println( "In Block");
          tester.start();
         System.out.println( "Before sleep");
         Thread.currentThread().sleep( 5000);
         System.out.println( "End Block");
      }
   }
}
   
class Lock {
   public synchronized void enter() {
      System.out.println( "In enter");
   }
}

Doc 17, Threads part 2 Slide # 16

Synchronized and Inheritance

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
      }

Doc 17, Threads part 2 Slide # 17

wait and notify Methods in Object

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 17, Threads part 2 Slide # 18

synchronized void waitingMethod()
   {
   while ( ! condition )
      wait();
   Now do what you need to do when condition is true
   }

Doc 17, Threads part 2 Slide # 19

synchronized void changeMethod()
   {
   Change some value used in a condition test
   notify();
   }
Doc 17, Threads part 2 Slide # 20

import java.util.ArrayList;
   
public class SharedQueue {
   ArrayList elements = new ArrayList();    
   public synchronized void append( Object item ) {
      elements.add( item);
      notify();
   }
   
   public synchronized Object get( ) {
      try {
         while ( elements.isEmpty() )
            wait();
      }
      catch (InterruptedException threadIsDone ) {
         return null;
      }
      return elements.remove( 0);
   }
}
Doc 17, Threads part 2 Slide # 21

public class Producer extends Thread
   {
   SharedQueue factory;
   int workSpeed;
   
   public Producer( String name, SharedQueue 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 17, Threads part 2 Slide # 22

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 17, Threads part 2 Slide # 23

public class ProducerConsumerExample
   {
   public  static  void  main( String  args[] ) throws Exception
      {
      SharedQueue wallmart = new SharedQueue();
      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 17, Threads part 2 Slide # 24

Smalltalk Saftey – Semaphore & RecursionLock

Causes the process to block until it is signaled

If not currently executing another critical: or wait run aBlock

Otherwise wait until other critical: ends or signal to end wait

Normally not mixed with wait & signal

Use Semaphore forMutualExclusion to create receiver for critical:

lock critical: [lock critical: [Transcript cr; show: 'entered']]

Doc 17, Threads part 2 Slide # 25

Doc 17, Threads part 2 Slide # 26

Doc 17, Threads part 2 Slide # 27

Some Thread Issues & Ideas

Passing Data – Multiple Thread Access

anObject = anotherThreadObject.getFoo();   // line A
System.out.println( anObject);         // line B

Doc 17, Threads part 2 Slide # 28

Pass copies

pubic foo getFoo() {
   return foo.clone();
}

foo
   ^foo copy

anObject.doSomeMunging( bar.clone());

anObject doSomeMunging: bar copy

Doc 17, Threads part 2 Slide # 29

Immutable Objects

anObject beImmutable

Doc 17, Threads part 2 Slide # 30

Background Operations

public class Poll  {
   public static void main( String args[] ) {
   
   TimeConsumingOperation background = 
      new TimeConsumingOperation();
   background.start();
   
   while ( !background.isDone() ) {
      performSomethingElse;
   }
   
   Object neededInfo = background.getResult();
   }
}
Doc 17, Threads part 2 Slide # 31

Futures

| delayedAnswer realAnswer |
delayedAnswer := [aClient perform: ‘computePi’ ] promise.
Do some other work here
realAnswer := delayedAnswer value

Doc 17, Threads part 2 Slide # 32

class FutureWrapper {
   TimeConsumingOperation myOperation;
   
   public FutureWrapper() {
      myOperation = new TimeConsumingOperation();
      myOperation.start();
   }
   
   public Object value() {
      try {
         myOperation.join();
         return myOperation.getResult();
      } catch (InterruptedException trouble ) {
         DoWhatIsCorrectForYourApplication;
      }
   }
}

public class FutureExample  {
   public static void main( String args[] ) {
   FutureWrapper myWorker = new FutureWrapper();
   
   DoSomeStuff;
   DoMoreStuff;
   
   x = myWorker.value();
   }
}

Doc 17, Threads part 2 Slide # 33

Callbacks

class MasterThread {
   public void normalCallback( Object result ) {
      processResult;
   }
   
   public void someMethod() {
      compute;
      TimeConsumingOperation backGround =
         new TimeConsumingOperation( this );
      
      backGround.start();
      moreComputation;
   }
}
class TimeConsumingOperation extends Thread {
   MasterThread master;
   
   public TimeConsumingOperation( MasterThread aMaster ) {
      master = aMaster;
   }
   public void run() {
         DownLoadSomeData;
         PerformSomeComplexStuff;
         master.normalCallback( resultOfMyWork );
      }
   }
}
Doc 17, Threads part 2 Slide # 34

ClientCode>>startBackground
   [| result |
   result := anObject performSomeCalculation.
   self processResult: result] fork

ClientCode>>processResult: aResult
   Handle the result here

ClientCode>>aMethod
   Do some work
   self startBackground.
   Do more work

Previous    visitors since 04-Mar-04    Next