java并发学习23：ReentrantLock介绍使用

最新推荐文章于 2025-06-23 15:51:33 发布

八十岁老将

最新推荐文章于 2025-06-23 15:51:33 发布

阅读量143

点赞数

CC 4.0 BY-SA版权

分类专栏： # java并发编程文章标签：多线程 java

本文链接：https://blog.youkuaiyun.com/qq_43464558/article/details/113245602

java并发编程专栏收录该内容

35 篇文章

订阅专栏

本文深入探讨了ReentrantLock锁的特点及使用方式，包括其相对于synchronized的优势如可中断、超时支持、公平锁选项以及对多个条件变量的支持，并通过实例说明了如何实现可重入、打断、超时等功能。

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

1、与synchronized相比

可中断
可以设置超时时间
可以设置为公平锁
支持多个条件变量

与synchronized一样，都支持可重入

基本语法：

// 获取锁
reentrantLock.lock();
try {
    // 临界区
} finally {
    // 释放锁
    reentrantLock.unlock();
}

2、可重入

可重入是指同一个线程如果首次获得了这把锁，那么因为它是这把锁的拥有者，因此有权利再次获取这把锁

如果是不可重入锁，那么第二次获得锁时，自己也会被锁挡住

static ReentrantLock lock = new ReentrantLock();
public static void main(String[] args) {
    method1();
}
public static void method1() {
    lock.lock();
    try {
        log.debug("execute method1");
        method2();  
    } finally {
        lock.unlock();   
    }
}
public static void method2() {
    lock.lock();
    try {
        log.debug("execute method2");
        method3();    
    } finally {
        lock.unlock(); 
    }
}
public static void method3() {
    lock.lock();
    try {
        log.debug("execute method3"); 
    } finally {
        lock.unlock(); 
    }
}

3、可打断

lock.lockInterruptibly();//获取锁，同时可以被其他线程打断

static ReentrantLock lock = new ReentrantLock();
public static void main(String[] args) {
    new Thread(() -> {
       method1();  
    },"t1")
}
public static void method1() {
    //如果没有竞争那么方法就会获取lock对象锁
    //如果没有竞争就进入阻塞队列，可以被其他线程用interrupt 方法打断
    lock.lockInterruptibly();
    try {
        log.debug("execute method1");
        method2();  
    } finally {
        lock.unlock();   
    }
}

4、锁超时

4.1 立刻失败

ReentrantLock lock = new ReentrantLock();
Thread t1 = new Thread(() -> {
    log.debug("启动...");
    if (!lock.tryLock()) {
        log.debug("获取立刻失败，返回");
        return;  
    }
    try {
        log.debug("获得了锁"); 
    } finally {
        lock.unlock();
    }
}, "t1");
lock.lock();
log.debug("获得了锁")

4.2 超时失败

ReentrantLock lock = new ReentrantLock();
Thread t1 = new Thread(() -> {
    log.debug("启动...");
    try {
        if (!lock.tryLock(1, TimeUnit.SECONDS)) {
            log.debug("获取等待 1s 后失败，返回");
            return;       
        }   
    } catch (InterruptedExceptione) {
        e.printStackTrace(); 
    }
    try {
        log.debug("获得了锁");   
    } finally {
        lock.unlock();
    }
}, "t1");
lock.lock();
log.debug("获得了锁");
t1.start();
try {
    sleep(2);
} finally {
    lock.unlock();
}

4.3tryLock解决哲学家问题

class Chopstick extends ReentrantLock {
    String name;
    public Chopstick(Stringname) {
        this.name=name;   
    }
    @Override
    public String toString() {
        return"筷子{"+name+'}';    
    }
}

class Philosopher extends Thread {
	Chopstick left;
    Chopstick right;
    public Philosopher(Stringname, Chopstickleft, Chopstickright) {
	super(name);
        this.left=left;
        this.right=right;  
    }
    
    @Override
    public void run() {
        while (true) {
            // 尝试获得左手筷子
            if (left.tryLock()) {
                try {
                    // 尝试获得右手筷子
                    if (right.tryLock()) {
                        try {
                            eat();  
                        } finally {
                            right.unlock();  
                        }              
                    }         
                } finally {
                    left.unlock();     
                }      
            }    
        }  
    }
    
    private void eat() {
        log.debug("eating...");
        Sleeper.sleep(1);   
    }
}