In a single thread only one piece of work can be actioned at a time, with multiple threads multiple tasks can be actioned at the same time. Note that you need a multi-processor to effectively run multi-threaded programs. A thread means two different things:

• An instance of class java.lang.Thread
• A thread of execution

Using threads also can have downsides, the programming can become complex, synchorization becomes more important as data can be clobbered and thus results can be incorrect, data caching can also cause problems and many many threads cause performance problems (context switching). Also threads are undetermined on the order they are run in, you can run a number of threads multiple times and each time will be a different order.

There is a difference between multithreading and parallel processing, as you can see in the diagram below, in parallel processing threads are able to run at the same time, this of course requires a multi-core CPU that allows simultaneous executing of threads, multithreading can run on a single CPU but time slicing is used to allow each thread some execution time.

When talking about performance in multithreading we often look at two areas

• Latency - the time to completion of a task, measured in time units, for example rendering a movie clip. This can be achieved by breaking a task into smaller tasks, the number of sub-tasks should exactly match or be less the number of cores to be truly parallel. One note to make is its pointless breaking up small tasks it will be counter productive and will be slower than running a single task
• Throughtput - the amount of tasks compleetd in a given time, measured in tasks/time unit, for example cruching larges amount of weather data in a specifc time. Again we can break the task into subtasks and use threads, however to achieve higher throughput we can use thread pooling, this means you don't have to recreate each thread but use existing already create threads from a pool thus saving time. I have covered advanced thread executing and pools in my concurreny section

An instance of Thread is just a object, it can have variables and methods and lives and dies on the heap, a thread of execution is an individual process (a lightweight process) that has it's own call stack. There is always at least one thread (the one that calls main()) which is called the main thread. Different JVM's treat threads differently, there is no guarantee that code on one system will work the same on another.

• Heap - Objects, class memebers, static variables (all shared by threads)
• Stack - local primitive types, local references (not shared by threads)

Just as we start from main( ) in an application program we always start from run( ) in a thread instance, you can define and instantiate a thread in one of two ways

• Extend the java.lang.Thread class
• Implement the Runnable interface

The thread class defines several methods which I will go into detail in this section

In the real world you are more than likely to implement the runnable interface than extend Thread, however extending the Thread class is easier but is considered bad practice because subclassing should be reserved for classes that extend an existing classes, because they're a more specialized version of the more general superclass, so you should only extend the Thread class if you have a more specialized version of the Thread class.

Lastly threads have priorities which determines how the thread is treated with respect with others. A thread's priority is used to decide when to switch from one running thread to the next, this is called context switch, there are rules on when this occurs, I discuss priorities with examples later in this section

• A thread can voluntarily relinquish control, this is done by explicity yielding,sleeping and blocking on pending I/O. All other threads are examined and the highest priority thread that is ready to run is given the CPU
• A thread can be preempted by a higher-priority thread, in this case the higher-priority thread that wants to run does, this is called preemptive multitasking
• Always use defensive coding, threads may run for a very long time, either set the daemon thread to true or when using join use a timeout value

