ReentrantLock重入锁和ReentrantReadWriteLock读写分离锁

最新推荐文章于 2022-07-29 16:47:09 发布

最新推荐文章于 2022-07-29 16:47:09 发布 · 823 阅读

文章标签：

#并发

1====>Java 专栏收录该内容

85 篇文章

订阅专栏

本文通过具体示例介绍了如何使用ReentrantLock和ReentrantReadWriteLock来实现线程间的同步与互斥，展示了重入锁结合Condition的灵活性以及读写锁在读多写少场景下的高效应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、重入锁
示例：重入锁+Condition实现灵活多变得同步编程
package com.锁;

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

public class ReentrantLockTest {

ReentrantLock lock = new ReentrantLock();
Condition condition1 = lock.newCondition();
Condition condition2 = lock.newCondition();

public void method1(){
    try{
        lock.lock();
        System.out.println("进入到method1");
        Thread.sleep(3000);
        System.out.println("释放锁method1");
        condition1.await();
        System.out.println("退出到method1");
    }catch(InterruptedException e){

    }finally{
        lock.unlock();
    }

}

public void method2(){
    try{
        lock.lock();
        System.out.println("进入到method2");
        Thread.sleep(3000);
        System.out.println("释放锁method2");
        condition1.await();
        System.out.println("退出到method2");
    }catch(InterruptedException e){

    }finally{
        lock.unlock();
    }

}

public void method3(){
    try{
        lock.lock();
        System.out.println("进入到method3");
        System.out.println("释放锁method3");
        Thread.sleep(3000);
        condition2.await();
        System.out.println("退出到method3");

    }catch(InterruptedException e){

    }finally{
        lock.unlock();
    }

}

public void method4(){
    try{
        lock.lock();
        System.out.println("进入到method4");
        Thread.sleep(3000);
        System.out.println("退出到method4");
        condition1.signalAll();
    }catch(InterruptedException e){

    }finally{
        lock.unlock();
    }

}

public void method5(){
    try{
        lock.lock();
        System.out.println("进入到method5");
        Thread.sleep(3000);
        System.out.println("退出到method5");
        condition2.signal();
    }catch(InterruptedException e){

    }finally{
        lock.unlock();
    }

}

public static void main(String[] args) throws InterruptedException {
    final ReentrantLockTest rt = new ReentrantLockTest();
    new Thread(new Runnable() {

        public void run() {
            rt.method1();
        }
    },"t1").start();

    new Thread(new Runnable() {

        public void run() {
            rt.method2();
        }
    },"t2").start();

    new Thread(new Runnable() {

        public void run() {
            rt.method3();
        }
    },"t3").start();

    new Thread(new Runnable() {

        public void run() {
            rt.method4();
        }
    },"t4").start();

    new Thread(new Runnable() {

        public void run() {
            rt.method5();
        }
    },"t5").start();


}

}

二、ReentrantReadWriteLock读写分离锁

package com.锁;

import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;

/*
* 读写锁：实现读写分离，读读共享，读写互斥，写写互斥
* 读写锁适用于读多写少的情况，性能远高于重入锁ReentrantLock
* */
public class RWLock {

private ReentrantReadWriteLock readwritelock = new ReentrantReadWriteLock();

//初始化读锁和写锁，这样才能体现读锁和写锁的分离
private ReadLock readLock = readwritelock.readLock();
private WriteLock writeLock = readwritelock.writeLock();

public void method1(){
    try{
        readLock.lock();
        System.out.println("进入到method1");
        Thread.sleep(3000);
        System.out.println("退出到method1");
    }catch(InterruptedException e){

    }finally{
        readLock.unlock();
    }
}

public void method2(){
    try{
        readLock.lock();
        System.out.println("进入到method2");
        Thread.sleep(3000);
        System.out.println("退出到method2");
    }catch(InterruptedException e){

    }finally{
        readLock.unlock();
    }
}

public void method3(){
    try{
        writeLock.lock();
        System.out.println("进入到method3");
        Thread.sleep(3000);
        System.out.println("退出到method3");
    }catch(InterruptedException e){

    }finally{
        writeLock.unlock();
    }
}

public static void main(String[] args) {

    final RWLock rw = new RWLock();

    Thread t1 = new Thread(new Runnable() {

        public void run() {
            rw.method1();
        }
    });

    Thread t2 = new Thread(new Runnable() {

                public void run() {
                    rw.method2();
                }
    });

    Thread t3 = new Thread(new Runnable() {

        public void run() {
            rw.method3();
        }
    });

    //t1和t2线程是读读共享
//  t1.start();
//  t2.start();

    //t1和t3是读写互斥
    t1.start();
    t3.start();

}

}