"Imagine that you are using your favorite text editor on a large file. When it starts up, does it need to examine the entire file before it lets you edit? Does it need to make a copy of the whole file? Wouldn't it be nice for it to show you the first page, enabling you to begin editing, and somehow (in the background) complete the slower tasks necessary for initialization? Threads allow exactly this kind of within-the-program parallelism." from Java in 21 Days

SUN tutorial and What is a Thread?

A thread represents a single process in execution on a system. Threads are sometimes referred to as light-weight processes or execution contexts. Typically, each thread controls a single aspect within a program, such as monitoring a particular input device or handling all of the disk I/O.

Has an execution context, program counter, stack, ...

• not a fork - it does not make copies and it is not a kernel-level entity...
• almost like exec, again, has its own registers, program counter, stack pointer, etc...but closer to a user-level entity

Multithreaded applications (and applets) use several execution contexts to accomplish their tasks. They make use of the fact that many tasks contain separate and distinct sub-tasks. One thread can be used for each subtask.

A multithreaded program allows each thread to start and finish as quickly as possible; this behavior provides better response to real-time input.

Note also that the vonNeumann machines will not be here forever; multiple processor machines are clearly here/coming; this is great experience in parallel processing and parallel algorithm considerations.

Here are a couple of examples of SUN using Threads for use in Swing: How to Use Threads and Threads in Applets

Introducing Threads

A SimpleThread example:

class SimpleThread extends Thread { public SimpleThread(String str) { super(str); } public void run() { for (int i = 0; i < 10; i++) { System.out.println(i + " " + getName()); try { sleep((int)(Math.random() * 1000)); } catch (InterruptedException e) {} } //see API: methods throw exceptions System.out.println("DONE! " + getName()); } }

Because applications go through main() when starting (and Applets through init()), note that with Swing, they start the programs off with calls to Runnable objects that immediately define and call the Interfaces run() method. Here are examples of instantiating classes that extend Thread. Look at the classes' (T , TestThread , SimpleThread) constructors for more information.

Examples:

T t = new T(); t1=new TestThread("Thread1",(int)(Math.Random()*2000)); SimpleThread st = new SimpleThread("myGuy");

Because we have direct control of our thread, we must start it directly as well:

t1.start();

Below is a first simple use of threads.

//threads are in java.lang.Thread public class A { public static void main(String args[]) { T t = new T(); t.start(); }} class T extends Thread{ public void run() { while(true) { System.out.println("b: "); try { sleep(300); } // sleep is in milliseconds catch (InterruptedException e){} } } }

The sleep() method simply tells a thread to be quiet for (at least) the specified number of milliseconds. You can use sleep when you delay execution of a thread. The sleep() method does not take up system resources while the thread sleeps. Other threads can (will) continue to work.

Below is a another simple introduction to threads.

// Define our simple threads. They will pause for a short time // and then print out their names class TestThread extends Thread { private String whoami; private int delay; // Our constructor to store the name (whoami) // and time to sleep (delay) public TestThread(String s, int d) { whoami = s; delay = d; } // Run - the thread method similar to main() // When run is finished, the thread dies. // Run is called from the start() method of Thread public void run() { // Try to sleep for the specified time try { sleep(delay); } catch (InterruptedException e) {} // Now print out our name System.out.println(whoami + " " + delay); } }

That class then implements the run method. An instance of the class can then be allocated, passed as an argument when creating Thread, and started.
See Thread API for constructors of Threads

The program below creates a thread that prints 3 messages.

Notice the interface Runnable (remember interface and implement?)

To create a thread, you must subclass Thread so that it defines its own run() method,
OR
you must pass a Runnable object to the Thread constructor.

The interface specifies the run() method that is required for use with the Thread class. Any class that implements this interface can provide the "body" of a thread. By implementing the interface Runnable you declare your intention to run on a separate thread.

import java.awt.Graphics; import java.applet.Applet; public class demoT extends Applet implements Runnable { Thread demoThread; String Message[] = {"Hello World!" , "I'm doing fine." , "Good-bye for now!"}; int numMessages = Message.length; int i = 0; public void paint(Graphics g) { g.drawString(Message[i], 5, 10); } public void run() { while ((demoThread != null) && (i < 2)){ i = (i + 1) % numMessages; repaint(); try { demoThread.sleep(5000); } catch (InterruptedException e){ } } } public void start() { if (demoThread == null) { demoThread = new Thread(this,"Thread Demonstration"); demoThread.start(); } } public void stop() { demoThread = null; } }

See notes on methods in Thread that were deprecated...and why

Particular help for CSCI 311 Course

"A thread is an independent flow of control within a process, composed of a context (which includes a register set and a program counter) and a sequence of instructions to execute. An independent flow of control is essentially an execution path through the program code in a process. The register set and program counter contain values that indicate the current state of program execution. Finally, the sequence of instructions to execute is the actual program code"

• Why? Programmers have been trained to think linearly and often fail to take advantage of the simultaneous paths a program might take

• Initial
  A thread object is in the initial state from the period when it is created (that is, its constructor is called) until the start() method of the thread object is called
• Runnable
  A thread is in the runnable state once its start() method has been called. There are various ways in which a thread leaves the runnable state, but the runnable state can be thought of as a default state: if a thread isn't in any other state, it's in the runnable state
• Blocked
  A thread that is blocked is one that cannot be run because it is waiting for some specific event to occur. A simple example is the case of a thread that has opened a socket to some remote data server and attempts to read data from the server when data is not available.
• Exiting
  A thread is in the exiting state once its run() method returns or its stop() method has been called

Related term:

• isAlive(): Determines if a thread is considered alive. By definition, a thread is considered alive sometime before a thread is actually started and sometime after a thread is actually stopped,

• join() : Waits for the completion of the specified thread. By definition join() returns as soon as the thread is considered "not alive". When the join() method is called, the current thread will simply wait until the thread it is joining with is no longer alive. This can be caused by the thread being stopped by yet another thread, or by completion of the thread itself.
  import java.applet.Applet; public class MyJoinApplet extends Applet { Thread t[] = new Thread[30]; public void start() { for (int i=0; i<30; i++) { t[i] = new CalcThread(i); t[i].start(); } } public void stop() { for (int i=0; i<30; i++) { try { t[i].join(); } catch (InterruptedException e) {} } } }
  No matter how we could have coded the join() loop, the time to complete the join() will be the time it takes for the last thread to finish. Still confused? Here is more on join().