Introduction to the usage of ReentrantLock class in

This article brings you an introduction to the usage of the ReentrantLock class in Java. It has certain reference value. Friends in need can refer to it. I hope it will be helpful to you.

In Java multi-threading, you can use the synchronized keyword to achieve synchronization and mutual exclusion between multiple threads, but the new ReentrantLock class added in JDK 1.5 can also achieve the same effect, and also has extended functions. More powerful, such as sniffing locks, multi-way branch notifications, fair locks and unfair locks (default) functions, and more flexible in use than synchronized.

Use ReentrantLock to achieve synchronization

public class MyService {
    private Lock lock = new ReentrantLock();
    public void testMethod() {
        lock.lock();
        for (int i = 0; i < 10; i++){
            System.out.println("ThreadName=" + Thread.currentThread().getName() + (" " + (i + 1)));
        }
        lock.unlock();
    }
}

public class MyThread extends Thread {
    private MyService myService;
    public MyThread(MyService myService) {
        this.myService = myService;
    }
    @Override
    public void run() {
        myService.testMethod();
    }
}

public static void main(String[] args) throws IOException, InterruptedException {
MyService myService = new MyService();
MyThread myThreadA = new MyThread(myService);
        MyThread myThreadB = new MyThread(myService);
        MyThread myThreadC = new MyThread(myService);
        MyThread myThreadD = new MyThread(myService);
        MyThread myThreadE = new MyThread(myService);

        myThreadA.start();
        myThreadB.start();
        myThreadC.start();
        myThreadD.start();
        myThreadE.start();

    }

Call the lock() method of the ReentrantLock object to acquire the lock, and call the unLock() method to release the lock.

Judging from the running results, the lock will be released after the current thread has finished printing. , other threads can continue printing. The data printed by the thread is grouped and printed, because the current thread already holds the lock, but the order of printing between threads is random.

Use Condition to implement waiting/notification

The keyword synchronized can be combined with the wait() and notify() / notifyall() methods to implement the wait/notify mode. However, when used, when the notify() method is called, the JVM will randomly select a thread in the WAITNG state to execute. .

The use of Condition can be more flexible, you can implement "selective notification", you can specify which threads to wake up and which threads to continue waiting.

public class MyService {

    private Lock lock = new ReentrantLock();
    public Condition conditionA = lock.newCondition();
    public Condition conditionB = lock.newCondition();

    public void awaitA() throws InterruptedException {
        lock.lock();

        System.out.println("begin awaitA 时间" + System.currentTimeMillis() + "ThreadName=" + Thread.currentThread().getName());

        conditionA.await();

        System.out.println("end awaitA 时间" + System.currentTimeMillis() + "ThreadName=" + Thread.currentThread().getName());

        lock.unlock();
    }

    public void awaitB() throws InterruptedException {
        lock.lock();

        System.out.println("begin awaitB 时间" + System.currentTimeMillis() + "ThreadName=" + Thread.currentThread().getName());

        conditionB.await();

        System.out.println("end awaitB 时间" + System.currentTimeMillis() + "ThreadName=" + Thread.currentThread().getName());

        lock.unlock();
    }

    public void  signalAll_A() throws InterruptedException {
        lock.lock();
        System.out.println("begin signalAll_A 时间" + System.currentTimeMillis() + "ThreadName=" + Thread.currentThread().getName());

        conditionA.signalAll();

        lock.unlock();
    }

    public void  signalAll_B() throws InterruptedException {
        lock.lock();
        System.out.println("begin signalAll_B 时间" + System.currentTimeMillis() + "ThreadName=" + Thread.currentThread().getName());

        conditionB.signalAll();

        lock.unlock();
    }
}

public class ThreadA extends Thread {

    private MyService myService;
    public ThreadA(MyService myService) {
        this.myService = myService;
    }

    @Override
    public void run() {
        try {
            myService.awaitA();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class ThreadB extends Thread {

    private MyService myService;

    public ThreadB(MyService myService) {
        this.myService = myService;
    }

    @Override
    public void run() {
        try {
            myService.awaitB();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

    public static void main(String[] args) throws IOException, InterruptedException {

        MyService myService = new MyService();

        ThreadA threadA = new ThreadA(myService);
        threadA.setName("a");
        threadA.start();

        ThreadB threadB = new ThreadB(myService);
        threadB.setName("b");
        threadB.start();

        Thread.sleep(3000);
        myService.signalAll_A();

    }

• In the Object class The wait() method is equivalent to the await() method in the Condition class.
• The wait(long timeout) method in the Object class is equivalent to the await(long time, TimeUnit unit) method in the Condition class.
• The notify() method in the Object class is equivalent to the signal() method in the Condition class.
• The notifyAll() method in the Object class is equivalent to the signalAll() method in the Condition class.

Judging from the execution results, threads a and b are suspended. When the myService.signalAll_A() method is executed, thread a continues to execute, while thread b is still in a waiting state.

Common methods

ReentrantLock Class

int getHoldCount() Query the number of times the lock() method is called.

final int getQueueLength() Estimate the number of threads waiting for the lock. For example, there are 5 threads , 1 thread first executes the await() method, then the return value after calling this method is 4, indicating that 4 threads are waiting for the lock to be released at the same time.

int getWaitQueueLength(Condition condition) returns this lock An estimate of the number of threads waiting for a given condition. For example, if there are 5 threads, and each thread executes the await() method of the same condition object, the value returned when calling this method is 5.

final boolean hasQueuedThreads() Determines whether there are threads waiting for this lock.

final boolean hasQueuedThread(Thread thread) Determines whether the specified thread is waiting to acquire this lock.

boolean hasWaiters(Condition condition) Determines the thread Have you called the await() method.

void lockInterruptibly() throws InterruptedException to acquire the lock, unless the current thread is interrupted.

Condition class

void awaitUninterruptibly() and await( ) The difference is that the InterrputedException exception will not be thrown when the interrupt() method is called.

This article is all over here. For more other exciting content, you can pay attention to the Java video on the PHP Chinese website Tutorial column!

The above is the detailed content of Introduction to the usage of ReentrantLock class in. For more information, please follow other related articles on the PHP Chinese website!