Java Multi Threading - Quick Summary

 

• Wait is used in thread communication when multiple threads are accessing the same object. 
• Sleep is used to suspend the execution of the current thread. 
• Wait vs Sleep 
• Wait is part of the object class, sleep is a static method in the Thread class.
• wait and notify should be called on synchronized context whereas sleep doesn't need to be.
• Calling outside synchronized context results in IllegalMonitorException. Both methods throw interrupted exception at the compile time.
• wait release the lock whereas sleep doesn't.
• Yield also stops executing current thread. If there are no waiting threads, then the same thread will resume execution.
• Join call on a thread will block the current execution until the joined thread finishes its execution.
• Blocking queue synchronizes the thread calls implicitly. It gives us an immedeate solution to the classic producer consumer problem via put and take methods. put or offer waits until the queue capacity is free and adds an element, poll or take waits until queue gets some data and consumes it.
• Lock is another way to synchronize the thread calls. lock.lock() and lock.unlock() are used to scope the code with synchronizing behavior. Conditions are created using lock.newCondition(). condition.wait() makes thread to wait on a condition and condition.signal() is to free a thread waiting on a condition.
• CountDownLatch can be initialized to an arbitrary int value before starting any threads. await() on the latch makes the current execution to wait until the latch value becomes zero. latch value will be counted down by threads after their execution by calling latch.countDown.
• CyclicBarrier can also be initialized with an arbitrary value. It allows each thread to wait on barrier.await() until the no. of threads reach that point becomes the value that barrier is initialized with. All the threads will be allowed to resume their further execution after that moment.
• Semaphore gives simultaneous access to multiple threads. A thread that calls semaphore.acquire() can get an access to process the code block surrounded by semaphore.acquire and semaphore.release. If a semaphore is initialized with a value say 2, at any point in time, max 2 threads are allowed  to access the semaphore code block simultaneously.
• Volatile variables makes the reads and writes to the main memory. But, it doesn't give synchronous behavior. 
• Atomic variables support compound operations like increment, decrement on variables in an atomic or synchronous manner. We can use them as an alternative for synchronization only for operations supported by the java atomic API,  since they are fast and non-blocking.
• Using ThreadLocal, each thread gets a copy of the object. Used for non thread-safe objects and we don't want to give synchronous access.
• Creating Threads while executing the code is an expensive operation. Threadpool cuts down this cost since it uses existing threads in the pool. Also, these threads can be reused for different tasks.
• FixedThreadPool - Creates a fixed no. of reusable worker threads in the pool.
• CachedThreadPool - Creates a unbounded thread pool. It automatically expand/shrink the pool size. It adds new threads when all the threads in the pool are occupied. Removes idle threads them when the task queue becomes free.
• ForkJoinPool - It splits the main task into sub tasks and submits the sub tasks to the same fork join pool.