"Exploring the Essential Functions and Design Considerations of Spillways in ...
Multi-threaded Programming in JAVA
1. GUIDED BY:
Multithreaded Programming in JAVA
DEVELOPED BY: Prof. Miral Patel
Vikram Kalyani 120110116017
2. What is Multithreading?
A multi-processing Operating System can run several processes at the same time
Each process has its own address/memory space
The OS's scheduler decides when each process is executed
Only one process is actually executing at any given time. However,
the system appears to be running several programs simultaneously
Separate processes to not have access to each other's memory space
Many OSes have a shared memory system so that processes can
share memory space
In a multithreaded application, there are several points of execution within the
same memory space.
Each point of execution is called a thread
Threads share access to memory
3. Why to use Multithreading?
In a single threaded application, one thread of execution must do everything
If an application has several tasks to perform, those tasks will be
performed when the thread can get to them.
A single task which requires a lot of processing can make the entire
application appear to be "sluggish" or unresponsive.
In a multithreaded application, each task can be performed by a separate thread
If one thread is executing a long process, it does not make the entire
application wait for it to finish.
If a multithreaded application is being executed on a system that has multiple
processors, the OS may execute separate threads simultaneously on separate
processors.
4. What Kind of Applications Use Multithreading?
Any kind of application which has distinct tasks which can be performed independently
Any application with a GUI.
Threads dedicated to the GUI can delegate the processing of user
requests to other threads.
The GUI remains responsive to the user even when the user's requests
are being processed.
Any application which requires asynchronous response
Network based applications are ideally suited to multithreading.
Data can arrive from the network at any time.
In a single threaded system, data is queued until the thread can
read the data
In a multithreaded system, a thread can be dedicated to listening
for data on the network port
When data arrives, the thread reads it immediately and processes
it or delegates its processing to another thread
5. What are Threads?
A piece of code that run in concurrent with other threads.
Each thread is a statically ordered sequence of instructions.
Threads are being extensively used express concurrency on both single and
multiprocessors machines.
Programming a task having multiple threads of control – Multithreading or
Multithreaded Programming.
6. Thread States
Threads can be in one of four states
Created, Running, Blocked, and Dead
A thread's state changes based on:
Control methods such as start, sleep, yield, wait, notify
Termination of the run method
notify()
Created Runnable Blocked
Dead
Thread() start()
run() method terminates
sleep()
wait()
7. Java Threads
Java has built in thread support for Multithreading
Synchronization
Thread Scheduling
Inter-Thread Communication:
Java Garbage Collector is a low-priority thread
8. Threading Mechanisms
Create a class that extends the Thread class
Create a class that implements the Runnable interface
9. 1st Method
Extending Thread class
Threads are implemented as objects that contains a method called
run()
class MyThread extends Thread
{
public void run()
{
// thread body of execution
}
}
Create a thread:
MyThread thr1 = new MyThread();
Start Execution of threads:
thr1.start();
10. An example
class MyThread extends Thread { // the thread
public void run() {
System.out.println(" this thread is running ... ");
}
} // end class MyThread
class ThreadEx1 { // a program that utilizes the thread
public static void main(String [] args ) {
MyThread t = new MyThread();
// due to extending the Thread class (above)
// I can call start(), and this will call
// run(). start() is a method in class Thread.
t.start();
} // end main()
} // end class ThreadEx1
11. 2nd Method
Threads by implementing Runnable interface
class MyThread implements Runnable
{
.....
public void run()
{
// thread body of execution
}
}
Creating Object:
MyThread myObject = new MyThread();
Creating Thread Object:
Thread thr1 = new Thread( myObject );
Start Execution:
thr1.start();
12. An example
class MyThread implements Runnable {
public void run() {
System.out.println(" this thread is running ... ");
}
} // end class MyThread
class ThreadEx2 {
public static void main(String [] args ) {
Thread t = new Thread(new MyThread());
// due to implementing the Runnable interface
// We can call start(), and this will call run().
t.start();
} // end main()
} // end class ThreadEx2
13. Thread Priority
In Java, each thread is assigned priority, which affects the
order in which it is scheduled for running. The threads so far had
same default priority (ORM_PRIORITY) and they are served using
FCFS policy.
Java allows users to change priority:
ThreadName.setPriority(intNumber)
MIN_PRIORITY = 1
NORM_PRIORITY=5
MAX_PRIORITY=10
14. Thread priority Example
class A extends Thread
{
public void run()
{
System.out.println("Thread A
started");
for(int i=1;i<=4;i++)
{
System.out.println("t From
ThreadA: i= "+i);
}
System.out.println("Exit from A");
}
}
class B extends Thread
{
public void run()
{
System.out.println("Thread B
started");
for(int j=1;j<=4;j++)
{
System.out.println("t From
ThreadB: j= "+j);
}
System.out.println("Exit from B");
}
}
15. Thread priority Example(Cont.)
class C extends Thread
{
public void run()
{
System.out.println("Thread C started");
for(int k=1;k<=4;k++)
{
System.out.println("t From ThreadC: k= "+k);
}
System.out.println("Exit from C");
}
}
16. Thread priority Example(Cont.)
class ThreadPriority
{
public static void main(String args[])
{
A threadA=new A();
B threadB=new B();
C threadC=new C();
threadC.setPriority(Thread.MAX_PRIORITY);
threadB.setPriority(threadA.getPriority()+1);
threadA.setPriority(Thread.MIN_PRIORITY);
System.out.println("Started Thread A");
threadA.start();
System.out.println("Started Thread B");
threadB.start();
System.out.println("Started Thread C");
threadC.start();
System.out.println("End of main thread");
}
}
17. Deadlock: What is it ?
A special type of error which occurs when two threads have
a circular dependency on a pair of synchronized objects.
For example, Traffic Jam.
Device allocation
Thread 1 requests tape drive 1 & gets it.
Thread 2 requests tape drive 2 & gets it.
Thread 1 requests tape drive 2 but is blocked.
Thread 2 requests tape drive 1 but is blocked.
18. Deadlock as error:
Deadlock is a difficult error to debug for two reasons..
In general, it occurs only rarely, when the two threads
time-slice in just the right way.
It may involve more than two threads and two
synchronized objects.
19. Suspending, Resuming, and Stopping Threads
Sometimes, suspending execution of a thread is useful as a
solution of deadlock.
The methods are….
void suspend( )
void resume( )
Void stop()
20. Java Synchonization
Java provides Synchronized keyword to methods that cause only one invocation of a synchronized
method on the same object at a time.
Example
public class SynchronizedCounter {
private int c = 0;
public synchronized void increment() {
c++;
}
public synchronized void decrement() {
c--;
}
public synchronized int value() {
return c;
}
}
21. 21
Synchronized Statements
Unlike synchronized methods, synchronized
statements must specify the object that provides the
intrinsic lock:
Uses construct ion:
synchronized ( expression ) {
statements
}
Evaluate to an
object or an
array. Used to
identify lock.
“critical section”
22. 22
Synchronized Statements
Example:
public void addName(String name) {
synchronized(this) {
lastName = name;
nameCount++;
}
nameList.add(name);
}
Only this part
synchronized
23. Atomic action
An atomic action cannot stop in the middle: it either happens completely, or it
doesn't happen at all. No side effects of an atomic action are visible until the
action is complete.
Read/writes can be declared atomic with the volatile keyword, e.g.
private volatile int x;
Sometimes can be more efficient than synchronized methods
24. Coordinating threads
Wait/notify mechanism
Sometimes need a thread to stop running and wait for an event before continuing.
wait() and notify() methods are methods of class Object.
Every object can maintain a list of waiting threads.
wait(): When a thread calls wait() method of an object, any locks the thread
holds are temporarily released and thread added to list of waiting threads for that
object and stops running.
notify(): When another thread calls notify() method on the same object, object
wakes up one of the waiting threads and allows it to continue.
25. Join
Sometimes one thread needs to stop and wait for another thread to
complete.
join() -- waits for a thread to die, i.e. thr1.join() waits for thread thr1 to die.
Calling return() from the run method implicitly causes the thread to exit.