资讯

精准传达 • 有效沟通

从品牌网站建设到网络营销策划，从策略到执行的一站式服务

网站建设 >

查看其它板块

Java中Lock锁与生产者消费者问题有哪些

小编给大家分享一下Java介绍Lock锁与生产者消费者问题，相信大部分人都还不怎么了解，因此分享这篇文章给大家参考一下，希望大家阅读完这篇文章后大有收获，下面让我们一起去了解一下吧！

在蒙城等地区，都构建了全面的区域性战略布局，加强发展的系统性、市场前瞻性、产品创新能力，以专注、极致的服务理念，为客户提供成都做网站、网站设计、外贸营销网站建设 网站设计制作定制网站制作,公司网站建设,企业网站建设,成都品牌网站建设,成都全网营销,外贸网站建设,蒙城网站建设费用合理。

Lock锁与生产者消费者问题

  • 传统Synchronized锁

  • Lock锁

  • Synchronized和lock锁的区别

  • 传统的生产者和消费者问题

  • Lock版的生产者和消费者问题

  • Condition实现精准通知唤醒

传统Synchronized锁

实现一个基本的售票例子：

/*
真正的多线程开发，公司中的开发,降低耦合性
线程就是一个单独的资源类，没有任何附属的操作
1.属性，方法
 * */public class SaleTicketDemo1 {
    public static void main(String[] args) {
        //并发，多个线程操作同一个资源类,把资源类丢入线程
        Ticket ticket=new Ticket();
        //Runnable借口是一个FunationalInterface函数式接口，接口可以new,jdk1.8以后，lamda表达式()->{代码}
        new Thread(()->{
            for(int i=0;i<60;i++){
                ticket.sale();
            }
        },"A").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<60;i++){
                    ticket.sale();
                }
            }
        },"B").start();
        new Thread(()->{
            for(int i=0;i<60;i++){
                ticket.sale();
            }
        },"C").start();
    }}//资源类 OOPclass Ticket{
    //属性，方法
    private int number=50;
    //卖票的方式
    //synchronized本质：队列，所
    public synchronized void sale(){
        if(number>0){
            System.out.println(Thread.currentThread().getName()+"卖出了"+(number--)+"票,剩余"+number);
        }
    }}

注意，这里面用到了lambda表达式，lambda表达式详细描述见Java基础-Lambda表达式

Java中Lock锁与生产者消费者问题有哪些
这是使用传统的synchronized实现并发，synchronized的本质就是队列，锁。就好比食堂排队。如果没有排队，就会很乱。只有给一个人服务完成了，另一个人才能接收到服务。

Lock锁

之前已经说道，JVM提供了synchronized关键字来实现对变量的同步访问以及用wait和notify来实现线程间通信。在jdk1.5以后，JAVA提供了Lock类来实现和synchronized一样的功能，并且还提供了Condition来显示线程间通信。
Lock类是Java类来提供的功能，丰富的api使得Lock类的同步功能比synchronized的同步更强大。
在java.util. Concurrent包中，里面有3个接口，Condition，lock(标准锁)。ReadWriteLock锁（读写锁）
Lock实现提供比使用synchronized方法和语句可以获得的更广泛的锁定操作。 它们允许更灵活的结构化，可能具有完全不同的属性，并且可以支持多个相关联的对象Condition。

Lock l = ...; l.lock(); try { // access the resource protected by this lock } finally { l.unlock(); }

lock()表示加锁，unlock()表示解锁
JDK官方文档中解释
Java中Lock锁与生产者消费者问题有哪些
所有已知实现类：
ReentrantLock可重入锁
ReentrantReadWriteLock.ReadLock 读锁
ReentrantReadWriteLock.writeLock写锁

先说ReentrantLock实现类：
ReentrantLock底层源码构造函数
Java中Lock锁与生产者消费者问题有哪些
公平锁：十分公平，可以先来后到。但是问题如果一个3s和一个3h的进程到达，3h先，那么3s等3h，实际上也不利。
非公平锁：十分不公平，可以插队（默认）
之后，我们会具体解释。

怎么用，用之前加锁，用之后解锁

//lock锁三部曲
//1.new ReentranLock();构造
//2.Lock.lock();加锁
//3.finally();解锁

public class SaleTicketDemo2 {
	public static void main(String[] args) {
		//并发，多个线程操作同一个资源类,把资源类丢入线程
		Ticket ticket=new Ticket();
		//Runnable借口是一个FunationalInterface函数式接口，接口可以new,jdk1.8以后，lamda表达式()->{代码}
		new Thread(()->{for(int i=0;i<60;i++)ticket.sale();},"A").start();
		new Thread(()->{for(int i=0;i<60;i++)ticket.sale();},"B").start();
		new Thread(()->{for(int i=0;i<60;i++)ticket.sale();},"C").start();
	}}//资源类 OOP//lock锁三部曲//1.new ReentranLock();//2.Lock.lock();加锁//3.finally();解锁class Ticket2{
	//属性，方法
	private int number=50;
	//卖票的方式
	//synchronized本质：队列，所
	Lock lock=new ReentrantLock();
	
	public void sale(){
		lock.lock();
		try {
			//业务代码
			if(number>0){
				System.out.println(Thread.currentThread().getName()+"卖出了"+(number--)+"票,剩余"+number);
			}
		} catch (Exception e) {
			// TODO: handle exception
		}finally{
			lock.unlock();
		}	
	}}

Synchronized和lock锁的区别

1.synchronized是内置的java关键字，lock是一个Java类
2.synchronized无法判断获取锁的状态，lock可以判断是否获取到了锁
3.synchronized会自动释放锁(a–),lock必须要手动释放锁！如果不释放锁，会导致死锁
4.Synchronized线程1（获得锁，阻塞），线程2（等待，傻傻的等）
lock.tryLock()尝试获取锁，不一定会一直等待下去
5.Synchronized可重入锁，不可以中断的，非公平锁。Lock,可重入锁，可以判断锁，公平与非公平可以自己设置（可以自己设置）
6.synchronized适合少量的代码同步问题，lock锁适合锁大量的同步代码
synchornized锁对象和同步代码块方法

传统的生产者和消费者问题

传统的生产者和消费者是基于Object类的wait、notify方法和synchronized关键字来实现的。
在面试的时候，手写生产者消费者代码是很常见的事情。
面试笔试经典问题：
单例模式+排序算法+生产者消费者+死锁
生产者消费者问题synchronized版

线程之间的通信问题：生产者和消费者问题 等待唤醒，通知唤醒
线程交替执行 A B 操作同一个变量number=0
A num+1
B num-1
注意：加锁的方法中，执行的思路是判断等待+业务+通知

