Java ：ReentrantLock类和Condition类

最新推荐文章于 2023-10-19 11:41:53 发布

AlgebraFly

最新推荐文章于 2023-10-19 11:41:53 发布

阅读量486

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/AlgebraFly/article/details/125520546

版权

java 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

锁机制之ReentrantLock

简单概念

可重入锁，Java自己实现的锁，继承了Lock类，有两种构造。

锁：在同一时间点只能被一个线程所持有
可重入：锁可以被已经占有它的线程多次获取

ReentrantLock在同一个时间点只能被一个线程获取(当某线程获取到“锁”时，其它线程就必须等待)；ReentraantLock是通过一个FIFO的等待队列来管理获取该锁所有线程的。在“公平锁”的机制下，线程依次排队获取锁；而“非公平锁”在锁是可获取状态时，不管自己是不是在队列的开头都会获取锁。

比较synchronized

相同: ReentrantLock提供了synchronized类似的功能和内存语义。

不同

[1]与synchronized相比，ReentrantLock提供了更多，更加全面的功能，具备更强的扩展性。例如：时间锁等候，可中断锁等候，锁投票。
[2]ReentrantLock还提供了条件Condition，对线程的等待、唤醒操作更加详细和灵活，所以在多个条件变量和高度竞争锁的地方，ReentrantLock更加适合（下面会阐述Condition）。
[3]ReentrantLock提供了可轮询的锁请求。它会尝试着去获取锁，如果成功则继续，否则可以等到下次运行时处理，而synchronized则一旦进入锁请求要么成功，要么一直阻塞，所以相比synchronized而言，ReentrantLock会不容易产生死锁些。
[4]ReentrantLock支持更加灵活的同步代码块，但是使用synchronized时，只能在同一个synchronized块结构中获取和释放。注：ReentrantLock的锁释放一定要在finally中处理，否则可能会产生严重的后果。
[5]ReentrantLock支持中断处理，且性能较synchronized会好些。

重入

有一个与锁相关的获取计数器，如果拥有锁的某个线程再次得到锁，那么获取计数器就加1，然后锁需要被释放两次才能获得真正释放。

线程再次获取锁：锁需要去识别获取锁的线程是否为当前占据锁的线程，如果是，则再次成功获取。
锁的最终释放：线程重复n次获取了锁，随后在n次释放该锁后，其他线程能够获取该锁。锁的最终释放要求锁对于获取进行计数自增，计数表示当前锁被重复获取的次数，而锁被释放时，计数自减，当计数等于0时表示锁已经释放。

公平/非公平锁

通过构造方法实现，默认非公平锁。且非公平锁性能高于公平锁性能。

如果获取一个锁是按照请求的顺序得到的，那么就是公平锁，否则就是非公平锁，允许线程插队。

公平锁表示线程获取锁的顺序是按照线程加锁的顺序来分配的，即先来先得的FIFO先进先出顺序。而非公平锁就是一种获取锁的抢占机制，是随机获得锁的，和公平锁不一样的就是先来的不一定先得到锁，这个方式可能造成某些线程一直拿不到锁，结果也就是不公平的了。

tryLock方法

实现可轮询的锁请求：仅在调用时锁为空闲状态才获取该锁。如果锁可用，则获取锁，并立即返回值true。如果锁不可用，则此方法将立即返回值false。
实现可定时的锁请求：如果活动在期待的时间内没能获得结果，定时锁能使程序提前返回。可定时的锁获取模式，由tryLock(long, TimeUnit)方法实现。

示例