package uk.co.datadisk;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class multithread1 {

    private static int counter = 0;
    private static Lock lock = new ReentrantLock();

    public static void increment(){
        lock.lock();
        counter++;
        lock.unlock();
    }

    public static void firstThread(){
        for(int i=0;i<1000;i++){ increment(); }
    }

    public static void secondThread(){
        for(int i=0;i<1000;i++){  increment(); }
    }

    public static void main(String[] args) {

        Thread t1 = new Thread(new Runnable() {
            public void run() { firstThread(); }
        });

        Thread t2 = new Thread(new Runnable() {
            public void run() { secondThread(); }
        });

        t1.start();
        t2.start();

        try {
            // use a join timeout value to protect your code from running for a very very long time
            // or set the daemon flag to true so that if main thread dies all other threads die with it
            t1.join();                              // pause here until thread dies, then move on
            t2.join();                              // pause here until thread dies, then move on
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(counter);                // won't be executed until all threads that used join have died
    }
}

public class ThreadExample1 {

    public static void main(String[] args) {
        MyThread mt1 = new MyThread();                      // create thread using Thread
        Thread mt2 = new Thread(new MyRunable());           // Create thread using Runnable
        
        mt1.start();                                        // use start to start a Thread
        mt2.start();                                        // use start to start a thread using Runnable
    }
}

class MyRunable implements Runnable {                       // we implement Runnable
    @Override
    public void run() {
        System.out.println("This is my Runable thread");    // override run method
    }
}

class MyThread extends Thread {                             // extend Thread
    @Override
    public void run() {
        System.out.println("This is my Thread thread");     // override run method
    }
}

Now you need to instantiate your thread

There are multiple Thread constructors

• Thread()
• Thread(Runable Target)
• Thread(Runable Target, String Name)
• Thread(ThreadGroup group, Runable Target)
• Thread(ThreadGroup group, Runable Target, String Name)
• Thread(ThreadGroup group, String Name)

Now that we have a Thread with a run() method, the Thread is said to be in the new state (see thread states below) , at this point the Thread is not considered to be alive. You can test to see if a thread is alive by calling the isalive() method on the thread instance.

To get the thread started (create a new call stack, etc) you call the threads start( ) method which in turns calls the run( ) method

When you call start on the thread the following happens

• A new thread of execution starts (with a new call stack)
• The thread moves from the new start to the runnable state
• When the thread gets a chance to execute, it's target run() method will run

Make sure that you call start() to start the thread of execution and not run() as the run() method will be treated just like any normal method.

A complete example follows

We need to know a couple of these here before we gone on, when a thread has finished, the stack for that thread dissolves and the thread is considered dead. Once a Thread has finished executing, it cannot be restarted (you get a IllegalThreadStateException).

Exception Handling

You can set a exception handler to handle all exceptions, using the setUncaughtExceptionHandler you define a method that will be used when an uncaught exception is thrown, the uncaughtException method accepts the Thread and Exception which then can be used inside the method to give details on what went wrong.

public class thread_exception1 {

    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                throw new RuntimeException("Something broke.....");
            }
        });

        thread.setName("Exception Thread");

        thread.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
            @Override
            public void uncaughtException(Thread t, Throwable e) {
                System.out.println("Caught thread exception: " + t.getName() + " , message:" + e.getMessage());
            }
        });
        thread.start();
    }
}

The Thread Scheduler

