Home arrow Java arrow Page 8 - Multithreading in Java
JAVA

Multithreading in Java


Multithreading allows two parts of the same program to run concurrently. This article discusses how to pull off this performance-improving feat in Java. It is excerpted from chapter 10 of the book Java Demystified, written by Jim Keogh (McGraw-Hill/Osborne, 2004; ISBN: 0072254548).

Author Info:
By: McGraw-Hill/Osborne
Rating: 4 stars4 stars4 stars4 stars4 stars / 535
August 04, 2005
TABLE OF CONTENTS:
  1. · Multithreading in Java
  2. · Overhead
  3. · The Thread Classes and the Runnable Interface
  4. · Creating Your Own Thread
  5. · Creating a Thread by Using extends
  6. · Using isAlive() and join()
  7. · Setting Thread Priorities
  8. · Synchronizing Threads
  9. · Using the Synchronized Statement
  10. · Suspending and Resuming Threads

print this article
SEARCH DEVARTICLES

Multithreading in Java - Synchronizing Threads
(Page 8 of 10 )

A major concern when two or more threads share the same resource is that only one of them can access the resource at one time. Programmers address this concern by synchronizing threads, much the same way baseball players take turns being up to bat.

Threads are synchronized in Java through the use of a monitor. Think of a monitor as an object that enables a thread to access a resource. Only one thread can use a monitor at any one time period. Programmers say that the thread owns the monitor for that period of time. The monitor is also called a semaphore.

A thread can own a monitor only if no other thread owns the monitor. If the monitor is available, a thread can own the monitor and have exclusive access to the resource associated with the monitor. If the monitor is not available, the thread is suspended until the monitor becomes available. Programmers say that the thread is waiting for the monitor.

Fortunately, the task of acquiring a monitor for a resource happens behind the scenes in Java. Java handles all the details for you. You do have to synchronize the threads you create in your program if more than one thread will use the same resource.

You have two ways in which you can synchronize threads: You can use the synchronized method or the synchronized statement.

The Synchronized Method

All objects in Java have a monitor. A thread enters a monitor whenever a method modified by the keyword synchronized is called. The thread that is first to call the synchronized method is said to be inside the method and therefore owns the method and resources used by the method. Another thread that calls the synchronized method is suspended until the first thread relinquishes the synchronized method.

If a synchronized method is an instance method, the synchronized method activates the lock associated with the instance that called the synchronized method, which is the object known as this during the execution of the body of the method. If the synchronized method is static, it activates the lock associated with the class object that defines the synchronized method.

Before you learn how to define a synchronized method in your program, letís see what might happen if synchronization is not used in a program. This is the objective of the following example. This program displays two names within parentheses using two threads. This is a three-step process, where the opening parenthesis, the name, and the closing parenthesis are displayed in separate steps.

The example defines three classes: the Parentheses class, the MyThread class, and the Demo class, which is the program class. The Parentheses class defines one method called display(), which receives a string in its argument list and displays the string in parentheses on the screen. The MyThread class defines a thread. In doing so, the constructor of MyThread requires two arguments. The first argument is a reference to an instance of the Parentheses class. The second argument is a string containing the name that will be displayed on the screen. The run() method uses the instance of the Parentheses class to call its display() method, passing the display() method the name that is to appear on the screen.

The rest of the action happens in the main() method of the Demo class. The first statement declares an instance of the Parentheses class. The next two classes create two threads. Notice that both threads use the same instance of the Parentheses class.

Hereís what is displayed when you run this program. Itís probably not what you expected to see. Each name should be enclosed within its own parentheses. The problem is that the display() method isnít synchronized.


NOTE:   If a variable is assigned by one thread and is used or assigned by other threads, all access to the variable should be enclosed in a synchronized method or a synchronized statement.

  (Bob(Mary)
)
class Parentheses {
   void display(String s) {
   System.out.print ("(" + s);
   try {
     
Thread.sleep (1000);
   } catch (InterruptedException e) {
       
System.out.println ("Interrupted");
   }
   System.out.println(")");
 
}
}
class MyThread implements Runnable {
  
String s1;
   Parentheses p1;
   Thread t;
   public MyThread (Parentheses p2, String s2) {
     
p1= p2;
      s1= s2;
      t = new Thread(this);
      t.start();
  
}
   public void run() {
     p1.display(s1);
  
}
}
class Demo{
  
public static void main (String args[]) {
     Parentheses p3 = new Parentheses();
     MyThread name1 = new MyThread(p3, "Bob");
     MyThread name2 = new MyThread(p3, "Mary");
     try {
       
name1.t.join();
        name2.t.join();
     } catch (InterruptedException e ) {
          System.out.println( "Interrupted");
     }
  }
}

The problem with the previous example is that two threads use the same resource concurrently. The resource is the display() method defined in the Parentheses class. In order to have one thread take control of the display() method, we must synchronize the display() method. This is done by using the keyword synchronized in the header of the display() method, which is illustrated in the next example.

Hereís what is displayed when you run the next example. This is what you expected to see in the previous example.

(Bob)
(Mary)
class Parentheses {
   synchronized void display(String s) {
   System.out.print ("(" + s);
   try {
     
Thread.sleep (1000);
   } catch (InterruptedException e) {
       
System.out.println ("Interrupted");
   }
   System.out.println(")");
 
}
}
class MyThread implements Runnable {
  
String s1;
   Parentheses p1;
   Thread t;
   public MyThread (Parentheses p2, String s2) {
     
p1= p2;
      s1= s2;
      t = new Thread(this);
      t.start();
  
}
   public void run() {
     p1.display(s1);
  
}
}
class Demo{
  
public static void main (String args[]) {
     Parentheses p3 = new Parentheses();
     MyThread name1 = new MyThread(p3, "Bob");
     MyThread name2 = new MyThread(p3, "Mary");
     try {
        
name1.t.join();
        name2.t.join();
   } catch (InterruptedException e ) {
        System.out.println( "Interrupted");
   }
  }
}


blog comments powered by Disqus
JAVA ARTICLES

- Java Too Insecure, Says Microsoft Researcher
- Google Beats Oracle in Java Ruling
- Deploying Multiple Java Applets as One
- Deploying Java Applets
- Understanding Deployment Frameworks
- Database Programming in Java Using JDBC
- Extension Interfaces and SAX
- Entities, Handlers and SAX
- Advanced SAX
- Conversions and Java Print Streams
- Formatters and Java Print Streams
- Java Print Streams
- Wildcards, Arrays, and Generics in Java
- Wildcards and Generic Methods in Java
- Finishing the Project: Java Web Development ...

Watch our Tech Videos 
Dev Articles Forums 
 RSS  Articles
 RSS  Forums
 RSS  All Feeds
Write For Us 
Weekly Newsletter
 
Developer Updates  
Free Website Content 
Contact Us 
Site Map 
Privacy Policy 
Support 

Developer Shed Affiliates

 




© 2003-2017 by Developer Shed. All rights reserved. DS Cluster - Follow our Sitemap
Popular Web Development Topics
All Web Development Tutorials