BlockingQueue is excellent when you want to skip the complexity involved in wait–notify statements. This BlockingQueue can be used to solve the producer-consumer problem as well as given blow example. As this problem is well known to every programmer, I am not going in detail of problem description. How BlockingQueue fit into Solution Any effective […]
Java Thread Life Cycle and Thread States
A java thread can be in any of following thread states during it’s life cycle i.e. New, Runnable, Blocked, Waiting, Timed Waiting or Terminated. These are also called life cycle events of a thread in java. Let’s understand each state in more detail. Java Thread Life Cycle States New As soon as, you create new […]
Concurrency vs. Parallelism
Concurrency means multiple tasks which start, run, and complete in overlapping time periods, in no specific order. Parallelism is when multiple tasks OR several part of a unique task literally run at the same time, e.g. on a multi-core processor. Remember that Concurrency and parallelism are NOT the same thing. Let’s understand more in detail […]
Java Multi-threading Evolution and Topics
One of our reader, Anant, asked this extremely good question to elaborate / list down all related topics that we should know about multi-threading including changes made in java 8.( Beginner level to Advance level). All he wanted to know was evolution of Multi-threading Framework in Java from Simple Runnable interface to latest feature in […]
Difference between lock and monitor – Java Concurrency
You may have faced this question in your interview that what is the difference between lock and a monitor? Well, to answer this question you must have good amount of understanding of how java multi-threading works under the hood. Short answer, locks provide necessary support for implementing monitors. Long answer read below. Locks A lock […]
ScheduledThreadPoolExecutor – Task Scheduling with Executors
The Java Executor Framework provides the ThreadPoolExecutor class to execute Callable and Runnable tasks with a pool of threads, which avoid you writing lots of boiler plate complex code. The way executors work is when you send a task to the executor, it’s executed as soon as possible. But there may be used cases when […]
Java Callable Future Example
One of the benefits of the Java executor framework is that we can run concurrent tasks that may return a single result after processing the tasks. The Java Concurrency API achieves this with the following two interfaces Callable and Future. 1. Java Callable and Future interfaces 1.1. Callable Callable interface has the call() method. In […]
Java Fixed Size Thread Pool Executor Example
In previous tutorial, we learned about basic thread pool executor with unlimited possible number of threads into the pool and it’s example usage. Now lets look example of fixed size thread pool executor which will help in improved performance and better system resource utilization by limiting the maximum number of threads in thread pool. 1) […]
Java Thread Pool – ThreadPoolExecutor Example
Why you need thread pool in Java? Answer is usually when you develop a simple, concurrent application in Java, you create some Runnable objects and then create the corresponding Thread objects to execute them. Creating a thread in Java is an expensive operation. And if you start creating new thread instance everytime to execute a […]
ConcurrentLinkedDeque Example – Non-blocking Thread-safe List
In java, most used data structure is probably a list. A list has an undetermined number of elements and you can add, read, or remove the element of any position. Additionally, concurrent lists allow the various threads to add or remove elements in the list at a time without producing any data inconsistency. And non-blocking […]
Control concurrent access to multiple copies of a resource using Semaphore
In previous tutorial, we learned about binary semaphore which can be used to control access to single copy of a resource using the counter value either 0 or 1. However, semaphores can also be used when you need to protect various copies of a resource that can be executed by more than one thread at […]
How to work with wait(), notify() and notifyAll() in Java?
The Object class in Java has three final methods that allow threads to communicate i.e. wait(), notify() and notifyAll(). Learn how to use these methods.
Binary Semaphore Tutorial and Example
A semaphore is a counter that protects the access to one or more shared resources. In this tutorial, we will learn how to use the binary semaphore for controlling access to a shared resource by multiple threads. How Semaphores Work? You can visualize a semaphore as counter which can be incremented or decremented. You initialize […]
How to Use Locks in Java | java.util.concurrent.locks.Lock Tutorial and Example
We are already aware of basic concepts around thread synchronization and various mechanisms using synchronized keyword. Java provides another mechanism for the synchronization of blocks of code based on the Lock interface and classes that implement it (such as ReentrantLock). In this tutorial, we will see a basic usage of Lock interface to solve printer […]
Creating Threads Using java.util.concurrent.ThreadFactory
The factory design pattern is one of the most used design patterns in the java. It is one of creational patterns and can be used to develop an object in demand of one or several classes. With this factory, we centralize the creation of objects. The centralization of creation logic brings us some advantages e.g. […]
Java ThreadLocal Variables – When and How to Use?
Today, one of the most critical aspects of a concurrent application is shared data. When you create thread that implements the Runnable interface and then start various Thread objects using the same Runnable object, all the threads share the same attributes that are defined inside the runnable object. This essentially means that if you change […]
How to Restart Thread Using UncaughtExceptionHandler
As we are already aware that there are two kinds of exceptions in Java. Checked exceptions and Unchecked exceptions. Checked exceptions must be specified in the throws clause of a method or caught inside them. Unchecked exceptions don’t have to be specified or caught. When a checked exception is thrown inside the run() method of […]
Java Compare and Swap Example – CAS Algorithm
One of the best additions in java 5 was Atomic operations supported in classes such as AtomicInteger, AtomicLong etc. These classes help you in minimizing the need of complex (un-necessary) multi-threading code for some basic operations such as increment or decrement a value which is shared among multiple threads. These classes internally rely on an […]
Java Concurrency – Difference between yield() and join()
Multi-threading is very popular topic among interviewers from long time. Though I personally feel that very few of us get real chance to work on a complex multi-threaded application (I got only one chance in last 7 years), still it helps in having the concepts handy to boost your confidence ONLY. Previously, I discussed a […]
Java Concurrency – Thread Safety?
Defining thread safety is surprisingly tricky. A quick Google search turns up numerous “definitions” like these: Thread-safe code is code that will work even if many Threads are executing it simultaneously. A piece of code is thread-safe if it only manipulates shared data structures in a manner that guarantees safe execution by multiple threads at […]