It is up to the JVM to decide which thread gets CPU time (although most JVM's map Java threads directly to native threads on the underlying O/S), as long as the thread is in a runnable state. The JVM will pick any thread in a runnable state so there is no guarantee which one the JVM will choose. Although we cannot get the JVM to pick a particular thread we can try and influence it a bit. However it's job is to keep the highest priority thread on the processor.

Some Java platforms support timeslicing and others may not, without timeslicing threads of equal priority run to completion before their peers get a chance to execute, with timeslicing, each thread receives a brief burst of processor time called a quantum during which that thread can execute. At the completion of the quantum, even if the thread has not finished executing, the processor is taking away from that thread and given to the next thread of equal priority if one is available.

Some of the methods in the Thread class can help the JVM to pick a particular over another thread but this is no means guaranteed

Every class in Java inherits the following three thread related methods, we will see examples of this in the thread interaction section below.

Thread States

A thread can be in one of five possible states, use the getState() method

Preventing Thread Execution

Sometimes you may want to slow a thread down, you can force the thread to sleep before it goes back into the runnable state after it has been exectuing. the sleep() method is a static method of the Thread Class, that you can use in your code to slow down a thread.

You pass the number of millseconds that you want the thread to sleep for, just remember that you have no control how long the thread will be on the cpu but onces it is off the cpu (now in runnable state) the thread will sleep a minimum of the number of seconds specified plus what it takes to get back on the cpu.

public class ThreadExample2 {
    public static void main(String [] args) {
        myRunnable r = new myRunnable();

        Thread t1 = new Thread(r);
        Thread t2 = new Thread(r);

        t1.setName("Thread One");
        t2.setName("Thread Two");

        t1.start();
        t2.start();

        // because sleep() can throw a checked InterruptedException it must be in a try-catch block
        //
        try {
            t1.sleep(10000);                   // put the thread to sleep for 10 seconds
        } catch (InterruptedException e) {
            System.out.println(e);
        }
    }
}

class myRunnable implements Runnable {
    public void run() {
        for ( int i = 1; i < 1000; i++)
            System.out.println("Thread: " + Thread.currentThread().getName());
    }
}

Thread priorities range from 1-10 (10 being the highest), if a thread enters the runnable state and it has a higher priority than any other threads in the pool and higher than the currently running thread, the lower priority thread will be put back into a runnable state and the higher priority thread will get access to the cpu, again this is not guaranteed, use it to improve the efficiency of your program but don't depend on it. Becareful at keeping a particular thread at low priority as it may be starved of cpu time.

If two threads are of equal priority then the JVM will decide what should run on the cpu and what should'nt and as the JVM has a mind of its own then there are no guarantees which one will run.

You can use the yield() method to make a already running thread head back into a runnable state, however there are no guarantees that the JVM won't pick the same thread to go back on the cpu again.

The join() method lets one thread join "on to the end" of another thread, if you have thread B that can't do its work until another thread A has completed its work, then you want thread B to "join" thread A. This means thread B will not become runnable until thread A is in the dead state.

So there are three ways that a thread could leave the running state

Synchronizing Code

Take the classic banking problem were two people access the account at the same time to with draw funds, if an account has £100 in it and both people draw £100 each at the same time, if unchecked both could get £100 (£200 in total), the account will now be overdrawn by -£100 which is not what the people wanted to happen (probably have to pay extra for being overdrawn). We must guarantee that the two steps of the withdrawal - checking the balance and making the withdrawal are never split apart, they must be performed as one operation, even if the thread falls asleep in between the steps, this is called a "atomic operation" which means that the thread must complete its operation before any other thread can act on the same data.

You cannot guarantee that a single thread will stay running throughout the entire atomic operation, but you can guarantee that even if the thread running the atomic operation moves in and out of state, no other thread will be able to act on the same data (takes it's locks with it).

To protect the data you must do two things:

• Mark the variable private
• Synchronize the code that modifies the variable (more granular)

What you are doing here is protecting the method that accesses the private variable, you do this by using the keyword synchronized.

The way synchronization works is by using locks, every object in Java has a built-in lock that only comes into play when the object has synchronized method code. Since there is only one lock per object, if one thread has picked up the lock (known as obtaining the lock) no other thread can enter the synchronized code until the lock is released.

The key points to remember are

• Only methods can be synchronized
• Each object has one lock
• Not all methods in a class must be synchronized, a class can have both synchronized and non-synchronized methods
• Once a lock has been placed on one synchronized method no other thread can enter any of the synchronized methods in that class.
• if you have both synchronized and non-synchronized methods you can still access the non-synchronized methods, even if you already have lock on the object
• if a thread goes to sleep it takes the lock with it.
• A thread can require more than one lock (on different objects - remember only one lock per object).
• You can also synchronize a block of code rather than a method (only protect necessary data)
• Static methods can be synchronized.

Thread Deadlock and LiveLock

A thread deadlock is when two threads block each other, waiting for each others resource, neither can run until the other releases its resource, kind of chicken and egg problem. A solution before implementing locks is to enforce a strict order (same order for all threads) on lock acquistion.

A Livelock is two or more threads keep on transferring states between one another instead of waiting infinitely as we saw in the deadlock example, they are not blocked but too busy responding to each others work. Consequently, the threads are not able to perform their respective tasks.

I also cover locks in my concurrency section.

An example of a deadlock code is below

Below is a table that explains when a lock is released or when it is not

Thread Interaction

Threads communicate their lock status through three methods

• wait()
• notify()
• notifyAll();

All three methods must be called from a synchronized method or block. A thread cannot invoke a wait or notify method on an object unless it owns that object's lock. Every object inheriates the three methods from the Object class.

An example using the wait() and notify() methods, every object can have a list of threads that are waiting for a signal from the object, again there is no order who on the list gets access when notify is called, any one could be choosen (no guarantee order).

The difference between notify() and notifyAll() is that when you have a list of threads waiting on the lock notify() will only notify one thread which one it is is up to the JVM, notifyall() will notify all waiting threads. So if you ever have a number of threads waiting for a lock then it is best to use notifyAll()

Key Thread Methods

Below is a table which lists the classes and the assoicated methods regarding Threads

Daemon Threads and Interrupting Threads

A daemon thread is a thread that runs for the benefit of other threads, they run in the background. Unlike normal threads, daemon threads do not prevent a program terminating. The garbage collector is a daemon thread.

You can interrupt a thread using the interrupt() method of a thread demo'ed by the first example, the second example uses isInterrupted to determine if interrupt() has been called on a Thread, this can help on long running threads to kill them after a specific time, you can also use the daemon thread to kill long running threads without the need to check that the interrupt() method has been called on it.

public class Main1 {
    public static void main(String [] args) {
        Thread thread = new Thread(new BlockingTask());

        thread.start();
		thread.interrupt();
    }

    private static class BlockingTask implements Runnable {

        @Override
        public void run() {
            //do things
            try {
                Thread.sleep(500000);
            } catch (InterruptedException e) {
                System.out.println("Existing blocking thread");
            }
        }
    }
}

public class thread_interrupt {

    public static void main(String[] args) {
        Thread thread = new Thread(new ForeverLoop());

        thread.start();
        thread.interrupt();     // interrupt the Thread
    }

    private static class ForeverLoop implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 1000000000; i++) {
                // Use isInterrupted to determine if the Thread has been interrupted
                if(Thread.currentThread().isInterrupted()) {
                    System.out.println("Thread has been killed :-(");
                    return;
                }
                System.out.println(i);
            }
        }
    }
}

