- When you want to execute the task in serial execution you write the code in order in which you want to execute.
- Multi-threaded applications normally do parallel processing of tasks where as single threaded applications do one task at a time i.e. If there are two tasks such as T1, T2 they are executed in serial order i.e T1 after T2 or T2 after T1, where as multi threading enables us to execute them simultaneously i.e. T1 along with T2. We can choose single threaded applications when parallel processing is not required example use cases such as simple text editor.
- Its like we execute two task parallel. like if we one CPU need to achieve the parallel execution then switching the Task T1 and T2 in some intervals.
- Create thread using
Thread
class andRunnable
interface - Best one is using the
Runnable
interface because we are just using therun()
. then why should we extendsThread
class and not inherit any property.
- Using
Thread
class
class MyThread extends Thread{
@Override
public void run() {
for (int i = 0; i <1000 ; i++) {
System.out.print("T");
}
}
}
// Implementation
MyThread thread=new MyThread();
thread.start();
- Using
Runnable
Interface
class MyThread2 implements Runnable{
@Override
public void run() {
System.out.print("R");
}
// Implementation
MyThread2 thread2=new MyThread2(); // task
Thread newThread=new Thread(thread2);
newThread.start();
}
Thread.sleep(milisec)
block the thread for given time of interval. it throws interruptedException- Why thread.stop() is dangerous ?
- You are not giving an opportunity to the thread to rollback or reverse whatever the action it performed.
- What shoud we do?
- We should use the
interrupt()
the thread. now you tell the thread to stop now it will be decided by thread to stop itself opr not. - we can read the signal using
interrupted()
and perform same task here.
- We should use the
- A thread executing in the Java virtual machine is in this state, internally we can think of it as a combination of two sub states Ready and Running, i.e. when you start the thread it comes to Ready state and wait for the CPU, and if CPU is allocated then it goes into Running state. Once allocated CPU time is completed, in other words when the Thread schedular suspends the thread then it goes back to the Ready state and waits for its turn again.
The yield() method instructs the thread schedular to pass the CPU to other waiting thread if any.
- A thread is blocked if it is waiting for a monitor lock is in this state. Refer synchronized methods and blocks.
- A thread that is waiting indefinitely for another thread to perform a particular action is in this state. Refer
wait(), join()
A thread that is waiting for another thread to perform an action for up to a specified waiting time is in this state. Refer wait(millis), join(millis)
A thread that has exited i.e. it has either completed its task or terminated in the middle of the execution.
yield() method
-
- yield() method is important in few scenarios, suppose a thread is given 5 min of CPU time, now after a minute thread knows that it doesn't need the CPU anymore with in that time period, in such scenarios do you think that blocking the CPU for the next four minutes is a good idea ? No, it is better to pass on the control to the threads if any waiting for CPU and that is when we can use the yield() method. Usage Thread.yield(), it is a static method of the Thread class and it affects the current thread from which the method is invoked.
- MIN-1
- DEFAULT 5
- HIGHEST 10
newThread.setPriority(8);
- We can create a Thread group and add thread in to groups
- Example
ThreadGroup threadGroup=new ThreadGroup("DemoThreadGroup");
threadGroup.setMaxPriority(4);
Thread thread=new Thread(threadGroup,new MyTask(),"MYTaskThread");
Thread thread1=new Thread(threadGroup,new MyTask(),"MYTaskThread1");
Thread thread2=new Thread(threadGroup,new MyTask(),"MYTaskThread2");
Thread thread3=new Thread(threadGroup,new MyTask(),"MYTaskThread3");
thread1.start();
thread2.start();
thread3.start();
thread.start();
outPut
java.lang.ThreadGroup[name=DemoThreadGroup,maxpri=4]
Thread[MYTaskThread1,4,DemoThreadGroup]
Thread[MYTaskThread2,4,DemoThreadGroup]
Thread[MYTaskThread3,4,DemoThreadGroup]
Thread[MYTaskThread,4,DemoThreadGroup]
- Basically we use thread group whenwe wnat to group the related thread into one group so that we can set the same priority to all threads or if we interrupt thread group all thread associated with that group will be interrupted.
- Daemon threads are the ones which does not prevent the JVM from exiting the application once it finishes. Daemon threads are handy for performing background tasks such as garbage collection or collecting application statistics etc. Note that the Java Virtual Machine exits when the only threads running are all daemon threads.
- Thread will terminate one the main thread end.
- Garbage collection and some statics
- Reference Handler , Finalizer and Signal Dispatcher all is
Daemon Thread.
- Main thread is not Daemon.
- this one is used when we want to return something from the thread.
- Unlike Runnable, Callable interface allows us to create an asynchronous task which is capable of returning an Object.
interface Callable<E> {
E call() throws Exception;
}
-
Future Object -
- When you submit a Callable task to the ExecutorService, it returns a Future object. This object enables us to access the request and check for the result of the operation if it is completed.
-
Important methods -
-
isDone()
- Returns true if the task is done and false otherwise. -
get()
- Returns the result if the task is done, otherwise waits till the task is done and then it returns the result. -
cancel(boolean mayInterrupt)
- Used to stop the task, stops it immediately if not started, otherwise interrupts the task only if mayInterrupt is true.
synchronized
this make the method thread safe.
static int a=0;
private int b;
// This method is not thread safe because synchronized lock b because it is object while a is static so its not locked that so problem with a.
public synchronized void increment(){
b++;
a++;
}
}
// solution
- lock should be used in the same manned both side ,
- like if pen locked first then need to lock pen first in other Writer too.
- here first write lock the book and the Thread go to sleep context changes and now writer2
- lock the pen so deadlock situation is arrived, to fix this we need to provide the resource in same manner.
- for both object book first then pen.
// Code from Thread2
synchronized (book){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (pen){
System.out.println("Writer 1 writing book");
}
}
// Code from thread2
// synchronized (pen){
// synchronized (book){
// System.out.println("Writer 2 writing book");
// }
// }
// Solved deal lock by providing lock in same manner
synchronized (book){
synchronized (pen){
System.out.println("Writer 2 writing book");
}
}
-
Read/Write lock
-
readLock allows us to lock the object for read operation, and the interesting point is that the read operation can be shared i.e if two threads are waiting for readLock then both of them can proceed forward with the operation as read operation doesn't change the data.
-
Where as writeLock is mutually exclusive i.e. if a writeLock is accepted then all the other lock requests should wait till the thread that owns the lock releases it.
-
For example let us assume the following chronologically ordered lock requests
T1 -> lock.readLock();
T2 -> lock.readLock();
T3 -> lock.readLock();
T4 -> lock.writeLock();
T5 -> lock.readLock();
Here T1, T2, T3 can share the readLock and proceed forward with the operation. Where T4 should wait till T1, T2 and T3 unlocks.
Why T5 is waiting ?
Because writeLock is requested by T4 before its request and hence all subsequent requests to read/write locks should wait.
This is in contrast to synchronized methods/blocks because for synchronized method/block there is no segregation of read and write operations. Object is locked no matter whether it is read or write.
Caution - It is always better to put the unlock operation in finally, as you need to unlock irrespective of exceptions.
- Thread signalling using wait() and notify() -
- wait() method Releases the lock over the object and takes the thread to WAITING state. And the thread remains in that state until some other thread calls the notify() method over the same object. Once notify() is invoked it ends the wait for one single thread and takes the thread to BLOCKED state where the thread remains in that state till the lock is obtained. wait() only returns after obtaining the lock.
- wait(long millis) slightly differs, as it takes thread to TIMED_WAITING and waits only for the specified duration.
notify() - notifies one single thread where as notifyAll() notifies all the threads waiting for the signal.