Java Threads

This talk summarizes material from

• Elliotte Rusty Harold, Java Network Programming [1], 2001. Chapter 5.
• The Java Tutorial: Doing Two or More Tasks At Once [2]

• A preemptive multi-tasking operating system supports multiple processes running in parallel by allocating each one a time slice.
• Each process runs on its own address space. That is, it gets its own stack, heap, and other system resources.
• Threads are units of execution that can run in parallel within one program. As such they:
  • Start-up faster.
  • Can easily communicate with each other. They can share variables.
  • Can be better controlled by the programmer (not by the OS).
• They allow a program to quickly and efficiently handle multiple asynchronous requests (e.g., requests coming from other machines).
• Since they run in parallel, they exhibit many of the same problems that arise in distributed programming. They are also used in almost all distributed programming implementations.
• You must learn to control your threads!

• If you simply want to schedule a particular action, you should use timers.
• The following example first prints "Task scheduled." and five seconds later prints "Time's up!".

import java.util.Timer;
import java.util.TimerTask;

/**
 * Simple demo that uses java.util.Timer to schedule a task to execute
 * once 5 seconds have passed.
 */

public class Reminder {
  Timer timer;
  
  public Reminder(int seconds) {
    timer = new Timer();
    timer.schedule(new RemindTask(), seconds*1000);
  }

  class RemindTask extends TimerTask {
    public void run() {
      System.out.println("Time's up!");
      timer.cancel(); //Terminate the timer thread
    }
  }

  public static void main(String args[]) {
    System.out.println("About to schedule task.");
    new Reminder(5);
    System.out.println("Task scheduled.");
  }
}

//To schedule it to go off every second do:
timer.schedule(new RemindTask(), seconds*1000, 1*1000);

• One way to implement a thread is by implementing a class that extends Thread.
• Your class must define a run() method, which is the one that will get called to run the thread.

public class SimpleThread extends Thread {
  public SimpleThread(String str) {
    super(str); //sets the name of this thread to str.
  }
  public void run() {
    for (int i = 0; i < 10; i++) {
      //print i and the name of this thread.
      System.out.println(i + " " + getName());
      try {
        sleep((long)(Math.random() * 1000));
      } catch (InterruptedException e) {}
    }
    System.out.println("DONE! " + getName());
  }
}

public class TwoThreadsDemo {
  public static void main (String[] args) {
    new SimpleThread("Jamaica").start();
    new SimpleThread("Fiji").start();
  }
}

• The other way to implement a thread is to implement a class that implements the Runnable interface.
• This is very useful when you want your class to extend some other class.
• You must implement the run() method.

import java.awt.Graphics;
import java.awt.Color;
import java.util.*;
import java.text.DateFormat;

public class Clock extends java.applet.Applet implements Runnable {
  private Thread clockThread = null;

  //Applet method
  public void init() {
    setBackground(Color.white);
  }

  //Applet method
  public void start() {
    if (clockThread == null) {
      clockThread = new Thread(this, "Clock");
      clockThread.start(); //thread starts running
    }
  }

  //A Thread method.
  public void run() {
    Thread myThread = Thread.currentThread();
    while (clockThread == myThread) {
      repaint(); //causes paint() to be called
      try {
        Thread.sleep(1000);
      } catch (InterruptedException e){ }
    }
  }

  //An applet method.
  public void paint(Graphics g) {
    Calendar cal = Calendar.getInstance();
    Date date = cal.getTime();
    DateFormat dateFormatter = DateFormat.getTimeInstance();
    g.drawString(dateFormatter.format(date), 5, 10);
  }
  // overrides Applet's stop method, not Thread's
  public void stop() {
    clockThread = null;
  }
}

• A new thread is in the "New Thread" state. It is no running.
• Thread starts running when its start() method is called. A call to this method results in the creation of an execution context for the thread and a call to the thread's run method.
• Threads do not actually run in parallel (only one CPU). They are schedule by the VM's scheduler.
• Thread that are in the Runnable state can be called on to run.
• A thread will enter the not Runnable state if it calls sleep, wait, or is blocking on I/O.
• A thread must stop itself. That is, the run method must return. An external stop has to be "soft", as in previous slide.
• The isAlive method return true if the thread is in either the Runnable or "not Runnable" states.

• The JVM scheduler is a fixed priority scheduler.
• Every thread has a priority number. Bigger is better.
• The scheduler chooses the runnable thread with the highest priority for execution. When it stops, yields, or becomes not runnable then a lower priority thread starts executing.
• If two threads of the same priority are waiting the scheduler chooses one of them to run in a round-robin fashion.
• A thread will run until:
  • A higher priority thread becomes runnable, i.e., its preemptive.
  • It yields, or its run method exits.
  • On systems that support time-slicing, its time allotment has expired.
• The scheduler does violate priority in order to avoid starvation.
• On a system without time-slicing, a selfish thread will only stop for a higher-priority thread (an equal-priority thread might have to wait a long time.)
• On systems with time-slicing (Unix, NT, W95) same-priority threads are interleaved.
• Remember: even if you have multiple threads, you still only have one CPU. Be nice!

• A producer and a consumer each runs in its own thread.
• The producer calls put while the consumer calls get. We want every item to be consumed exactly once.

public class CubbyHole {
  private int contents;
  private boolean available = false;

  public synchronized int get() {
    while (available == false) {
      try {
        wait();
      } catch (InterruptedException e) { }
    }
    available = false;
    notifyAll();
    return contents;
  }

  public synchronized void put(int value) {
    while (available == true) {
      try {
        wait();
      } catch (InterruptedException e) { }
    }
    contents = value;
    available = true;
    notifyAll();
  }
}

public class ProducerConsumerTest {
  public static void main(String[] args) {
    CubbyHole c = new CubbyHole();
    Producer p1 = new Producer(c, 1);
    Consumer c1 = new Consumer(c, 1);

    p1.start();
    c1.start();
  }
}

• The synchronized keyword means that only one thread can be accessing that function at a time.
• The wait method will block until that object (CubbyHole) calls notifyAll. Since it blocks it means that some other thread must make that call.

• Every Java thread is a member of a ThreadGroup.
• By default, threads are placed in the group of the thread that created them.

public class EnumerateTest {
  public void listCurrentThreads() {
    ThreadGroup currentGroup =
      Thread.currentThread().getThreadGroup();
    int numThreads = currentGroup.activeCount();
    Thread[] listOfThreads = new Thread[numThreads];

    currentGroup.enumerate(listOfThreads);
    for (int i = 0; i < numThreads; i++)
      System.out.println("Thread #" + i + " = " + 
                         listOfThreads[i].getName());
  }
}

• The methods that operate on ThreadGroups are:
  • getMaxPriority and setMaxPriority
  • getDaemon and setDaemon
  • getName
  • getParent and parentOf
  • toString