How to solve thread synchronization and mutual exclusion issues in Java

How to solve the thread synchronization and mutual exclusion problems in Java

In Java multi-threaded programming, thread synchronization and mutual exclusion are a very important task. The purpose of thread synchronization is to ensure that multiple threads execute in a specific order, while thread mutual exclusion ensures that multiple threads do not access or modify shared resources at the same time. Correctly handling thread synchronization and mutual exclusion issues can avoid many thread safety issues and improve program performance and reliability.

The following will introduce several commonly used methods to solve thread synchronization and mutual exclusion problems, and provide corresponding code examples.

1. Use the synchronized keyword to achieve thread synchronization

The synchronized keyword in Java can be used to modify methods or code blocks to achieve thread synchronization. When a thread enters a synchronized modified method or code block, it acquires the lock of the corresponding object, and other threads need to wait for the lock to be released before they can continue execution. The following is an example of using the synchronized keyword to achieve thread synchronization:

public class SynchronizedExample {
    private int count = 0;
    
    public synchronized void increment() {
        count++;
    }
    
    public synchronized int getCount() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) {
        SynchronizedExample example = new SynchronizedExample();
        
        // 创建两个线程并发执行
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });
        
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });
        
        thread1.start();
        thread2.start();
        
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println("Count: " + example.getCount());
    }
}

In the above example, the synchronized keyword is used to modify the increment() and getCount() methods to ensure that the count variable is increased and read. Operations are thread-safe. Running the program will output Count: 2000, indicating that the increment operations of the two threads on the count variable are correctly synchronized.

2. Use the Lock and Condition interfaces to achieve thread synchronization

In addition to using the synchronized keyword, Java also provides the Lock and Condition interfaces to achieve thread synchronization. Compared with the synchronized keyword, the Lock and Condition interfaces provide finer-grained control and can achieve thread synchronization more flexibly. The following is an example of using the Lock and Condition interfaces to implement thread synchronization:

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockExample {
    private int count = 0;
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    
    public void increment() {
        lock.lock();
        try {
            count++;
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }
    
    public int getCount() {
        lock.lock();
        try {
            while (count < 1000) {
                condition.await();
            }
            return count;
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
        return -1;
    }
}

public class Main {
    public static void main(String[] args) {
        LockExample example = new LockExample();
        
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });
        
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });
        
        thread1.start();
        thread2.start();
        
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println("Count: " + example.getCount());
    }
}

In the above example, the Lock and Condition interfaces are used to implement synchronization operations on the count variable. Acquire and release locks by calling the lock() and unlock() methods, and wait and wake up the thread by calling the await() and signalAll() methods. Running the program will output Count: 2000, indicating that the increment operations of the two threads on the count variable are correctly synchronized.

Summary

There are many solutions to thread synchronization and mutual exclusion problems in Java. This article introduces the use of the synchronized keyword and the Lock and Condition interfaces to achieve thread synchronization. When using these methods, you need to abide by the following principles:

1. Try to use the simplest way to achieve thread synchronization, such as using the synchronized keyword. Consider using the Lock and Condition interfaces only when more fine-grained control is required.
2. When using the synchronized keyword, try to use object-level locks instead of class-level locks to avoid unnecessary performance overhead.
3. When using the Lock and Condition interfaces, be sure to remember to release the lock in the finally block to ensure that the lock is released.

By properly handling thread synchronization and mutual exclusion issues, we can avoid many potential thread safety issues and ensure the correctness and reliability of the program. At the same time, it can also improve the performance and concurrency of the program, make full use of hardware resources on multi-core processors, and improve the execution efficiency of the program.

The above is the detailed content of How to solve thread synchronization and mutual exclusion issues in Java. For more information, please follow other related articles on the PHP Chinese website!