// 简单示例
public class ReentrantLockThread implements Runnable {

    ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        lock.lock();
        try {
            for (int i = 0; i < 3; i++) {
                System.out.println(Thread.currentThread().getName() + "输出：" + i);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    
    public static void main(String[] args) {
        ReentrantLockThread thread1 = new ReentrantLockThread();
        new Thread(thread1, "a").start();
        new Thread(thread1, "b").start();
    }
    
}

// 锁的重入
public class TestRetryLock {

    ReentrantLock lock = null;

    public TestRetryLock() {
        lock = new ReentrantLock();
    }

    public static void main(String[] args) {
        TestRetryLock retryLock = new TestRetryLock();
        try {
            retryLock.testReentry(1);
            // 能执行到这里而不阻塞，表示锁可重入
            retryLock.testReentry(2);
            retryLock.testReentry(3);

        } finally {
            // 释放重入测试的锁，要按重入的数量解锁，否则其他线程无法获取该锁。
            retryLock.getLock().unlock();
            retryLock.getLock().unlock();
            retryLock.getLock().unlock();
        }
    }
    public ReentrantLock getLock() {
        return lock;
    }
    public void testReentry(int count) {
        lock.lock();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
        System.out.println(sdf.format(new Date()) + " " + Thread.currentThread().getName()
                + " get lock. " + count);
    }
}

// 公平和非公平锁
public class LockService {

    private ReentrantLock lock;

    public LockService(boolean fair){
        lock = new ReentrantLock(fair);
    }

    public void serviceMethod() {
        lock.lock();
        try {
            System.out.println("ThreadName=" + Thread.currentThread().getName() + " 获得锁定");
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        LockService lockService = new LockService(true);
        Runnable runnable = () -> {
            System.out.println("**线程： " + Thread.currentThread().getName() + " 运行了 ");
            lockService.serviceMethod();
        };
        for (int i = 0; i < 10; i++) {
            new Thread(runnable).start();
        }
    }
    
}

Condition

简单概念

Condition类能实现synchronized和wait、notify搭配的功能，另外比后者更灵活，Condition可以实现多路通知功能，也就是在一个Lock对象里可以创建多个Condition（即对象监视器）实例，线程对象可以注册在指定的Condition中，从而可以有选择的进行线程通知，在调度线程上更加灵活。而synchronized就相当于整个Lock对象中只有一个单一的Condition对象，所有的线程都注册在这个对象上。线程开始notifyAll时，需要通知所有的WAITING线程，没有选择权，会有相当大的效率问题。

Condition是个接口，基本的方法就是await()和signal()方法。
Condition依赖于Lock接口，生成一个Condition的基本代码是lock.newCondition()
调用Condition的await()和signal()方法，都必须在lock保护之内，就是说必须在lock.lock()和lock.unlock之间才可以使用。
Conditon中的await()对应Object的wait()，Condition中的signal()对应Object的notify()，Condition中的signalAll()对应Object的notifyAll()。
condition是跟着线程来的，即一个线程可以拥有一个condition，而不是一个ReentrantLock拥有一个condition

示例

// 简单示例
public class ConditionService {

    // 实例化一个ReentrantLock对象
    private ReentrantLock lock = new ReentrantLock();
    // 为线程A注册一个Condition
    public Condition conditionA = lock.newCondition();
    // 为线程B注册一个Condition
    public Condition conditionB = lock.newCondition();
    
    public void awaitA() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "进入了awaitA方法");
            long timeBefore = System.currentTimeMillis();
            // 执行conditionA等待
            conditionA.await();
            long timeAfter = System.currentTimeMillis();

            System.out.println(Thread.currentThread().getName() + "被唤醒");
            System.out.println(Thread.currentThread().getName() + "等待了: " + (timeAfter - timeBefore) / 1000 + "s");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void awaitB() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "进入了awaitB方法");
            long timeBefore = System.currentTimeMillis();
            // 执行conditionA等待
            conditionB.await();
            long timeAfter = System.currentTimeMillis();

            System.out.println(Thread.currentThread().getName() + "被唤醒");
            System.out.println(Thread.currentThread().getName() + "等待了: " + (timeAfter - timeBefore) / 1000 + "s");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void signallA() {
        lock.lock();
        try {
            System.out.println("启动唤醒程序");
            // 唤醒所有注册conditionA的线程
            conditionA.signalAll();
        } finally {
            lock.unlock();
        }
    }

    public void signallB() {
        lock.lock();
        try {
            System.out.println("启动唤醒程序");
            // 唤醒所有注册conditionB的线程
            conditionB.signalAll();
        } finally {
            lock.unlock();
        }
    }
    
}

public static void main(String[] args) throws InterruptedException {
    ConditionService conditionService = new ConditionService();
    new Thread(() -> conditionService.awaitA(), "A").start();
    new Thread(() -> conditionService.awaitB(), "B").start();

    Thread.sleep(2000);
    // 唤醒持有ConditionA的线程
    conditionService.signallA();

    Thread.sleep(2000);
    // 唤醒持有ConditionB的线程
    conditionService.signallB();
}

// 生产者消费者模式
public class SomethingFactory {

    /**
     * 工厂最大库存容量
     */
    public static final int MAX_SIZE = 10;
    private int currentNumber = 0;

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


    public void produce(int needNum) {
        lock.lock();
        try {
            while (currentNumber + needNum > MAX_SIZE) {
                System.out.println("要生产的产品数量" + needNum + "超过剩余库存量" + (MAX_SIZE - currentNumber) + "，暂时不能执行生产任务!");
                condition.await();
            }

            System.out.println(Thread.currentThread().getName() + "---生产商品---");
            currentNumber += needNum;
            System.out.println("已经生产了" + needNum + "个产品，现仓储量为" + currentNumber);

            // 通知消费者
            condition.signalAll();
        } catch (Exception e) {

        } finally {
            lock.unlock();
        }

    }

    public void consume(int needNum) {
        lock.lock();
        try {
            while (currentNumber < needNum) {
                System.out.println("要消费的产品数量" + needNum + "超过剩余库存量" + (currentNumber) + "，暂时不能执行消费任务!");
                condition.await();
            }

            System.out.println(Thread.currentThread().getName() + "---消费商品---");
            currentNumber -= needNum;
            System.out.println("已经消费了" + needNum + "个产品，现仓储量为" + currentNumber);

            // 提醒生产者生产
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

public static void main(String[] args) {

    SomethingFactory factory = new SomethingFactory();

    new Thread(() -> {
        int count = 0;
        while (count++ < 5) {
            factory.consume(1);
        }
    }, "consumer-A").start();

    new Thread(() -> {
        int count = 0;
        while (count++ < 5) {
            factory.produce(1);
        }
    }, "producer").start();

    new Thread(() -> {
        int count = 0;
        while (count++ < 5) {
            factory.consume(1);
        }
    }, "consumer-B").start();

}