Threads - Revision history

Suhridk at 08:52, 25 October 2012

2012-10-25T08:52:22Z

Suhridk at 08:51, 25 October 2012

2012-10-25T08:51:37Z

Suhridk: /* Thread Interrupts */

2011-12-29T20:41:18Z

Thread Interrupts

Suhridk: /* Thread Exceptions */

2011-09-13T07:56:04Z

Thread Exceptions

Suhridk: /* Thread Communication */

2011-09-12T05:00:11Z

Thread Communication

Suhridk: /* Join */

2011-09-05T09:09:40Z

Join

Suhridk: /* Intro */

2011-09-05T09:08:16Z

Intro

Suhridk: /* Intro */

2011-09-05T07:45:25Z

Intro

Suhridk: /* Thread Exceptions */

2011-09-02T05:36:58Z

Thread Exceptions

Suhridk: /* Thread Checked Exceptions */

2011-09-02T05:32:08Z

Thread Checked Exceptions

← Older revision		Revision as of 08:52, 25 October 2012
Line 917:		Line 917:
	* wait() and notify() also throw an unchecked IllegalMonitorStateException when the thread invoking them does not own the object lock.		* wait() and notify() also throw an unchecked IllegalMonitorStateException when the thread invoking them does not own the object lock.

−	[[Category:OCPJP]][[~~Cateogry~~:RealtimeJava]]	+	[[Category:OCPJP]]
		+	[[Category:RealtimeJava]]

← Older revision		Revision as of 08:51, 25 October 2012
Line 917:		Line 917:
	* wait() and notify() also throw an unchecked IllegalMonitorStateException when the thread invoking them does not own the object lock.		* wait() and notify() also throw an unchecked IllegalMonitorStateException when the thread invoking them does not own the object lock.

−	[[Category:OCPJP]]	+	[[Category:OCPJP]][[Cateogry:RealtimeJava]]

@@ Line 857: / Line 857: @@
 * Thread can check if its interrupted by calling the static Thread.interrupted(). Calling this method clears the interrupt status. Threads invoking methods which dont throw interrupteexception should check this flag periodically. Based on this, it can choose to terminate or continue (In below example, the thread terminates.)
 * To check another thread's status the non static t.isInterrupted() method can be used - this does not reset the interrrupt flag.
 <syntaxhighlight lang="java5">
@@ Line 909: / Line 910: @@
 </syntaxhighlight>
 == Thread Exceptions ==

← Older revision		Revision as of 07:56, 13 September 2011
Line 803:		Line 803:

	\|}		\|}
		+
		+	== Thread Interrupts ==
		+
		+	* An interrupt is an indication to a thread that it should stop what it is doing and do something else.
		+	* It's up to the programmer to decide exactly how a thread responds to an interrupt, but it is very common for the thread to terminate.
		+	* Calling methods such as sleep() will throw an interrupted exception - the thread can ignore or terminate on catching the exception.
		+
		+
		+	<syntaxhighlight lang="java5">
		+
		+	package tred;
		+
		+	class Job implements Runnable {
		+
		+	public void run() {
		+	for(int i=0; i < 100; i++) {
		+	try {
		+	Thread.sleep(1000);
		+	} catch(InterruptedException e) {
		+	System.out.println("Interrupted");
		+	System.out.println("Flag : " + Thread.currentThread().isInterrupted());
		+	return;
		+	}
		+	System.out.print(i + " ");
		+	}
		+	}
		+
		+	}
		+
		+	public class Inter {
		+
		+	public static void main(String[] args) {
		+
		+	Thread t1 = new Thread(new Job());
		+	t1.start();
		+
		+	try {
		+	Thread.sleep(5000);
		+	} catch (Exception e) {
		+	e.printStackTrace();
		+	}
		+
		+	System.out.println("Interrupting T1 : ");
		+	t1.interrupt();
		+
		+	}
		+	}
		+
		+
		+	</syntaxhighlight>
		+
		+	* Interrupt status is maintained as an internal flag in the thread class.
		+	* Thread can check if its interrupted by calling the static Thread.interrupted(). Calling this method clears the interrupt status. Threads invoking methods which dont throw interrupteexception should check this flag periodically. Based on this, it can choose to terminate or continue (In below example, the thread terminates.)
		+	* To check another thread's status the non static t.isInterrupted() method can be used - this does not reset the interrrupt flag.
		+
		+	<syntaxhighlight lang="java5">
		+
		+	class Job implements Runnable {
		+
		+	PrintWriter pw;
		+
		+	Job() {
		+	try {
		+	pw = new PrintWriter("/tmp/U571");
		+	} catch (FileNotFoundException e) {
		+	e.printStackTrace();
		+	}
		+	}
		+
		+	public void run() {
		+	for(int i=0; i < 10000000; i++ ) {
		+	boolean b = Thread.interrupted();
		+	if(b) {
		+	System.out.println("Interrupted ! ");
		+	return;
		+	}
		+	pw.println("Mayday");
		+	}
		+
		+	pw.close();
		+	}
		+
		+	}
		+
		+	public class Inter {
		+
		+	public static void main(String[] args) {
		+
		+	Thread t1 = new Thread(new Job());
		+	t1.start();
		+
		+	try {
		+	Thread.sleep(100);
		+	} catch (Exception e) {
		+	e.printStackTrace();
		+	}
		+
		+	System.out.println("Interrupting T1 : ");
		+	t1.interrupt();
		+	System.out.println("T1 Interrupted Status " + t1.isInterrupted());
		+
		+	}
		+	}
		+
		+
		+	</syntaxhighlight>
		+

	== Thread Exceptions ==		== Thread Exceptions ==