package testConcurrent;/*
线程之间的通信问题：生产者和消费者问题    等待唤醒，通知唤醒
线程交替执行 A B 操作同一个变量number=0
A num+1
B num-1

 * */public class A {
	public static void main(String[] args) {
		Data data =new Data();
		new Thread(()->{
			for(int i=0;i<10;i++){
				try {
					data.increment();
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		},"A").start();
		new Thread(()->{
			for(int i=0;i<10;i++){
				try {
					data.decrement();
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		},"B").start();	
	}}//判断等待+业务+通知class Data{		//数字。资源类
	private int number=0;
	
	//+1。多线程的情况下一定要加锁。
	public synchronized void increment() throws InterruptedException{
		//判断是否需要等待，如果不需要，就需要干活进行业务操作
		if(number!=0){			//等于1的时候，需要等待，缓冲区只有1个空位置
			//等待操作
			this.wait();
		}
		number++;		//进行业务操作
		System.out.println(Thread.currentThread().getName()+"=>"+number);
		//通知其他线程，我+1完毕了
		this.notify();
	}
	//-1
	public synchronized void decrement() throws InterruptedException{
		if(number==0){
			//等待
			this.wait();
		}
		number--;
		System.out.println(Thread.currentThread().getName()+"=>"+number);
		//通知其他线程，我-1完毕了
		this.notify();
	}}

Java中Lock锁与生产者消费者问题有哪些
如图，基本可以实现所要求的功能，但是这样还会出现问题，如果此时我再加上了两个线程，则

		new Thread(()->{
			for(int i=0;i<10;i++){
				try {
					data.increment();
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		},"C").start();
		new Thread(()->{
			for(int i=0;i<10;i++){
				try {
					data.decrement();
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		},"D").start();

Java中Lock锁与生产者消费者问题有哪些
这里结果中出现了2，输出结果出现了问题。为什么呢？
为什么if判断会出现问题：
if判断只判断一次。因为if判断了之后，就已经进入了代码的等待那一行，这时，在wait下的线程可能有多个，甚至包括生产者和消费者。有可能某个生产者执行完了之后，唤醒的是另一个生产者。

在我们的官方文档中就给出了解释

public final void wait(long timeout)
                throws InterruptedException

导致当前线程等待，直到另一个线程调用此对象的notify()方法或notifyAll()方法，或指定的时间已过。
线程也可以唤醒，而不会被通知，中断或超时，即所谓的虚假唤醒 。 虽然这在实践中很少会发生，但应用程序必须通过测试应该使线程被唤醒的条件来防范，并且如果条件不满足则继续等待。 换句话说，等待应该总是出现在循环中，就像这样：

 synchronized (obj) {
         while ()
             obj.wait(timeout);
         ... // Perform action appropriate to condition
     }

注意点：防止虚假唤醒问题。
我们代码中用的是if判断，而应该用while判断

package testConcurrent;/*
线程之间的通信问题：生产者和消费者问题    等待唤醒，通知唤醒
线程交替执行 A B 操作同一个变量number=0
A num+1
B num-1

 * */public class A {
    public static void main(String[] args) {
        Data data =new Data();
        new Thread(()->{
            for(int i=0;i<10;i++){
                try {
                    data.increment();
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for(int i=0;i<10;i++){
                try {
                    data.decrement();
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for(int i=0;i<10;i++){
                try {
                    data.increment();
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        },"C").start();
        new Thread(()->{
            for(int i=0;i<10;i++){
                try {
                    data.decrement();
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        },"D").start();
        
    }}//判断等待+业务+通知class Data{     //数字。资源类
    private int number=0;
    
    //+1
    public synchronized void increment() throws InterruptedException{
        //判断是否需要等待，如果不需要，就需要干活进行业务操作
        while(number!=0){           //等于1的时候，需要等待，缓冲区只有1个空位置
            //等待操作
            this.wait();
        }
        number++;       //进行业务操作
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，我+1完毕了
        this.notify();
    }
    //-1
    public synchronized void decrement() throws InterruptedException{
        while(number==0){
            //等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，我-1完毕了
        this.notify();
    }}

Lock版的生产者和消费者问题

在synchronized版本中，我们使用了wait和notify来实现线程之间的同步
在lock中，
此时synchronized被lock替换了，那么wait和notify用什么来替换呢？
我们在官方文档java.util.concurrent.locks 中，找到Lock类，然后在底部找到了
Condition newCondition()
返回一个新Condition绑定到该实例Lock实例。
在等待条件之前，锁必须由当前线程保持。 呼叫Condition.await()将在等待之前将原子释放锁，并在等待返回之前重新获取锁。
然后我们再来了解Condition类
Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set（wait-set）。其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。
一个Condition实例本质上绑定到一个锁。 要获得特定Condition实例的Condition实例，请使用其newCondition()方法。

Java中Lock锁与生产者消费者问题有哪些
我们可以看到，使用的时候new一个Condition对象。然后用await替代wait,signal替换notify
代码实现
//判断等待+业务+通知

class Data2{		//数字。资源类
	private int number=0;
	Lock lock=new ReentrantLock();
	Condition condition=lock.newCondition();
	//+1
	public void increment() throws InterruptedException{
		try {
			lock.lock();
			//业务代码
			while(number!=0){		
				//等待
				condition.await();
			}
			number++;		
			System.out.println(Thread.currentThread().getName()+"=>"+number);
			condition.signalAll();		//通知
		} catch (Exception e) {
			// TODO: handle exception
		}finally{
			lock.unlock();
		}
	}
	//-1
	public void decrement() throws InterruptedException{
		try {
			lock.lock();
			//业务代码
			while(number!=1){		
				//等待
				condition.await();
			}
			number--;		
			System.out.println(Thread.currentThread().getName()+"=>"+number);
			condition.signalAll();		//通知
		} catch (Exception e) {
			// TODO: handle exception
		}finally{
			lock.unlock();
		}
	}	}

注意：主函数部分于最上面的代码一样。

Java中Lock锁与生产者消费者问题有哪些
这时候虽然说是正确的，但是它是一个随机分布的状态，现在我们希望它有序执行，即A执行完了执行B，B执行C，C完了执行D。即精准通知。

Condition实现精准通知唤醒

Condition实现精准的通知和唤醒
我们构造三个线程，要求A执行完了执行B，B执行完了执行C，C执行完了执行D.
代码思想：
//加多个监视器，通过监视器来判断唤醒的是哪一个人
//设置多个同步监视器，每个监视器监视一个线程
//实例：生产线，下单->支付->交易->物流

package testConcurrent;import java.util.concurrent.locks.Condition;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;/*
A执行完调用B,B执行完调用C，C执行完调用A
 * */public class C {

    public static void main(String[] args) {
        Data3 data=new Data3();
        new Thread(()->{
            for(int i=0;i<10;i++){
                data.printA();
            }
        },"A").start();
        new Thread(()->{
            for(int i=0;i<10;i++){
                data.printB();
            }
        },"B").start();
        new Thread(()->{
            for(int i=0;i<10;i++){
                data.printC();
            }
        },"C").start();
    }}class Data3{    //资源类
    private Lock lock=new ReentrantLock();
    //加多个监视器，通过监视器来判断唤醒的是哪一个人
    //设置多个同步监视器，每个监视器监视一个线程
    //实例：生产线，下单->支付->交易->物流
    private Condition condition1=lock.newCondition();
    private Condition condition2=lock.newCondition();
    private Condition condition3=lock.newCondition();
    private int number=1;       //1A 2B 3C
    public void printA(){
        lock.lock();
        try {
            //业务，判断->执行->通知
            while(number!=1){
                //等待
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>AAAAAAA");
            //唤醒，唤醒指定的人，B
            number=2;           //精准唤醒
            condition2.signal();
            
        } catch (Exception e) {
            // TODO: handle exception
        }finally{
            lock.unlock();
        }
    }   
    public void printB(){
        lock.lock();
        try {
            //业务，判断->执行->通知
            while(number!=2){
                //等待
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>BBBBBBB");
            //唤醒，唤醒指定的人，C
            number=3;           //精准唤醒
            condition3.signal();
            
        } catch (Exception e) {
            // TODO: handle exception
        }finally{
            lock.unlock();
        }
    }
    public void printC(){
        lock.lock();
        try {
            //业务，判断->执行->通知
            while(number!=3){
                //等待
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>CCCCCCC");
            //唤醒，唤醒指定的人，A
            number=1;           //精准唤醒
            condition1.signal();
            
        } catch (Exception e) {
            // TODO: handle exception
        }finally{
            lock.unlock();
        }
    }}

以上是“Java介绍Lock锁与生产者消费者问题”这篇文章的所有内容，感谢各位的阅读！相信大家都有了一定的了解，希望分享的内容对大家有所帮助，如果还想学习更多知识，欢迎关注创新互联行业资讯频道！


网页名称：Java中Lock锁与生产者消费者问题有哪些
网站URL：http://www.cdkjz.cn/article/jhside.html
返回首页 了解更多建站资讯

相关资讯

多年建站经验

多一份参考，总有益处

联系快上网，免费获得专属《策划方案》及报价

咨询相关问题或预约面谈，可以通过以下方式与我们联系

大客户专线   成都：13518219792   座机：028-86922220

在线咨询 提交需求
友情链接 交换友情链接
四川艺考培训成都气球装饰企业网站建设成都模板网站成都小程序开发成都商城开发营销网站建设网站空间泽君科技成都网站推广

成都网站建设公司地址：成都市青羊区太升南路288号锦天国际A座10层 建设咨询028-86922220

成都快上网科技有限公司-四川网站建设设计公司 | 蜀ICP备19037934号 Copyright 2020,ALL Rights Reserved cdkjz.cn | 成都网站建设 | © Copyright 2020版权所有.

专家团队为您提供成都网站建设,成都网站设计,成都品牌网站设计,成都营销型网站制作等服务,成都建网站就找快上网！ | 成都网站建设哪家好？ | 网站建设地图