The key to Java multi-threading programming is to understand thread creation, synchronization mechanism and resource management. 1. Threads are the basic unit of program execution. They can be created by implementing the Runnable interface or inheriting the Thread class; 2. Synchronized, wait/notify or ReentrantLock are required to control the execution order; 3. Avoid deadlocks, unified resource application order, set timeouts and reduce nested locks; 4. Using thread pools can improve performance. It is recommended that ExecutorService manage fixed, single-thread or cache pools. Mastering these core points can effectively deal with concurrent scenarios.

Java multi-threaded programming is actually not that mysterious, but it is indeed prone to errors. If you are new to multi-threading development, you may feel "Why are the threads running out of chaos?" and "Why are the locks not working?" at the beginning. Don't worry, this article will take you to sort out a few key points and give you more confidence when writing multi-threaded code.

What are threads in Java?

In Java, threads are the basic unit of program execution. Each Java program has at least one main thread (main thread), and the code you write is run in this thread by default.
If you want the program to do several things at the same time, such as downloading files while updating the progress bar, you need to use multi-threading.

There are two common ways to create threads:

• Inherit Thread class and override run() method
• Implement the Runnable interface and pass it to Thread object

For example:

 class MyTask implements Runnable {
    public void run() {
        System.out.println("Task is running");
    }
}

//Usage method Thread t = new Thread(new MyTask());
t.start(); // Note: Not calling run()

Tip: Try to use Runnable as much as possible instead of inheriting Thread , because Java does not support multiple inheritance, and the implementation of interfaces is more flexible.

How to control the execution order of multiple threads?

Many times we hope that threads can work in a coordinated manner instead of doing their own things. This requires the use of some basic synchronization mechanisms.

Several common control methods include:

• synchronized keyword: can be used to modify methods or code blocks, ensuring that only one thread executes a certain piece of code at the same time
• wait() / notify() : used for inter-thread communication, a thread waits for a certain condition to be met before continuing to execute.
• ReentrantLock : More flexible than synchronized, supports advanced features such as trying to add locks and timeouts

Let’s give a simple scenario: two threads print A and B alternately.

You can use synchronized with wait/notify , or use ReentrantLock Condition . The key is to understand who should execute first and who should wait.

Common misunderstandings: Many people think that as long as synchronized is added, everything will be fine, but if you do not pay attention to the scope and granularity of the object lock, concurrency problems may still occur.

How to avoid deadlocks?

Deadlock is one of the most troublesome problems in multi-threading. It usually happens when multiple threads are waiting for each other to release resources.

To avoid deadlocks, there are several practical suggestions:

• Unified resource application order : For example, threads take A first and then B first, and threads two also follow this order, which can reduce conflicts.
• Set the timeout mechanism : use tryLock() instead of blocking directly, and give up if you can't get the lock for a while
• Avoid nested locks : Try not to acquire another lock before it is released

For example:

 Object lock1 = new Object();
Object lock2 = new Object();

// Thread 1
new Thread(() -> {
    synchronized (lock1) {
        synchronized (lock2) {
            // do something
        }
    }
}).start();

// Thread 2
new Thread(() -> {
    synchronized (lock2) {
        synchronized (lock1) {
            // Possible deadlock}
    }
}).start();

The above code may cause deadlock because the order of the locks is inconsistent.

What are the benefits of using thread pools?

Although it is simple to create threads manually, it is not recommended in actual projects. Frequently creating and destroying threads is resource-intensive. A better approach is to use thread pools.

Java provides the ExecutorService interface and Executors tool classes to manage thread pools. You can select different types of thread pools according to your needs:

• Fixed-size thread pool ( newFixedThreadPool ): suitable for most concurrent scenarios
• Single-thread pool ( newSingleThreadExecutor ): Ensure task serial execution
• Cache thread pool ( newCachedThreadPool ): suitable for a large number of short-term asynchronous tasks

Example of usage:

 ExecutorService executor = Executors.newFixedThreadPool(4);
executor.submit(() -> System.out.println("Task1"));
executor.shutdown(); // Remember to close it

Small details: You can use submit() or execute() to submit tasks. The difference is that the former can return the result (Future), while the latter cannot.

Multithreading is not difficult, but simple and easy to get into trouble. Mastering basic concepts, understanding common tool classes, understanding synchronization mechanisms, and using them in conjunction with thread pools, you can basically cope with most development scenarios.

The above is the detailed content of Java multithreading tutorial. For more information, please follow other related articles on the PHP Chinese website!