• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Java Multithreading
 

Java Multithreading

on

  • 2,196 views

 

Statistics

Views

Total Views
2,196
Views on SlideShare
2,196
Embed Views
0

Actions

Likes
0
Downloads
88
Comments
0

0 Embeds 0

No embeds

Accessibility

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Java Multithreading Java Multithreading Document Transcript

    • Overview Let’s get the basics of multi- threaded programming in Java, and then write some simple programs. An Introduction to Multi-threading 12 MARCH 2008 | LINUX FoR YoU | www.openITis.com cmyk
    • Overview I n a typical application like a word created in main). processor, many tasks need to be executed in parallel—for instance, responding to Asynchronous execution the user, checking spellings, formatting, Note that created threads run ‘asynchronously’. This displaying, saving, etc. These tasks can means that threads do not run sequentially (like function run as different processes, sharing the resources calls); rather, the order of execution of threads is not using inter-process communication. Multi-processing predictable. To understand this, let us extend our simple is heavyweight and costly in terms of the system calls program here: made, and requires a process switch. An easier and cheaper alternative is to use threads. class MyThread extends Thread { Multiple threads can run in the context of the same public void loop() { process and hence share the same resources. A context for(int i = 0; i < 3; i++) { switch is enough to switch between threads, whereas a System.out.println(“In thread “ + costly process switch is needed for processes. Thread.currentThread().getName() + Java has support for concurrent programming and “; iteration “ + i); has support for multi-threading in both language and try { library levels. In this article, we’ll cover the basics of Thread.sleep((int)Math.random()); multi-threaded programming in Java and write some } simple programs. We’ll also look at some difficult catch(InterruptedException ie) { problems that can crop up when we write multi- ie.printStackTrace(); threaded code. } } The basics } A Java thread can be created in two ways: by implementing the Runnable interface or by extending public void run() { the Thread class. Both have a method called run. This System.out.println(“This is new thread”); method will be called by the runtime when a thread this.loop(); starts executing. } A thread can be created by invoking the start method on a Thread or its derived objects. This in turn calls the public static void main(String args[]) throws Exception { run method and keeps the thread in running state. Now MyThread mt = new MyThread(); let us look at a simple example using threads. mt.start(); System.out.println(“This is the main Thread”); class MyThread extends Thread { mt.loop(); public void run() { } System.out.println(“This is new thread”); } } In a sample run, the output was: public static void main(String args[]) throws Exception { MyThread mt = new MyThread(); This is the main Thread mt.start(); In thread main; iteration 0 System.out.println(“This is the main Thread”); This is new thread } In thread Thread-0; iteration 0 } In thread Thread-0; iteration 1 In thread main; iteration 1 This program prints: In thread Thread-0; iteration 2 In thread main; iteration 2 This is the main Thread This is new thread In this program, we have a loop method that has a for loop that has three iterations. In the for loop, we print In this example, the MyThread class extends the the name of the thread and the iteration number. We can Thread class. We need to override the run method set and get the name of the thread using setName and in this class. This run method will be called when the getName methods, respectively. If we haven’t set the thread runs. In the main function, we create a new name of the thread explicitly, the JVM gives a default thread and start it. The program prints messages name (‘main’, ‘Thread-0’, ‘Thread-1’, etc.). After printing from both the main thread and the mt thread (that we this information, we force the current thread to sleep for www.openITis.com | LINUX FoR YoU | MARCH 2008 13 cmyk
    • Overview 10 milli-seconds. of the value Counter.count and when they update The main thread (‘main’) and the child thread the counter with Counter.count++, they need not (‘hread-0’) are executed independently. The output immediately reflect that value in the main memory. In is not fixed and the order of executing the iterations the next read operation of Counter.count, the local in the threads is not predictable. This is one of the value of Counter.count is printed. fundamental and important concepts to understand in Technically, this program has a ‘data race’. To avoid multi-threading. this problem, we need to ensure that the write and read operations are done together (‘atomically’) by a Data races single thread. How do we ensure that? It is by acquiring Threads share memory and they can concurrently a lock on the object. Only a single thread can acquire modify data. This can lead to unintuitive results and end a lock on an object at a time, and only that thread in ‘data races’. Here is an example of a data race: can execute the code protected by the lock (that code segment is known as a ‘critical section’). Until class Counter { then the other threads have to wait. Internally, this is public static long count = 0; implemented with monitors and the process is called as } locking and unlocking. class UseCounter implements Runnable { Thread synchronisation public void run() { Java has a keyword synchronised to acquire a lock. Lock for (int i = 0; i < 3; i++) { is not obtained on code, but on a resource. Any object Counter.count++; (not primitive types but of reference type) can be used System.out.print(Counter.count + “ “); to acquire a lock. } Here is an improved version of the code that provides } synchronised access to Counter.count, and does both } read and write operations on that in a critical section. For that, only the run method needs to be changed as public class DataRace { follows: public static void main(String args[]) { UseCounter c = new UseCounter(); public void run() { Thread t1 = new Thread(c); for (int i = 0; i < 3; i++) { Thread t2 = new Thread(c); synchronized(this) { Thread t3 = new Thread(c); Counter.count++; t1.start(); System.out.print(Counter.count + “ “); t2.start(); } t3.start(); } } } } The program now prints the expected output In this program, we have a Counter class, which has correctly: a static variable count. The UseCounter class simply increments the count and prints the count three times in 1 2 3 4 5 6 7 8 9 a for loop. We create three threads in the main function in the DataRace class and start it. We expect the In the run method, we acquire lock on the implicit program to print 1 to 9 sequentially as the threads run this pointer before doing both reading and writing to and increment the counters. However, when we run this Counter.count. program, it does print 9 integer values, but the output In this case, run is a non-static method. What about looks like garbage! In a sample run, I got these values: static methods, as they do not have this pointer? You can obtain a lock for a static method, and the lock is 3 3 5 6 3 7 8 4 9 obtained for the class instance and not the object. In fact, in this example, Counter.count is a static member, so we Note that the values will usually be different every might as well have acquired a lock on Counter.class for time you run this program. What is the problem? modifying and reading Counter.count. The expression Counter.count++ is a write operation and the next System.out.print statement Deadlocks has a read operation for Counter.count. When the Obtaining and using locks is tricky and can lead to lots three threads execute, each of them has a local copy of problems, one of which (a common one) is known as 14 MARCH 2008 | LINUX FoR YoU | www.openITis.com cmyk
    • Overview a ‘deadlock’ (there are other problems like ‘livelocks’ Thread t2 = new Thread(c); and ‘lock starvation’ that are not discussed here). t1.start(); A deadlock happens when locking in threads t2.start(); results in a situation where they cannot proceed and } wait indefinitely for others to terminate -- for instance, } when one thread acquires a lock on resource, r1, and waits to acquire another resource, r2. At the same If you execute this program, it might run fine, or it time, there might be another thread that has already may deadlock and never terminate. acquired r2 and is waiting to obtain a lock on r1. Now, In this example, there are two classes, as you will notice, both the threads cannot proceed till Balls and Runs, with static member balls the other releases the lock, which never happens, so and runs. The Counter class has two they ‘deadlock’. methods IncrementBallAfterRun and Here is an example that programmatically shows IncrementRunAfterBall. They acquire locks on Balls. how this can happen. class and Runs.class in the opposite order. The run method calls these two methods consecutively. The class Balls { main method in the Dead class creates two threads public static long balls = 0; and starts them. } When the threads t1 and t2 execute, they will invoke the methods IncrementBallAfterRun and class Runs { IncrementRunAfterBall. In these methods, locks are public static long runs = 0; obtained in the opposite order. It might happen that t1 } acquires a lock on Runs.class and waits to acquire a lock on Balls.class. Meanwhile, t2 might have acquired class Counter implements Runnable { Balls.class and waits to acquire a lock on Runs.class. public void IncrementBallAfterRun() { So, this program can lead to a deadlock. It is not synchronized(Runs.class) { assured that this program will lead to a deadlock every synchronized(Balls.class) { time you execute this program. Why? We never know Runs.runs++; the sequence in which threads execute, and the order Balls.balls++; in which locks are acquired and released. For this } reason, the problems are said to be ‘non-deterministic’ } and such problems cannot be reproduced consistently. } We will not look at how to resolve this deadlock problem in this article. The objective is to introduce public void IncrementRunAfterBall() { you to problems like these that can occur in multi- synchronized(Balls.class) { threaded programs. synchronized(Runs.class) { In this article, we explored the basics of writing Balls.balls++; multi-threaded programming in Java. We can create Runs.runs++; classes that are capable of multi-threading by } implementing a Runnable interface or by extending } a Thread class. Concurrent reads and writes to } resources can lead to ‘data races’. Java provides thread synchronisation features for protected access public void run() { to shared resources. We need to use locks carefully. IncrementBallAfterRun(); Incorrect usage of lock can lead to problems like IncrementRunAfterBall(); deadlocks, livelocks or lock starvation, which are very } difficult to detect and fix. } By: S G Ganesh is a research engineer in Siemens public class Dead { (Corporate Technology), Bangalore. His latest book is ‘60 public static void main(String args[]) { Tips on Object Oriented Programming’ published by Tata Counter c = new Counter(); McGraw-Hill in December 2007. You can reach him at Thread t1 = new Thread(c); sgganesh@gmail.com www.openITis.com | LINUX FoR YoU | MARCH 2008 15 cmyk