CS 596 Java Programming Fall Semester, 1998 Threads, part 1
	To Lecture Notes Index © 1998, All Rights Reserved, SDSU & Roger Whitney San Diego State University -- This page last updated 13-Nov-98

References
Concurrent Programming
Threads

Creating Threads
Solaris, Green & Native Threads
Thread Scheduling

Preemptive
Single Processor -Time-slicing or not time-sliced

Types of Threads: user and daemon

References

S-nov2 10mins Doc 18, Threads, part 1 Slide # 2

Concurrent Programming

Two different threads could write to the same memory location at the same time, leaving the memory location in an improper state.

Threads can become deadlocked, each thread waiting forever for the other to perform a task. Threads can become livelocked, waiting forever to get their turn to execute.

Thread activities can become intertwined. Different executions of a program with the same input can produce different results. This can make program hard to debug.

Different threads in the same program execute autonomously from each other. Communication between threads is an issue.

S-nov2 1min Doc 18, Threads, part 1 Slide # 3

Threads

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

S-nov2 7mins, Q-nov5 10mins Doc 18, Threads, part 1 Slide # 4

Creating Threads

class  SimpleThread  extends Thread {
   public void run() {
      for  ( int  count = 0;  count < 4; count++)
         System.out.println( "Message " + count +
                          " From: Mom" );
   }
}
class  TestingSimpleThread {
   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" );
   }
}

Create the thread
Started the thread
End
Message 0 From:  Mom
Message 1 From:  Mom
Message 2 From:  Mom
Message 3 From:  Mom
S-nov2 3mins, Q-nov5 2mins Doc 18, Threads, part 1 Slide # 5

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

Create the thread
Started the thread
End
Message 0 From: Dad
Message 1 From: Dad
Message 2 From: Dad
Message 3 From: Dad
S-nov2 1min Doc 18, Threads, part 1 Slide # 6

class  SecondMethod  implements  Runnable {
   public  void  run() {
      for  ( int  count = 0;  count < 2; count++)
         System.out.println( "Message " + count +  " From: " + 
                        Thread.currentThread().getName() );
   }
}
class  TestThread {
   public static void main( String[]  args ) {
      Thread  a  =  new Thread(new SecondMethod(), "Mom" );
      Thread  b  =  new Thread(new SecondMethod(), "Dad" );
      System.out.println( "Create the thread");
      a.start();
      b.start();
      System.out.println( "End" );
   }
}

Create the thread
End
Message 0 From: Mom
Message 1 From: Mom
Message 0 From: Dad
Message 1 From: Dad
S-nov2 55secs, Q-nov5 1min Doc 18, Threads, part 1 Slide # 7

public 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() );
         }
      }
   }
S-nov2 5mins, Q-nov5 4mins Doc 18, Threads, part 1 Slide # 8

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

java -native TestThread

End
0 From: Thread-0
1 From: Thread-0
2 From: Thread-0
0 From: Thread-1
1 From: Thread-1
2 From: Thread-1
3 From: Thread-0
3 From: Thread-1
4 From: Thread-0
4 From: Thread-1
Doc 18, Threads, part 1 Slide # 9

Solaris, Green & Native Threads

java -native className

S-nov2 7mins, Q-nov5 1min Doc 18, Threads, part 1 Slide # 10

Thread Scheduling

Preemptive

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

S-nov2 4mins Doc 18, Threads, part 1 Slide # 11

Single Processor -Time-slicing or not time-sliced

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

It 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 18, Threads, part 1 Slide # 12

S-nov2 2mins Doc 18, Threads, part 1 Slide # 13

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

S-nov2 2mins, Q-nov5 1min Doc 18, Threads, part 1 Slide # 14

Types of Threads: user and daemon

Daemon threads are expendable. When all user threads are done, the program ends all daemon threads are stopped

User threads are not expendable. They continue to execute until their run method ends or an exception propagates beyond the run method.

• The exit method of class Runtime has been called and the security manager has permitted the exit operation to take place.

• All threads that are not daemon threads have died, either by returning from the call to the run method or by throwing an exception that propagates beyond the run method.

S-nov2 3mins, Q-nov5 2mins Doc 18, Threads, part 1 Slide # 15

class DaemonExample
   {
   public  static  void  main( String  args[] )
      {
      InfinityThread  shortLived      = new InfinityThread( );
      shortLived.setDaemon( true );
      shortLived.start();
      System.out.println( "Bye");
      }
   }
class  InfinityThread  extends Thread
   {
   public  void run()
      {
      while (true)
         {
         System.out.println(  "From: " + getName()  );
         System.out.flush();
         }
      }
   }

Bye

visitors since 28-Oct-98