How to solve thread contention and resource contention issues in Java

How to solve thread competition and resource contention problems in Java

In multi-threaded programming, thread competition and resource contention problems are very common. If you deal with Improper use will lead to program security and performance problems. This article will introduce some common solutions and provide specific code examples.

1. Use the synchronized keyword
The synchronized keyword is the most basic method in Java to solve the problem of thread competition and resource contention. It can mark a block of code or method as synchronized so that only one thread can execute the block or method at a time.

1. Use the synchronized keyword to modify the method:

public synchronized void synchronizedMethod(){
    // 同步代码块
}

2. Use the synchronized keyword to modify the code block:

public void nonSynchronizedMethod(){
    synchronized (this){
        // 同步代码块
    }
}

above In the example, the synchronized keyword marks methods or code blocks as synchronized, ensuring that only one thread can access them at the same time, thereby avoiding thread competition and resource contention issues.

2. Use Lock interface and ReentrantLock class
In addition to the synchronized keyword, Java also provides the Lock interface and ReentrantLock class to solve thread competition and resource contention issues. Unlike synchronized, the Lock interface and ReentrantLock class provide more flexibility and functionality.

1. Use Lock interface and ReentrantLock class:

Lock lock = new ReentrantLock();

public void synchronizedMethod(){
    lock.lock();
    try{
        // 同步代码块
    }finally{
        lock.unlock();
    }
}

In the above example, a ReentrantLock object is first created, then the lock() method is used to obtain the lock, and in Use the unlock() method in the try-finally statement to release the lock. This ensures that only one thread can execute the synchronized code block at the same time.

3. Use the Semaphore class
If you need to control the number of threads accessing a resource at the same time, you can use the Semaphore class to solve the problem. The Semaphore class is a counting semaphore that can specify multiple threads to access a shared resource at the same time.

1. Using the Semaphore class:

Semaphore semaphore = new Semaphore(2); // 允许同时访问的线程数为2

public void synchronizedMethod(){
    try{
        semaphore.acquire(); // 获取许可
        // 同步代码块
    }catch(InterruptedException e){
        // 异常处理
    }finally{
        semaphore.release(); // 释放许可
    }
}

In the above example, a Semaphore object is first created and the number of threads allowed to access simultaneously is 2. Then use the acquire() method to obtain the permission. If the permission is not available, the thread will be blocked until a permission is available. Finally, use the release() method in the finally statement to release the license.

In this way, only the specified number of threads can execute the synchronized code block at the same time, and other threads need to wait for permission to enter.

4. Use the Condition interface and the ReentrantLock class
The combination of the Condition interface and the ReentrantLock class can more flexibly control thread competition and resource contention issues. The Condition interface provides methods such as await() and signal() to implement thread waiting and wake-up operations.

1. Using the Condition interface and ReentrantLock class:

Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();

public void waitMethod(){
    lock.lock();
    try{
        while(conditionFlag){
            condition.await(); // 线程等待
        }
        // 同步代码块
    }catch(InterruptedException e){
        // 异常处理
    }finally{
        lock.unlock();
    }
}

public void signalMethod(){
    lock.lock();
    try{
        conditionFlag = false;
        condition.signal(); // 唤醒线程
    }finally{
        lock.unlock();
    }
}

In the above example, a ReentrantLock object and a Condition object are first created. In the waitMethod() method, use the lock() method to acquire the lock, and use the await() method in the while loop to make the thread wait until conditionFlag is false. In the signalMethod() method, use the lock() method to acquire the lock, set conditionFlag to false, and use the signal() method to wake up the thread.

In this way, thread waiting and waking up operations can be realized, thereby controlling thread competition and resource contention issues.

Summary
Thread competition and resource contention are common problems encountered in multi-threaded programming, and appropriate solutions need to be adopted to ensure the safety and performance of the program. This article introduces the use of the synchronized keyword, Lock interface and ReentrantLock class, Semaphore class, Condition interface and ReentrantLock class to solve thread competition and resource contention problems, and provides corresponding code examples. I hope readers can choose the appropriate method to solve the problem based on actual needs.

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