Hi! First of all, congratulations: you've reached the topic of Multithreading in Java! This is a serious achievement — you've come a long way. But prepare yourself: this is one of the most difficult topics in the course. And it's not that we're using complex classes or lots of methods here: in fact, we'll use less than twenty. It's more that you'll need to change how you think slightly.
Previously, your programs have been executed sequentially. Some lines of code came after others, some methods came after others, and everything was basically clear. First, we calculated something, then displayed result on the console, and then the program ended.
To understand multithreading, it's better to think in terms of parallelism. Let's start with something quite simple :)
Imagine your family is moving from one house to another. Gathering up all your books will be an important part of the move. You've accumulated lots of books, and you need to put them in boxes.
Currently, you're the only one available. Mom is preparing food, brother is packing clothes, and sister went to the store. Alone, you can manage somehow. Sooner or later, you'll complete the task yourself, but it will take a lot of time. However, your sister will return from the store in 20 minutes, and she doesn't have anything else to do. So she can join you.
The task hasn't changed: put books into boxes. But it's being performed twice as fast.
Why? Because the work is happening in parallel. Two different 'threads' (you and your sister) are performing the same task simultaneously. And if nothing changes, then there will be a huge time difference compared with the situation where you do everything by yourself.
If brother finishes his job soon, he can help you and things will go even faster.
![Multithreading in Java: what it is, its benefits and common pitfalls - 4]()
Imagine that Thread-1 interacts with some Object-1, and that Thread-2 interacts with Object-2. Furthermore, the program is written so that:
![Multithreading in Java: what it is, its benefits and common pitfalls - 6]()
'Java Concurrency in Practice' was written in 2006, but has not lost its relevance. It is dedicated to multithreaded Java programming — from the basics to the most common mistakes and antipatterns.
If you someday decide to become a multithreading guru, this book is a must-read.
See you in the next lessons! :)
Problems solved by multithreading
Multithreading was actually invented to achieve two important objectives:Do several things at the same time.
In the example above, different threads (family members) performed several actions in parallel: they washed dishes, went to the store, and packed things.
We can offer an example more closely related to programming. Suppose you have a program with a user interface. When you click 'Continue' in the program, some calculations should happen and the user should see the following screen. If these actions were performed sequentially, then the program would just hang after the user clicks the 'Continue' button. The user will see the screen with the 'Continue' button screen until the program performs all internal calculations and reaches the part where the user interface is refreshed.
Well, I guess we'll wait a couple of minutes!
![Multithreading in Java: what it is, its benefits and common pitfalls - 3]()
Or we could rework our program, or, as programmers say, 'parallelize' it. Let's perform our calculations on one thread and draw the user interface on another. Most computers have enough resources to do this. If we take this route, then the program won't freeze up and the user will move smoothly between screens without worrying about what's happening inside. One doesn't interfere with the other :)
Perform calculations more quickly.
Everything is much simpler here. If our processor has multiple cores, and most processors today do, then several cores can handle our list of tasks in parallel. Obviously, if we need to perform 1000 tasks and each takes one second, one core can finish the list in 1000 seconds, two cores in 500 seconds, three in a little more than 333 seconds, etc.
public class MyFirstThread extends Thread {
@Override
public void run() {
System.out.println("I'm Thread! My name is " + getName());
}
}
public class Main {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
MyFirstThread thread = new MyFirstThread();
thread.start();
}
}
}
Problems created by multithreading
In our example with books, you saw that multithreading solves very important tasks and can make our programs faster. Often many times faster. But multithreading is considered to be a difficult topic. Indeed, if used improperly, it creates problems instead of solving them. When I say 'creates problems', I don't mean in some abstract sense. There are two specific problems that multithreading can create: deadlock and race conditions. Deadlock is a situation where multiple threads are waiting for resources held by each other, and none of them can continue to run. We'll talk more about it in subsequent lessons. The following example will suffice for now:
Imagine that Thread-1 interacts with some Object-1, and that Thread-2 interacts with Object-2. Furthermore, the program is written so that:
- Thread-1 stops interacting with Object-1 and switches to Object-2 as soon as Thread-2 stops interacting with Object-2 and switches to Object-1.
- Thread-2 stops interacting with Object-2 and switches to Object-1 as soon as Thread-1 stops interacting with Object-1 and switches to Object-2.
public class MyFirstThread extends Thread {
@Override
public void run() {
System.out.println("Thread executed: " + getName());
}
}
public class Main {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
MyFirstThread thread = new MyFirstThread();
thread.start();
}
}
}
'Java Concurrency in Practice' was written in 2006, but has not lost its relevance. It is dedicated to multithreaded Java programming — from the basics to the most common mistakes and antipatterns.
If you someday decide to become a multithreading guru, this book is a must-read.
See you in the next lessons! :)
GO TO FULL VERSION