Unit 5 Concurrent Programming
Unit 5 Concurrent Programming
CONCURRENT PROGRAMMING
Threads
• Threads are lightweight processes as the
overhead of switching between threads is less
• The can be easily spawned
• The Java Virtual Machine spawns a thread
when your program is run called the Main
Thread
Why do we need threads?
• To enhance parallel processing
• To increase response to the user
• To utilize the idle time of the CPU
• Prioritize your work depending on priority
Example
• Consider a simple web server
• The web server listens for request and serves it
• If the web server was not multithreaded, the
requests processing would be in a queue, thus
increasing the response time and also might hang
the server if there was a bad request.
• By implementing in a multithreaded
environment, the web server can serve multiple
request simultaneously thus improving response
time
Creating threads
• In java threads can be created by extending
the Thread class or implementing the
Runnable Interface
• It is more preferred to implement the
Runnable Interface so that we can extend
properties from other classes
• Implement the run() method which is the
starting point for thread execution
Running threads
• Example
class mythread implements Runnable{
public void run(){
System.out.println(“Thread Started”);
}
}
class mainclass {
public static void main(String args[]){
Thread t = new Thread(new mythread()); // This is the way to
instantiate a thread implementing
runnable interface
t.start(); // starts the thread by running the run method
}
}
• Calling t.run() does not start a thread, it is just a simple
method call.
• Creating an object does not create a thread, calling
start() method creates the thread.
Thread states
new
wait()
start() sleep()
suspend()
blocked
runnable non-runnable
notify()
stop() slept
resume()
unblocked
dead
Threading Mechanisms...
• Create a class that extends the Thread class
• Create a class that implements the Runnable interface
1st method: Extending Thread class
class MyThread extends Thread
{
public void run()
{
// thread body of execution
}
}
• Creating thread:
MyThread thr1 = new MyThread();
• Start Execution:
thr1.start();
An example
class MyThread extends Thread { // the thread
public void run() {
System.out.println(" this thread is running ... ");
}
} // end class MyThread
class ThreadEx21 {
public static void main(String [] args ) {
Thread t = new Thread(new MyThread());
// due to implementing the Runnable interface
// I can call start(), and this will call run().
t.start();
} // end main()
} // end class ThreadEx2
A program with two threads
class MyThread implements Runnable {
public void run() { System.out.println("This is
'MyThread' ); }
}
class ThreadEx4 {
public static void main(String [] args ) {
Thread t1 = new Thread(new MyThread());
Thread t2 = new Thread(new YourThread());
t1.start();
t2.start();
}
} // end class ThreadEx4
Monitor model (for Syncronization)
Method 1
Method 2
Key
Block 1
Threads
}
System.out.println(“Iam in this “);
notifyAll();
}
Object locking
• The synchronized keyword locks the object. The wait
keyword waits for the lock to be acquired, if the
object was already locked by another thread.
Notifyall() notifies other threads that the lock is
about to be released by the current thread.
• Another method notify() is available for use, which
wakes up only the next thread which is in queue for
the object, notifyall() wakes up all the threads and
transfers the lock to another thread having the
highest priority.
Synchronized Collections
•The classes in the Java Collections Framework
are not thread-safe, i.e., the contents may be
corrupted if they are accessed and updated
concurrently by multiple threads.
•You can protect the data in a collection by
locking the collection or using synchronized
collections.
•The Collections class provides six static methods
for wrapping a collection into a synchronized
version.
•The collections created using these methods are
called synchronization wrappers.
java.util.Collections
+synchronizedCollection(c: Collection): Collection Returns a synchronized collection.
+synchronizedList(list: List): List Returns a synchronized list from the specified list.
+synchronizedMap(m: Map): Map Returns a synchronized map from the specified map.
+synchronizedSet(s: Set): Set Returns a synchronized set from the specified set.
+synchronizedSortedMap(s: SortedMap): SortedMap Returns a synchronized sorted map from the specified
sorted map.
+synchronizedSortedSet(s: SortedSet): SortedSet Returns a synchronized sorted set.
Vector, Stack, and Hashtable
Invoking synchronizedCollection(Collection c)
returns a new Collection object, in which all the
methods that access and update the original
collection c are synchronized. These methods are
implemented using the synchronized keyword. For
example, the add method is implemented like this: