【Java多线程编程核心技术】第四章 Lock的使用

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了【Java多线程编程核心技术】第四章 Lock的使用，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含2715字，纯文字阅读大概需要4分钟。

内容图文

使用ReentrantLock类

Lock lock = new ReentrantLock();
lock.lock();
//同步的代码段
...
lock.unlock();

Condition用法:await(), signal()方法调用之前需要调用lock.lock()获得同步监视器

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

try{
    lock.lock();
    ...
    condition.await();
} catch (...) {
    ...
} finally {
    lock.unlock();
}

try{
    lock.lock();
    ...
    condition.signal();
} finally {
    lock.unlock();
}

使用Condition实现通知部分线程

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

//唤醒所有被conditionA.await()等待的线程
conditionA.await(); --> conditionA.signalAll()；

//唤醒所有被conditionB.await()等待的线程
conditionB.await(); --> conditionB.signalAll()

使用Lock与Condition模拟生产者与消费者

class Service {
    private Lock lock = new ReentrantLock();
    //生产者与消费者使用两个Condition对象
    private Condition conditionPro = lock.newCondition();
    private Condition conditionCon = lock.newCondition();
    private int count = 0;

    public void produce() {
        try {
            //获取锁
            lock.lock();

            //循环生成
            while (true) {
                //使用while循环判断count值
                while (count > 5) {
                    //使生产者等待
                    conditionPro.await();
                }
               /*
                *    // 不能使用 if 对 count 值进行判断
                *    if (count > 5){
                *        conditionPro.await();
                *    }
                *    //使用if后，该生产者会暂时被等待，但可能被其它线程通知
                *    //然后，会继续执行对count的操作
                */
                
                //此处count最大值可达到6
                count++;
                System.out.println("produce---" + count);
                //生产者产生一个值后，count值此时一定 >= 1，可通知消费者
                conditionCon.signalAll();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //释放锁
            lock.unlock();
        }
    }

    public void consume() {
        try {
            lock.lock();
            while (true) {
                while (count < 1) {
                    conditionCon.await();
                }
                count--;
                System.out.println("consume---" + count);
                conditionPro.signalAll();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

class Producer extends Thread {
    private Service service;

    Producer(Service service) {
        this.service = service;
    }

    @Override
    public void run() {
        service.produce();
    }
}

class Consumer extends Thread {
    private Service service;

    Consumer(Service service) {
        this.service = service;
    }

    @Override
    public void run() {
        service.consume();
    }
}

公平锁：获取锁的顺序是按照线程加锁的顺序来分配，即FIFO

非公平锁：随机获得锁，该方式可能造成某些线程一直拿不到锁，结果也就是不公平的了

 public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

读写锁ReentrantReadWriteLock的使用

该锁有两个锁，一个是读操作相关的锁，也称共享锁；一个是写操作相关的锁，也叫排他锁。

多个读锁间不互斥，读锁与写锁互斥，写锁与写锁互斥。

多个线程可以同时进行读操作，但同一时刻只允许一个线程进行写操作

ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

lock.readLock().lock();
...
lock.readLock().lock();

内容总结

以上是互联网集市为您收集整理的【Java多线程编程核心技术】第四章 Lock的使用全部内容，希望文章能够帮你解决【Java多线程编程核心技术】第四章 Lock的使用所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端