What are threads?

•  Threads are a way for a program to divide (termed "split") itself into two or more simultaneously (or pseudo-simultaneously) running tasks.
  
  

• Threads and processes differ from one operating system to another but, in general, a thread is contained inside a process and different threads in the same process share the same resources while different processes in the same multitasking operating system do not.

• Threads are lightweight, in terms of the system resources they consume, as compared with processes.
  

WHY Threads?

• Suppose we have 1 web server program (process) but, we have multiple users/clients that want to request a file from our web server program. Do we really want to wait until user/client 1 is completely served before starting to serve ouruser/ client 2????

  • NO we do NOT want to WAIT. So we can write a multi-threaded program to handle the multiple user requests, one on each thread as shown in the diagram below. Then we can let our SYSTEM (e.g. java virtual machine) handle how much time to spend on user/client 1's thread before pausing it and working on user/client 2's thread (and back and forth until both are served).

    >>> THIS allows us to share our resources between our users/clients. A single threaded program would mean user 2 would have to wait until user 1 complete served.

About Threads in Java

Java threads are units of a Java computation executing Java methods. Java Virtual Machines support concurrent execution of Java threads. Such multithreading is pre-emptive and prioritised. Scheduling is regulated by priorities:

• all threads have priority from 1 to 10
• threads are given by default a priority of 5
• new threads inherit the priority of their creating thread

Java scheduler

• keeps highest priority thread running at all times
• pre-empts current thread if higher priority one is ready

When a Java Virtual Machine starts up, there is usually a single non-daemon thread (which typically calls the method named main of some designated class). The Java Virtual Machine (the scheduler) continues to execute threads until either of the following occurs:

• 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 performing the stop method.

Some but not all Java schedulers support time-slicing

• while multiple threads are ready and have highest priority
• successive such threads are run for timeslice and then pre-empted
• scheduling chances continue to be distributed round robin fashion

Otherwise yield() method

• allows thread to give way to other equal priority threads
• should be periodically used when there is no time-slicing

Threads can be created by

• passing runnable object to thread constructor
• subclassing Thread so it defines its own run() method

Main methods of Java threads are:

getPriority() gets priority of thread

interrupt() wakes sleep/waiting thread via InterruptedException sets interrupted flag on non-sleeping thread

run() body of thread

resume() restarts suspended thread

setPriority() sets priority of thread

sleep(msecs) makes thread sleep for msecs milliseconds

start() initiates thread by executing its run() method

suspend() temporarily suspends thread until resumed

yield() gives way to equal priority threads on scheduling

Three useful inherited methods from Object class are

• notify() unblocks waiting thread
• notifyAll() unblocks waiting threads
• wait() blocks object until notified

Java Thread Synchronisation

Thread executes until it

• blocks on input/output
• calls sleep(), suspend(), stop(), wait() or yield()
• is delayed on call to synchronised method
• is pre-empted by higher priority thread
• uses up its time-slice

Higher priority thread other than running thread can become ready if

• suspended thread is resumed
• sleeping thread finishes sleeping
• it is waiting on I/O which completes
• waiting thread has notify or notifyAll called on it

2 Alternatives to create a Thread

1) class extends Thread

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

}

}

2) class implements Runnable, and then create instance of it and pass this to the general Thread constructor and start this thread.

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

}

}

Testing for Time-slicing & Parallelism

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

}

}

Output

• if Time-sliced A group of "From: Thread-5" will be followed by a group of "From: Thread-4" etc.
• if not Time-sliced, Single Processor "From: Thread-4" will repeat "forever"
• Multiple Processor "From: Thread-5" and "From: Thread-4" will intermix "forever"

Debugging Threads

Some useful methods in Thread for debugging

• public static void dumpStack() Prints a stack trace for the current thread on System.out
• public String toString() Returns a String representation of the Thread, including the thread's name, priority and thread group.
• public int countStackFrames() Returns the number of stack frames in this Thread. The Thread must be suspended when this method is called.