Thread Groups

Sometimes it is useful to identify various threads as belonging to a thread group, class ThreadGroup contains methods for creating and manipulating thread groups. You would useful for example to interrupt all threads in the group, set the priority of all threads in the group, you can also have groups within groups. The ThreadGroup has many methods to stop, list, suspend, resume, interrupt, destroy, etc threads within the group.

There are two constructors in the ThreadGroup class

• ThreadGroup( String groupName)
• ThreadGroup( ThreadGroup parentGroup, String groupName)

public class ThreadGroupDemo implements Runnable{

    public void run() {
        System.out.println(Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        ThreadGroupDemo runnable = new ThreadGroupDemo();
        ThreadGroup tg1 = new ThreadGroup("Parent ThreadGroup");

        Thread t1 = new Thread(tg1, runnable,"one");
        t1.start();
        Thread t2 = new Thread(tg1, runnable,"two");
        t2.start();
        Thread t3 = new Thread(tg1, runnable,"three");
        t3.start();

        System.out.println("Thread Group Name: "+tg1.getName());
        tg1.list();

    }
}

Thread Performance

You can use Thread pools that use workers that can break up a a large task, the pool manages the workers, you can even specify the max number of workers (or cores) that you wish to allocate to the pool. I have also cover advanced pooling in my concurrency section. There are a couple of basic pooling services that you can use as per below

• ExecutorService
• ThreadPoolExecutor

public class threadPool {

    private static final int MAX_NUMBER_OF_THREADS = 6;

    public static void main(String args[]) {
        // Can use the below but not as advanced as ThreadExecutorPool
        // Executor pool = Executors.newFixedThreadPool(MAX_NUMBER_OF_THREADS);
        ThreadPoolExecutor pool = (ThreadPoolExecutor) Executors.newFixedThreadPool(NUMBER_OF_THREADS);

        for (int i = 0; i < 20; i++) {
            Runnable worker = new WorkerThread("Thread - " + i, pool);
            pool.execute(worker);
        }
        pool.shutdown();
        while (!pool.isTerminated()) {
        }
        System.out.println("Finished all threads");
    }
}

class WorkerThread implements Runnable {

    private String threadName;
    private ThreadPoolExecutor pool;

    public WorkerThread(String threadName, ThreadPoolExecutor pool) {
        this.threadName = threadName;
        this.pool = pool;
    }

    @Override
    public void run() {
        System.out.println("Thread Name: " + threadName);
        System.out.println("Pool Size: " + pool.getPoolSize());
        System.out.println("Active Count: " + pool.getActiveCount());
        System.out.println("Core Pool Size: " + pool.getCorePoolSize());
        System.out.println("Queue Size: " + pool.getQueue().size());
    }
}