← Older revision		Revision as of 05:00, 12 September 2011
Line 402:		Line 402:
	* notify() means the thread says - I am done running the job after acquiring the object's lock, I will now release the lock, so that threads wait()'ing for this object can run.		* notify() means the thread says - I am done running the job after acquiring the object's lock, I will now release the lock, so that threads wait()'ing for this object can run.

		+	* '''NOTE:''' wait() will cause the thread to give up it's lock immediately, but not notify() - notify wakes up waiting thread(s), but the lock is released only when the current thread gives it up - e.g. reaching the end of the synchronized block/method.

	* Here are couple of Producer-Consumer examples. The producer thread writes some messages, the consumer thread will pick up the message and print it out.		* Here are couple of Producer-Consumer examples. The producer thread writes some messages, the consumer thread will pick up the message and print it out.

@@ Line 81: / Line 81: @@
 * t.join() will take the current thread from which this code is called and join it to the end of t.
 * This means the thread from which join() is called will wait until t finishes before it runs again.
 == Name and Id ==

@@ Line 1: / Line 1: @@
-== Intro ==
+== Intro, Thread States ==
 * Think of Thread as the "worker" and Runnable as the job.
@@ Line 71: / Line 71: @@
 ** Dead
-<u> '''SLEEP''' </u>
+== Sleep ==
 *''' Be careful of the Thread classes static methods such as sleep() and yield().''' They refer to the current executing thread! Do not be misled when they are invoked using a thread object.
 * e.g. t1.sleep() will not cause Thread t1 to sleep(), it causes the current executing thread to sleep().
@@ Line 78: / Line 78: @@
 * so sleep() gives the minimum duration that the thread will not run. You cannot use it as an accurate timer!
-<u> '''JOIN''' </u>
+== Join ==
 * t.join() will take the current thread from which this code is called and join it to the end of t.
 * This means the thread from which join() is called will wait until t finishes before it runs again.
-<u> '''Name and Id''' </u>
+== Name and Id ==
 * Every thread has a name and an id which is assigned by default.

@@ Line 82: / Line 82: @@
 * This means the thread from which join() is called will wait until t finishes before it runs again.
-<u> Name and Id </u>
+<u> '''Name and Id''' </u>
 * Every thread has a name and an id which is assigned by default.
@@ Line 88: / Line 88: @@
 * Names are also assigned by default they look like - "Thread-0", "Thread-1" etc. 0, 1  do not represent Thread IDs
 * Names can be explicitly assigned as an argument to the Thread constructor or using setName().
 == Thread Lifetime ==

@@ Line 764: / Line 764: @@
 == Thread Exceptions ==
+* sleep(), join() and wait() throw a checked InterruptedException.
+* Whenever a thread goes into a waiting state - then it can be interrupted and therefore must handle the InterruptedException.
+* wait() and notify() also throw an unchecked IllegalMonitorStateException when the thread invoking them does not own the object lock.
 [[Category:OCPJP]]