The thread synchronization and mutual exclusion control in the Java class library
The thread synchronization and mutual exclusion control in the Java class library
In multi -threaded programming, thread synchronization and mutual exclusion control are very important concepts.When multiple threads access shared resources at the same time, data competition or conditions may occur, resulting in uncertain results.The Java class library provides some tools and mechanisms to help developers achieve thread synchronization and mutual exclusion control to ensure the correctness and reliability of multi -threaded programs.
1. Synchronized keyword
Synchronized keywords are used to modify methods or code blocks to ensure that only one thread can access the modified code at the same time.When a thread obtains the lock of the synchronized code block, other threads will be blocked until the thread is released.This mechanism can ensure that shared resources are accessed by only one thread at the same time.The following is an example of the synchronized keyword:
public class Counter {
private int count;
public synchronized void increment() {
count++;
}
public synchronized int getCount() {
return count;
}
}
In the above example, the Counter class uses the synchronized keyword to modify the `increment () and` getCount () `method to ensure that only one thread can access them at the same time.
2. Lock interface and ReentrantLock class
Java also provides the Lock interface and the ReentrantLock class to achieve thread synchronization and mutual exclusion control.Compared with the synchronized keyword, the Lock interface provides greater flexibility and functions.The following is an example of the Lock interface and the ReentrantLock class:
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Counter {
private int count;
private Lock lock = new ReentrantLock();
public void increment() {
lock.lock();
try {
count++;
} finally {
lock.unlock();
}
}
public int getCount() {
lock.lock();
try {
return count;
} finally {
lock.unlock();
}
}
}
In the above examples, the Counter class uses the Lock interface and the RENTRANTLOCK class to achieve thread synchronization and mutually exclusive control.Get the lock by calling the `lock ()" method, and then perform the operation of shared resources in the `Try-Finally` block, and finally release the lock in the` Finally` block.
3. Condition interface and ReentrantLock use Condition
Through the Condition interface, it can be used in conjunction with the ReentrantLock class to achieve more complicated thread synchronization and mutually exclusive control.The Condition object can return multiple Condition instances to control different thread scheduling.The following is an example of the use of the Condition interface and the ReentrantLock:
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Buffer {
private String[] buffer;
private int count;
private int putIndex;
private int takeIndex;
private Lock lock = new ReentrantLock();
private Condition notFull = lock.newCondition();
private Condition notEmpty = lock.newCondition();
public Buffer(int size) {
buffer = new String[size];
}
public void put(String message) throws InterruptedException {
lock.lock();
try {
while (count == buffer.length) {
notFull.await();
}
buffer[putIndex] = message;
putIndex = (putIndex + 1) % buffer.length;
count++;
notEmpty.signal();
} finally {
lock.unlock();
}
}
public String take() throws InterruptedException {
lock.lock();
String message;
try {
while (count == 0) {
notEmpty.await();
}
message = buffer[takeIndex];
takeIndex = (takeIndex + 1) % buffer.length;
count--;
notFull.signal();
} finally {
lock.unlock();
}
return message;
}
}
In the above example, the Buffer class uses the Condition interface with the ReentrantLock class to achieve a limited -sized buffer.By calling the `AWAIT ()) method to release the lock and wait for the condition to be satisfied, and then wake up the waiting thread by calling the` Signal () "method.
The above is some commonly used mechanisms and examples of synchronization and mutual control control in the Java class library.Multi -threaded programming is very important to properly handle thread synchronization and mutual exclusion control to ensure the correctness and reliability of the program.
