CS 596 Client-Server Programming
Threads

1. Threads
   1. Creating Threads
   2. SimpleThread for Use in Future Examples
   3. Thread Scheduling - Preemptive
   4. More Streams
   5. Messages between Threads
   6. Synchronize

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

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

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

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

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

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

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

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

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

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

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

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

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 )  {}
            }
        }
    }

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

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

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

import java.io.*;
import sdsu.io.ASCIIInputStream;

class  StreamExample
    {
    public  static  void  main( String  args[]  ) throws Exception
        {
        File  sourceFile  =  new File( "ReadingFileExample.java" );
        FileInputStream inputFile  = new FileInputStream( sourceFile);

        ASCIIInputStream  fileIn;
        fileIn  =  new  ASCIIInputStream( inputFile );
        fileIn.readWord();

        ASCIIInputStream  standardIn;
        standardIn  =  new  ASCIIInputStream(System.in);
        standardIn.readWord();
        }
    }

file

socket

keyboard

    // Modified from Sun Code
    public static InputStream Up( InputStream source ) {
        PipedOutputStream ps = null;
        PipedInputStream is = null;

        try {
            ASCIIInputStream dis = new ASCIIInputStream( source );
            String input;

            ps = new PipedOutputStream();
            is = new PipedInputStream(ps);
            PrintStream os = new PrintStream( ps );

            while ( ( input = dis.readLine() ) != null ) {
                os.println( input.toUpperCase ) );
            }
            os.close();
        } catch ( Exception e ) {
            System.out.println( "StringUtils reverse: " + e );
        }
        return is;
    }

import java.io.*;
import sdsu.io.ASCIIInputStream;

class  ReadThread  extends Thread
    {

    private  ASCIIInputStream  cin;

    public  ReadThread(  String  name,  PipedInputStream  input )
        {
        super( name );
        cin  =  new ASCIIInputStream( input );
        }

    public  void run() 
        {
        try
            {
            System.out.println( "Start " + getName() );
            String  message  =  cin.readWord();
            System.out.println( message +  " From: " + getName() );
            }
        catch  ( Exception  ignored )
            {
            }
        }
    }

class  TestIO
    {
    public static void main( String[]  args )  throws Exception
        {

        PipedInputStream  inPipe  =  new PipedInputStream();
        PipedOutputStream  outPipe  =  new PipedOutputStream(inPipe);

        PrintStream  cout  =  new  PrintStream(  outPipe  );

        ReadThread  reader  =  new ReadThread( "Read",  inPipe  );
        reader.setPriority( 6 );   // 5 is normal priority
        reader.start();

        System.out.println( "In Main" );
        cout.println( "Hello" );
        System.out.println( "End" );
        }
    }

import sdsu.io.ASCIIInputStream;

class  IOThread  extends Thread
    {
    public  IOThread(  String  name ) {  super( name );  }

    public  void run()
        {
        System.out.println( getName() + "Is starting" );
        System.out.print( "Please Type an integer: " );
        System.out.flush();

        ASCIIInputStream  cin = new ASCIIInputStream(System.in);
        try
            {
            int input = cin.readInt();    // Wait here
            System.out.println( "You typed: " + input );
            }
        catch  ( Exception  ignored )  {}
        }
    }

class  TestIOBlocking
    {
    public static void main( String[]  args )  throws Exception
        {
        Thread  worker  =  new SimpleThread( "Worker",  10 );
        IOThread  boss  =  new IOThread( "The Boss" );

        boss.setPriority( 5 );
        worker.setPriority( 5 );   // 5 is normal priority

        worker.start();
        boss.start();
        System.out.println( "End" );
        }
    }

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

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

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

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

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 )  {}
            }
        }
    }

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

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