concurrent(2)—lock和condition

本文详细解析了Java并发编程中Lock接口与Condition接口的概念及其使用方法,对比了它们与synchronized关键字的区别,并通过生产者消费者模式的示例展示了如何使用Lock与Condition实现线程间的协作。

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

Lock和Condition只是concurrent中的两个接口,但基于这两个接口实现的类完成了先前由synchronized和object共同实现的方法。 
但就生产者消费者来说(参考生产者与消费者),Lock相当于synchronized而Condition的await()和signal()方法相当于Object的wait()和notify()方法。 
在讲解Lock和Condition之前,先要弄清synchronized的本质:

synchronized(Object o)代码块实际上获得了对象o的锁才会继续执行里面的方法,而对象o的锁只有一把,因此针对某一个对象o的synchronized代码块只能串行执行。

其实往深了就是锁,既然是锁,那么我们肯定可以直接使用锁的方法来完成synchronized的功能。

Condition是在java 1.5中才出现的,它用来替代传统的Object的wait()、notify()实现线程间的协作,相比使用Object的wait()、notify(),使用Condition1的await()、signal()这种方式实现线程间协作更加安全和高效。简单说,他的作用是使得某些线程一起等待某个条件(Condition),只有当该条件具备(signal 或者 signalAll方法被调用)时,这些等待线程才会被唤醒,从而重新争夺锁。

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()。

Lock

上面说道,使用Lock代替synchronized,那么Lock接口到底有哪些作用呢? 
总的来说,Lock可以完全替换synchronized,并在此基础上提供了更多的功能。

 
其源码如下:

public interface Lock {
    /**
    * 当前线程获取lock的锁,如果获取不到,则当前线程就暂停
    * 相当于synchronized(lock)方法
    */
    void lock();

    //获取锁,相当于lock(),但可以被打断
    void lockInterruptibly() throws InterruptedException;

    /** 
    * 非阻塞式的获取锁,如果获取不到就返回false,该方法不会导致当前的阻塞
    * 对于tryLock(),常见的方法是:
    * Lock lock = ...;
    * if (lock.tryLock()) {
    *     try {
    *         // manipulate protected state
    *     } finally {
    *         lock.unlock();
    *     }
    * } else {
    *     // perform alternative actions
    * }
    */
    boolean tryLock();

    //同tryLock()
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

    //释放锁,正如上面的例子,该方法一般在finally方法中
    void unlock();

    /*
    * 返回和该锁对应的Condition对象。
    * 方法本身很难理解,需要对照例子和Condition源码
    * 实际上相当于和synchronized(Object o)对应的o
    */
    Condition newCondition();

以上是Lock的源码,Lock基本实现了互斥锁,但单独的Lock是无法实现条件获取,即调用lock()方法时没有指定条件,因此单独的lock无法实现生产者消费者功能,而条件获取锁还需要另外通过Condition来辅助完成。

Condition

Condition将Object的wait()和notify()方法独立了出来,直接看看Condition的源码:

public interface Condition {
    /**
    * 使得当前线程等待
    * 类似于Object.wait()方法
    * 该等待可以被打断
    */
    void await() throws InterruptedException;

    /*
    * 同样是等待,但该方法不会被打断
    * 不管是await()还是awaitUninterruptibly(),在调用时都需要
    * 已经获得和Condition相关的锁
    * 而调用await()或者awaitUninterruptibly()后则自动释放锁
    * 而在从await()执行完毕,方法返回时则需要再次获取锁
    */
    void awaitUninterruptibly();

    long awaitNanos(long nanosTimeout) throws InterruptedException;

    boolean await(long time, TimeUnit unit) throws InterruptedException;

    boolean awaitUntil(Date deadline) throws InterruptedException;

    /**
    * 唤醒一个等待的线程
    * 相当于Object.notify()方法
    */
    void signal();

    //相当于Object.notifyAll()方法
    void signalAll();

通过分析Condition的源码,发现Condition确实就是相当于Object的wait()和notify()方法的替代。 
但这里有一个问题,我们在上一篇博客分析了。 
synchronized(Object o) 和o.wait()配合使用,其中o起着中间承接的作用,那么对于Condition和Lock,这两如何配合起来呢?其实就是通过Lock的newCondition()方法来承接的,即Condition c = lock.newCondition()。

Java并行编程-lock中使用多条件condition(生产者消费者模式实例)

Java 并发包下的提供Lock,Lock相对于Synchronized可以更好的解决线程同步问题,更加的灵活和高效,并且ReadWriteLock锁还能实现读、写的分离。但线程间仅仅互斥是不够的,还需要通信,本篇的内容是基于上篇之上,使用Lock如何处理线程通信。阻塞队列(BlockingQueue)就是使用condition的和lock实现的。可以查看:Java并发编程-阻塞队列(BlockingQueue)的实现原理

Condition 
那么引入本篇的主角,Condition,Condition 将 Object的通信方法(wait、notify 和 notifyAll)分解成截然不同的对象,以便通过将这些对象与任意 Lock 实现组合使用,为每个对象提供多个等待 set (wait-set)。其中,Lock 替代了 synchronized 方法和语句的使用,Condition 替代了 Object 通信方法的使用。

在Condition中,用await()替换wait(),用signal()替换notify(),用signalAll()替换notifyAll(),传统线程的通信方式,Condition都可以实现,这里注意,Condition是被绑定到Lock上的,要创建一个Lock的Condition必须用newCondition()方法。

Condition的强大之处在于它可以为多个线程间建立不同的Condition, 使用synchronized/wait()只有一个阻塞队列,notifyAll会唤起所有阻塞队列下的线程,而使用lock/condition,可以实现多个阻塞队列,signalAll只会唤起某个阻塞队列下的阻塞线程。

下面用两种方式编写生产者/消费者模式代码加以说明。

- 使用synchronized/wait()实现生产者消费者模式如下:

