Threads

• Thread: a sequential flow of execution within a program
• Multithreaded program is one in which multiple threads are executing 'simultaneously'
  • Multiprocessor system
  • Mutlitasking (time-slicing)
• Also known as concurrent programming

Threads vs Processes

• Processes are heavy weight; threads are lightweight
  • Processes
    • Process is an entity managed by the operating system
      • Think of it loosely as a program
    • Creating a process entails allocating memory and bringing its image into memory
    • Switching between processes is an expensive operation
    • Processes communicate via special interprocess communication channles
  • Threads
    • Threads run within a process
    • Created either by language's run-time library or possible O/S
    • Think a thread as an independent, concurent 'threads' of execution running within a program
      • All your programs until now were single-threaded
    • Threads of the same process share the same address (memory) space so they can communicate through shared variables

Benefits of Threads

• Many applications are inherently parallel (multiple activities going on at once)
  • Decomposing into sequential threads make programming model simpler
  • Advantage here of threads over processes is threads share same address space
• Threads allow substantial CPU / I/O overlap
• Useful on multiple CPU's where real parallelism is possible
• Reactive systems, i.e., systems requiring continuous monitoring of devices is easier to write using threads (than trying to juggle everything in a single flow of execution).
• Makes systems more responsive to user input
  • Think of being able to click the STOP button in a browser while a picture is being downloaded
  • In a single threaded system, either the system is waiting for the click or its performing the I/O.
    • Even if the I/O is non-blocking (i.e. we can check whether there is a click rather than waiting for it), the logic still becomes quite messy
• Multi-threading allows a server to handle multiple clients simultaneously
• Advantage can be taken of multiple processors

Creating a Thread

• Threads in Java are instances of Thread class
• To get a thread, can either:
  • Extend Thread
  • Implement Runnable interface

Extending Thread

• Need to override the run method
• acts similar to main
  • initial entry point for thread logic

class InputThread extends Thread {
	public void run() {
		...					// main body of thread
	}
}
	

Implementing Runnable

• Have to define a run method (as above)
• Useful if have (or want) to extend a different class

class ActiveCounter extends Counter implements Runnable {
	public void run() {
		...					// main body of thread
	}
}
	

• If Thread was extended
  • Create an instance of the Thread subclass

  InputThread it = new InputThread();
  		

  Thread t = new InputThread();
  		

• If Runable was implemented
  • Create an instance of Thread passing in Runnable as the constructor argument

  Thread t2 = new Thread(new ActiveCounter());
  		

  Runnable r = new ActiveCounter();
  Thread t3 = new Thread(r);
  		

• Invoke the start method on the created object
  • NOT the run method
  • The start method contains the 'magic' needed to create the actual thread
  • Once the separate 'thread' of execution has begun, run is (indirectly) invoked
  • Invoking the run method directly would merely cause it to execute in the same thread as you invoke it

  it.start();
  		

  t.start();
  		

  new InputThread().start();
  		

  new Thread(new ActiveCounter()).start();
  		

An Example

• Using a thread to monitor for input
  • 'main' thread in tight print loop
  • want to allow user to input new word to be printed
  • How could this be done in a single-threaded program?

Lifecycle of a Thread

• NEW - created but start hasn't been invoked yet
• ALIVE - start has been invoked. Two substates
  • RUNNABLE - Ready to run
    • May or may not be actually executing
      • Depends on processor availablity
  • BLOCKED - waiting for a certain event
• DEAD - have returned from run method

Priority and Scheduling

• Some (quite a bit?) of latitude allowed among implementations
• Every thread has a priority
  • Defaults to priority of thread that created it
• May be changed via the setPriority method
• Thread with highest priority is selected (scheduled) to execute
  • If a thread with higher priority than the currently executing one becomes runnable , it will preempt the currently executing one.
• Threads of equal priority selected
  • arbitrarily
  • FIFO
• Executing thread gives up control
  • Invoking the yield method (yielding)
    • Cooperative multithreading
  • Invoking sleep, join, or wait (blocking)
    • An I/O operation will cause this to occur
  • when a higher priority thread becimes runnable (preempting)
  • when its time slice has expired (switching/preempting)
    • Not all implementations provide time-slicing

A Simple Clock Applet

import java.awt.*;
import java.applet.*;
import java.util.*;

public class Clock0 extends Applet {
	public void paint(Graphics g) {
		String display = new Date() + "";
		FontMetrics fm = g.getFontMetrics();
		int stringWidth = fm.stringWidth(display);
		int screenWidth = getWidth();
		g.drawString(display, (screenWidth - stringWidth)/2, 100);
		
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
		}
		
		repaint();
	}
}

• Stuff in grey is graphic stuff-- centering the clock display -- don't worry about it
• Thread.sleep - static method in Thread that causes the current thread to sleep for specified milliseconds (1000ths of a second).
• Each time paint is called it updates the display and calls repaint
• Note we always obtain the time from the system -- bad idea to keep track of time yourself

A Related Applet: A Stopwatch

• Start/Pause/Resume button

import java.util.*;
import java.awt.*;
import java.applet.*;
import java.awt.event.*;
import java.text.*;

public class Clock1 extends Applet implements ActionListener {
	public void init() {
		setLayout(new FlowLayout(FlowLayout.CENTER));

		clock = new Label(simpleDateFormat.format(new Date(0)));
		add(clock);

		b = new Button("Start");
		add(b);
		b.addActionListener(this);
	}

