java threads
DESCRIPTION
Java Threads. Instructor: Mainak Chaudhuri [email protected]. Java threads. Two ways to create a thread Extend the Thread class and override the public run method Implement a runnable interface with a public run method class MyThread extends Thread { private int tid; - PowerPoint PPT PresentationTRANSCRIPT
![Page 2: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/2.jpg)
2
Java threads• Two ways to create a thread
– Extend the Thread class and override the public run method
– Implement a runnable interface with a public run method
class MyThread extends Thread { private int tid; private String name; private long startTime; public MyThread (String name, int tid) { super (name); this.tid = tid; this.name = new String(name); startTime = System.currentTimeMillis(); } // next slide
![Page 3: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/3.jpg)
3
Java threads public void run () { // override System.out.println (“<” + age() + “> Hi!
This is ” + getName() + “.”); } public long age () { return (System.currentTimeMillis () –
startTime); }} // end class
class MyFirstThreadDemo { public static void main (String arg[]) { Integer n = new Integer (arg[0].trim()); int numThreads = n.intValue(); // next
slide
![Page 4: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/4.jpg)
4
Java threads int i; MyThread t[] = new
MyThread[numThreads]; for (i=0; i<numThreads; i++) { t[i] = new MyThread (“Thread ”+i,
i); t[i].start(); } } // end main} // end class
![Page 5: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/5.jpg)
5
Java threads via interfaceclass MyThread implements Runnable {
private int tid; private String name; private long startTime; public MyThread (String name, int tid) { this.tid = tid; this.name = new String(name); startTime = System.currentTimeMillis(); } public void run () { System.out.println (“<” + age() + “> Hi!
This is ” + Thread.currentThread().getName() + “.”);
} //next slide
![Page 6: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/6.jpg)
6
Java threads via interface
public long age () { return (System.currentTimeMillis () –
startTime); }} // end class
class MyFirstThreadDemo { public static void main (String arg[]) { Integer n = new Integer
(arg[0].trim()); int numThreads = n.intValue(); int i; // next slide
![Page 7: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/7.jpg)
7
Java threads via interface
MyThread mt[] = new MyThread[numThreads];
Thread t[] = new Thread[numThreads]; for (i=0; i<numThreads; i++) { mt[i] = new MyThread (“Thread ”+i,
i); t[i] = new Thread (mt[i], “Thread
”+i); t[i].start(); } } // end main} // end class
![Page 8: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/8.jpg)
8
Announcements• Final exam on 19th November 1215 to
1515• Seating arrangement:Y4, Y5, Y7001 to Y7085 L1 OROSY7092 to Y7233 L2 ERESY7234 to Y7388 L16 OROSY7391 to Y7518 L17 ERES• Please take seats 15 minutes before
the scheduled time
![Page 9: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/9.jpg)
9
Java thread states• Java threads have typically seven states
– New: just after a thread is created– Runnable: after the start() method is
invoked. The thread is placed in the runnable set or the ready queue. When scheduled, the run() method will be executed.
– Running: executing the code in the run() method. May call its yield() method to put itself back in the runnable set.
– Suspended: after the suspend() method is called. May be called by itself or by some other thread. It is placed back on runnable set only if some other thread calls its resume() method.
![Page 10: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/10.jpg)
10
Java thread states• Seven states (continued)
– Blocked: after the sleep() method or the wait() method or the join() method is called to join with a thread (at a barrier) that is yet to arrive at the join point or when it does blocking I/O (e.g., reading from keyboard). The thread transitions back to runnable state when the blocking call is over.
– Suspended-blocked: If a blocked thread is suspended by some other thread. It returns back to suspended or blocked state depending on whether the blocking finishes before a call to resume() or not.
– Dead: On completion of the run() method or a call to stop() method.
![Page 11: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/11.jpg)
11
Java thread scheduling• Every Java thread gets a priority
– Inherits the same priority from the creating thread. In our example, all threads have same priority as the “main thread”.
– Priorities range from MIN_PRIORITY to MAX_PRIORITY defined in Thread class. The default priority is NORM_PRIORITY.
– Use setPriority and getPriority methods to change and query a thread’s priority.
– Among all the threads in the runnable set, the highest priority thread is allowed to run until it blocks, yields, gets suspended, or a new thread of higher priority enters the runnable set. In the last case the running thread goes back to runnable set
![Page 12: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/12.jpg)
12
Java thread scheduling• Some implementations carry out a
round-robin scheduling (e.g., JDK 1.1 for Windows 95/NT)– Every thread gets a time slice to execute– Once the time slice of the thread expires,
it is put back in the runnable set and the next thread is given a chance (higher priority threads are considered first)
– If a thread blocks, yields, or gets suspended before the time slice expires, the next thread is scheduled for execution
![Page 13: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/13.jpg)
13
More exampleclass MyThread extends Thread { private int tid; private String name; private long startTime; private long screamingInterval; public MyThread (String name, int tid, long
screamingInterval) { super (name); this.tid = tid; this.name = new String(name); startTime = System.currentTimeMillis(); this.screamingInterval =
screamingInterval; } // next slide
![Page 14: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/14.jpg)
14
More example public void run () { // override long count = 0; while (true) { if (count % screamingInterval == 0) { System.out.println (“<” + age() + “> Hi! This
is ” + getName() + “.”); } count++; } } public long age () { return (System.currentTimeMillis () – startTime); }} // end class
![Page 15: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/15.jpg)
15
More exampleclass MyThreadDemo { public static void main (String arg[]) { Integer n = new Integer (arg[0].trim()); int numThreads = n.intValue(); int i; MyThread t[] = new
MyThread[numThreads]; for (i=0; i<numThreads; i++) { t[i] = new MyThread (“Thread ”+i, i,
(i+1)*1000000); //t[i].setPriority (t[i].getPriority()+i); t[i].start(); } } // end main} // end class
![Page 16: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/16.jpg)
16
Typical output snapshot<8408> Hi! This is Thread 0.<9014> Hi! This is Thread 0.<9374> Hi! This is Thread 1.<9615> Hi! This is Thread 0.<10214> Hi! This is Thread 0.<10545> Hi! This is Thread 1.<10813> Hi! This is Thread 0.<11416> Hi! This is Thread 0.<11720> Hi! This is Thread 1.<12014> Hi! This is Thread 0.<12613> Hi! This is Thread 0.<12889> Hi! This is Thread 1.<13213> Hi! This is Thread 0.
![Page 17: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/17.jpg)
17
Physical resources• Parallelism ultimately depends on
availability of multiple physical CPUs– You get true concurrency with
“multiprocessors”– With single CPU, you get time-shared
concurrency (at any point in time only one thread can run)
– Today small-scale multiprocessors are commodity
– Chip-multiprocessors or so called multi-core processors come with two, four, or eight processors on a single chip (soon 16 processors)
![Page 18: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/18.jpg)
18
Data race• How to share a variable?
– Create a single class containing the variables that you want to share
– Create one instance of this object and attach multiple threads to it
– Let us see what happens if we try to update a shared variable concurrently in multiple threads
– This is known as a data race as multiple threads may have a race trying to update the same data
![Page 19: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/19.jpg)
19
Data raceclass MyThread implements Runnable { private long sum; public MyThread () { sum=0; } public void run () { int i; for (i=0; i<100000; i++) { sum++; } System.out.println("<" +
Thread.currentThread().getName() + ">: Sum=" + sum);
} // next slide
![Page 20: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/20.jpg)
20
Data race public long GetSum () { return sum; }} // end class
class MyDataRaceDemo { public static void main (String arg[])
throws java.lang.InterruptedException { Integer n = new Integer
(arg[0].trim()); int numThreads = n.intValue(); int i; // next slide
![Page 21: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/21.jpg)
21
Data race MyThread mt = new MyThread(); Thread t[] = new Thread[numThreads]; for (i=0; i<numThreads; i++) { t[i] = new Thread (mt, "Thread "+i); t[i].start(); } for (i=0; i<numThreads; i++) { t[i].join(); } System.out.println("From main: Sum=" +
mt.GetSum()); } // end main} // end class
![Page 22: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/22.jpg)
22
Data race• If you run this program multiple times,
you will get different outputs in different runs– A typical symptom of data race– The output depends on how the threads
get interleaved when they run– A typical output:<Thread 0>: Sum=107927<Thread 1>: Sum=128853From main: Sum=128853
![Page 23: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/23.jpg)
23
More data race example• Let us try to write the program for summing an
arrayclass MyThread implements Runnable { private int array[]; private long sum; private int numThreads; private int tid; public MyThread (long size, int numThreads) { int i; array = new int[size]; for (i=0; i<size; i++) { array[i] = i; } sum = 0; tid = 0; this.numThreads = numThreads; } // next slide
![Page 24: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/24.jpg)
24
More data race example public void run () { int i; int myid = tid++; // data race on tid for (i=myid*(array.length/numThreads);
i<(myid+1)*(array.length/numThreads); i++) {
sum += array[i]; // data race on sum } } public long GetSum() { return sum; }} // end class
![Page 25: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/25.jpg)
25
More data race exampleclass MyArraySumDemo { public static void main (String arg[]) throws
java.lang.InterruptedException { Integer n = new Integer (arg[0].trim()); long size = n.intValue(); n = new Integer (arg[1].trim()); int numThreads = n.intValue(); int i; MyThread mt = new MyThread(size,
numThreads); Thread t[] = new Thread[numThreads]; // next slide
![Page 26: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/26.jpg)
26
More data race example for (i=0; i<numThreads; i++) { t[i] = new Thread (mt, "Thread "+i); t[i].start(); } for (i=0; i<numThreads; i++) { t[i].join(); } System.out.println("From main: Sum=" +
mt.GetSum() + “[Expected=” + (size*(size-1))/2 + “]”);
} // end main} // end class
![Page 27: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/27.jpg)
27
More data race example• One typical output for size=100000
and numThreads=2From main:
Sum=3692782245[Expected=4999950000]
• Replacing sum by local sum and accumulating at the end reduces the chance of data race– Reduces the number of executed critical
sections: more parallelism– But the program is still buggy and may
produce wrong results once in a while
![Page 28: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/28.jpg)
28
More data race exampleclass MyThread implements Runnable { private int array[]; private long sum; private int numThreads; private int tid; public MyThread (long size, int numThreads)
{ int i; array = new int[size]; for (i=0; i<size; i++) { array[i] = i; } sum = 0; this.numThreads = numThreads; } // next slide
![Page 29: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/29.jpg)
29
More data race example public void run () { int i; long localSum = 0; // private variable int myid = tid++; // data race on tid for (i=myid*(array.length/numThreads);
i<(myid+1)*(array.length/numThreads); i++) {
localSum += array[i]; // no data race } sum += localSum; // data race on sum } public long GetSum() { return sum; }} // end class
![Page 30: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/30.jpg)
30
More data race exampleclass MyArraySumDemo { public static void main (String arg[]) throws
java.lang.InterruptedException { Integer n = new Integer (arg[0].trim()); long size = n.intValue(); n = new Integer (arg[1].trim()); int numThreads = n.intValue(); int i; MyThread mt = new MyThread(size,
numThreads); Thread t[] = new Thread[numThreads]; // next slide
![Page 31: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/31.jpg)
31
More data race example for (i=0; i<numThreads; i++) { t[i] = new Thread (mt, "Thread "+i); t[i].start(); } for (i=0; i<numThreads; i++) { t[i].join(); } System.out.println("From main: Sum=" +
mt.GetSum() + “[Expected=” + (size*(size-1))/2 + “]”);
} // end main} // end class
![Page 32: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/32.jpg)
32
Fixing data races• Every Java object has an in-built lock
– We will make use of this to protect the critical sections
– For every shared variable that is involved in a data race, we need to create a lock
– It is possible to have a single lock to resolve multiple races, but that will limit concurrency (why?)
– General solution: create a dummy object and use its lock to resolve a race
– Java allows the programmer to mark critical sections with the keyword synchronized
![Page 33: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/33.jpg)
33
Fixing array sumclass MyThread implements Runnable { private int array[]; private long sum; private int numThreads; private int tid; private Object tidLock; // dummy object private Object sumLock; // dummy object public MyThread (long size, int numThreads,
Object tidLock, Object sumLock) { int i; array = new int[size]; for (i=0; i<size; i++) { array[i] = i; } // next slide
![Page 34: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/34.jpg)
34
Fixing array sum sum = 0; this.numThreads = numThreads; this.tidLock = tidLock; this.sumLock = sumLock; } public void run () { int i; int myid; synchronized (tidLock) { myid = tid++; } // next slide
![Page 35: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/35.jpg)
35
Fixing array sum for (i=myid*(array.length/numThreads);
i<(myid+1)*(array.length/numThreads); i++) {
synchronized (sumLock) { sum += array[i]; } } }
public long GetSum() { return sum; }} // end class
![Page 36: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/36.jpg)
36
Fixing array sumclass MyArraySumDemo { public static void main (String arg[]) throws
java.lang.InterruptedException { Integer n = new Integer (arg[0].trim()); long size = n.intValue(); n = new Integer (arg[1].trim()); int numThreads = n.intValue(); int i; Object tidLock = new Object(); Object sumLock = new Object(); MyThread mt = new MyThread(size,
numThreads, tidLock, sumLock); Thread t[] = new Thread[numThreads]; // next slide
![Page 37: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/37.jpg)
37
Fixing array sum for (i=0; i<numThreads; i++) { t[i] = new Thread (mt, "Thread "+i); t[i].start(); } for (i=0; i<numThreads; i++) { t[i].join(); } System.out.println("From main: Sum=" +
mt.GetSum() + "[Expected=" + (size*(size-1))/2 + "]");
} // end main} // end class
![Page 38: Java Threads](https://reader035.vdocuments.net/reader035/viewer/2022062802/568145ee550346895db2f1cd/html5/thumbnails/38.jpg)
38
Announcements• No class tomorrow• All the best for the final exam. Bye!