    //模拟生产和消费的对象
    class Buffer {
        private int maxSize;
        private List<Date> storage;
        Buffer(int size){
            maxSize=size;
            storage=new LinkedList<>();
        }
        //生产方法
        public synchronized void put()  {
            try {
                while (storage.size() ==maxSize ){//如果队列满了
                    System.out.print(Thread.currentThread().getName()+": wait \n");;
                    wait();//阻塞线程
                }
                storage.add(new Date());
                System.out.print(Thread.currentThread().getName()+": put:"+storage.size()+ "\n");
                Thread.sleep(1000);
                notifyAll();//唤起线程
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }       
        }
        //消费方法
        public synchronized void take() {
            try { 
                while (storage.size() ==0 ){//如果队列满了
                    System.out.print(Thread.currentThread().getName()+": wait \n");;
                    wait();//阻塞线程
                }
                Date d=((LinkedList<Date>)storage).poll();
                System.out.print(Thread.currentThread().getName()+": take:"+storage.size()+ "\n");
                Thread.sleep(1000);
                notifyAll();//唤起线程
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }       
        } 
}
//生产者
class Producer implements Runnable{
    private Buffer buffer;
    Producer(Buffer b){
        buffer=b;
    }
    @Override
    public void run() {
        while(true){
            buffer.put();
        }
    }   
}
//消费者
class Consumer implements Runnable{
    private Buffer buffer;
    Consumer(Buffer b){
        buffer=b;
    }
    @Override
    public void run() {
        while(true){
            buffer.take();
        }
    }   
}
//
public class Main{
    public static void main(String[] arg){
        Buffer buffer=new Buffer(10);
        Producer producer=new Producer(buffer);
        Consumer consumer=new Consumer(buffer);
        //创建线程执行生产和消费
        for(int i=0;i<3;i++){
            new Thread(producer,"producer-"+i).start();
        }
        for(int i=0;i<3;i++){
            new Thread(consumer,"consumer-"+i).start();
        }
    }
}

- 使用lock/condition实现生产者消费者模式如下:

import java.util.Date;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


class Buffer {
    private  final Lock lock;
    private  final Condition notFull;
    private  final Condition notEmpty;
    private int maxSize;
    private List<Date> storage;
    Buffer(int size){
        //使用锁lock,并且创建两个condition,相当于两个阻塞队列
        lock=new ReentrantLock();
        notFull=lock.newCondition();
        notEmpty=lock.newCondition();
        maxSize=size;
        storage=new LinkedList<>();
    }
    public void put()  {
        lock.lock();
        try {   
            while (storage.size() ==maxSize ){//如果队列满了
                System.out.print(Thread.currentThread().getName()+": wait \n");;
                notFull.await();//阻塞生产线程
            }
            storage.add(new Date());
            System.out.print(Thread.currentThread().getName()+": put:"+storage.size()+ "\n");
            Thread.sleep(1000);         
            notEmpty.signalAll();//唤醒消费线程
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{   
            lock.unlock();
        }
    }

    public  void take() {       
        lock.lock();
        try {  
            while (storage.size() ==0 ){//如果队列满了
                System.out.print(Thread.currentThread().getName()+": wait \n");;
                notEmpty.await();//阻塞消费线程
            }
            Date d=((LinkedList<Date>)storage).poll();
            System.out.print(Thread.currentThread().getName()+": take:"+storage.size()+ "\n");
            Thread.sleep(1000);         
            notFull.signalAll();//唤醒生产线程

        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            lock.unlock();
        }
    } 
}

class Producer implements Runnable{
    private Buffer buffer;
    Producer(Buffer b){
        buffer=b;
    }
    @Override
    public void run() {
        while(true){
            buffer.put();
        }
    }   
}
class Consumer implements Runnable{
    private Buffer buffer;
    Consumer(Buffer b){
        buffer=b;
    }
    @Override
    public void run() {
        while(true){
            buffer.take();
        }
    }   
}
public class Main{
    public static void main(String[] arg){
        Buffer buffer=new Buffer(10);
        Producer producer=new Producer(buffer);
        Consumer consumer=new Consumer(buffer);
        for(int i=0;i<3;i++){
            new Thread(producer,"producer-"+i).start();
        }
        for(int i=0;i<3;i++){
            new Thread(consumer,"consumer-"+i).start();
        }
    }
}

 当生产者执行put方法时,调用notEmpty.signalAll()只会唤醒notEmpty.await()下的消费者线程。 
- 当消费者执行塔克方法时,调用notFull.signalAll()只会唤醒notFull.await()下的消费者线程。

转载于:https://blog.youkuaiyun.com/u012882134/article/details/78464546 

https://blog.youkuaiyun.com/chenchaofuck1/article/details/51592429

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值