	public void actionPerformed(ActionEvent e) {
		paused = !paused;
			if (!paused) {
			b.setLabel("Pause");
			if (firstTime) {
				firstTime = false;
				startClock();
			}
		}
		else
			b.setLabel("Resume");
	}

	void startClock() {
		Date startDate = new Date();
		
		while (true) {
			if (!paused) {
				Date duration = new Date(new Date().getTime() - startDate.getTime());
				clock.setText(simpleDateFormat.format(duration));
			}
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
			}
		}
	}


	SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss");
	boolean paused = true;
	Button b;
	Label clock;
	boolean firstTime = true;
}

• Clicking button first time causes startClock to be invoked
• startClock contains infinite loop
  • never returns to actionPerformed...
  • actionPerformed never returns to whoever called it ...
  • no one around to listen to further event occurrences

Fixing the Stopwatch

• Add a thread which takes over the function of startClock
• The original thread will still be available to listen for and handle events
• We also added a Diag class that helps us see who's doing what
  • Diag contains a single static method that accepts a message and prints it together with the name of the currently executing thread

class Diag {
	static void threadPrint(String what) {
		System.err.println(what + ": " + Thread.currentThread().getName());
	}
}

import java.util.*;
import java.awt.*;
import java.applet.*;
import java.awt.event.*;
import java.text.*;

public class Clock2 extends Applet implements ActionListener {
	public void init() {
		Diag.threadPrint("init");

		setLayout(new FlowLayout(FlowLayout.CENTER));
		Label clock = new Label(simpleDateFormat.format(new Date(0)));
		add(clock);

		b = new Button("Pause");
		b.setForeground(Color.red);
		add(b);
		b.addActionListener(this);

		clockThread = new Clock2Thread(clock);
		clockThread.start();
	}

	public void actionPerformed(ActionEvent e) {
		Diag.threadPrint("actionPerformed");
		boolean paused = clockThread.togglePaused();
		if (!paused) {
			b.setForeground(Color.red);
			b.setLabel("Pause");
		}
		else {
			b.setForeground(DARK_GREEN);
			b.setLabel("Resume");
		}
	}


	SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss");
	static final Color DARK_GREEN = new Color(0, 100, 0);
	Button b;
	Clock2Thread clockThread;
}

• Again, greyed-out stuff is formatting/graphics
• Note the creation of the Clock2Thread object and the invocation of start
• Also note how the actionPerformed method controls the clock thread via the togglePaused method

... and here's the thread ...

import java.awt.*;
import java.util.*;
import java.text.*;

class Clock2Thread extends Thread {
	Clock2Thread(Label clock) {this.clock = clock;}

	boolean togglePaused() {
		Diag.threadPrint("togglePaused");	
		paused = !paused;
		return paused;
	}

	public void run() {
		Diag.threadPrint("run");
		Date startDate = new Date();
		int count = 0;
		while (true) {
			if (!paused) {
				Date duration = new Date(new Date().getTime() - startDate.getTime());
				clock.setText(simpleDateFormat.format(duration));
				count++;
				if (count > 10) {
					Diag.threadPrint("tick");
					count = 0;
				}
			}
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
			}
		}
	}

	SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss");
	boolean paused = false;
	Label clock;
}

Thread Safety

• Multi-threaded programs can easily corrupt data if not written correctly
• Thread-safe: consistency is maintained in the presence of multiple threads
• Critical region: segement of code within which only one thread should be executing
• Mutual exclusion: ensuring only one process is in a critical region at any point
• race condition: resulting state of (multi-threaded) code is dependent upon sequence/timing of the threads
• Basic Rule: correctness must never be based upon relative speed of processors or order of execution of threads

Ensuring Thread Safety in Java

• Mutual exclusion: provided via the synchronized keyword
  • Prevents simultaneous access to critical shared data
  • Can be applied at the method or block level
• Cooperation: allows threads to coordinate with each-- achieve through join, wait and notify

An Example - A credit card system

• Transactions (charges) are made against accounts
• Two transactions may happen 'simultaneously'
• Without any synchronization
• With synchronization
• Improper synchronization

Another Example-- Mutli-Threaded Quicksort

• After partitioning, create two child threads to handle the recursive tasks
  • This version Doesn't Work
• Need to have some way of knowing when we're done
  • Use Java's thread-copperation mechanisms- Quicksort Using join
  • Use Java's thread-copperation mechanisms- Quicksort Without join

More Applications of Threads

• Multi-threaded
  • Interactive thread
  • Reformatting thread
  • Auto-save thread
• Single-threaded
  • Backup would 'hang-up' rest of application (in particular user input)
  • Could have user input interrupt disk backup, at the cost of programming complexity

• As a threaded application
• Two sequential threads
  • Dispatcher thread reads incoming requests
  • Dispatcher hands request over to an available worker thread
  • Worker thread is then woken up (by dispatcher)

  //Dispatcher Thread
  while (1) {   
  	request = getNextRequest()
  	handOffRequest(request)
  }
  		

  //Worker Thread
  
  while (1) {
  	request = waitForWork()   
  	found = lookInCache(request, page)
  	if (!found)
  		readPageFromDisk(request, page)
  	returnPage(page)
  }
  	

• Unthreaded?
  • Single thread
    • main loop of the server gets request and completes it before moving to next request
    • During disk I/O server is idle and no other requests are serviced

#3 - Inputting, Processing and Outputting Blocks of Data

• Usual approach
  • Single thread
    • read data
    • process data
    • write data
• Threaded
  • Three threads
    • Input thread
    • Processing thread
    • Output thread