Threads

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 - causes the application 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

Threads

• Conceptually, all threads run in parallel.
  • To understnad more about how they work, take CIS 25.
• All threads in the same application share the same address space.
  • An address space are those locations in memory that can be addressed by code
  • Two pieces of code sharing an address space effectively means they share the same memory.

Creating a Running a Thread

Either:

• Ceate a subclass of (i.e., extend) class Thread
• Implement Runnable interface
• We'll stick with the first

• Just like any other subclass
  • Can have constructor and any methods you decide upon
• Code run method
• Invoke start method
• The 'magic' happens between the invocations of start and run

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

Why 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

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

• Thread gets control and runs until it (voluntarily) gives up control
  • sleep
  • yield
  • I/O

Preemptive Threads

• Thread gets control for some amount of time (the time-slice) after which control is taken away from it (by hardware/O/S)