java利用lock和unlock实现消费者与生产者问题(多线程)

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockAndUnlockDemo {

    public static void main(String[] args) {
        Clerk2 c=new Clerk2();
        Thread t=new Thread(new Producer2(c));
        Thread t1=new Thread(new Consumer2(c));
        t.start();
        t1.start();
    }

}
class Clerk2{
    private int product=0;//生产者生产的数量给店员
    private Lock lock = new ReentrantLock();
    private Condition condition_pro = lock.newCondition();
    private Condition condition_con = lock.newCondition();
    
    public void addproduct(){
        lock.lock();
        try {
            if(this.product>5){
                try {
                    condition_con.await();
                } catch (InterruptedException e) {
                    
                    e.printStackTrace();
                }
            }else{
                product++;
                System.out.println("生产了第"+product+"个商品");
                condition_con.signal();
            }
        }finally {
            lock.unlock();
        }
    }
    public void getproduct(){
        lock.lock();
        try {
            if(this.product<=0){
                try {
                    condition_con.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            else{
                System.out.println("消费者买走了第"+product+"个商品");
                product--;
                condition_pro.signal();
            }
        } finally {
            lock.unlock();
        }
        
    }
}
class Producer2 implements Runnable{
    private Clerk2 clerk;
    
    public Producer2(Clerk2 clerk) {
        super();
        this.clerk = clerk;
    }

    public void run() {
        System.out.println("开始生产商品");
        while(true){
            try {
                Thread.sleep((int)(Math.random()*10)*1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            clerk.addproduct();
        }
        
    }
    
}
class Consumer2 implements Runnable{
    private Clerk2 clerk;
    
    public Consumer2(Clerk2 clerk) {
        super();
        this.clerk = clerk;
    }

    public void run() {
        System.out.println("消费者买走商品");
        while(true){
            try {
                Thread.sleep((int)(Math.random()*10)*1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            clerk.getproduct();
        }
        
    }
    
}
时间: 2024-10-25 18:19:46

java利用lock和unlock实现消费者与生产者问题(多线程)的相关文章

Java中lock上锁 unlock解锁

代码很简单,本宝宝就直接上代码了,请喷吧! /** *jdk1.5之后出现了lock,创建锁不那么繁琐,调用lock上锁 unlock解锁,更加面向对象 */public class LockTest { public static void main(String[] args) { //运用内部类的方法实现runnable new Thread( new Runnable() { @Override public void run(){ //调用out方法中的print方法 out pOut

通过消费者和生产者的多线程程序,了解Java的wait()和notify()用法

仓库类 public class Store { private int size = 0;//当前容量 private final int MAX = 10;//最大容量 //向仓库中增加货物 public synchronized void add() { while(size >= MAX)//每次执行都要检查是否已满 { try { wait();//如果满了,进入等待池等待 } catch (InterruptedException e) { e.printStackTrace();

消费者与生产者(多线程)

1 /** 2 * 要求:假定有10个消费者去消费生产的产品, 产品要保证顺序被其他任意消费者消费,上一个消费完了下一个才能消费 3 * 4 * @author trfizeng 5 * 6 */ 7 public class SCThread { 8 public static void main(String[] args) { 9 System.out.println("begin:" + (System.currentTimeMillis()) / 1000); 10 for

JAVA基础再回首(二十五)——Lock锁的使用、死锁问题、多线程生产者和消费者、线程池、匿名内部类使用多线程、定时器、面试题

JAVA基础再回首(二十五)--Lock锁的使用.死锁问题.多线程生产者和消费者.线程池.匿名内部类使用多线程.定时器.面试题 版权声明:转载必须注明本文转自程序员杜鹏程的博客:http://blog.csdn.net/m366917 我们来继续学习多线程 Lock锁的使用 虽然我们可以理解同步代码块和同步方法的锁对象问题,但是我们并没有直接看到在哪里加上了锁,在哪里释放了锁,为了更清晰的表达如何加锁和释放锁,JDK5以后提供了一个新的锁对象Lock Lock void lock():获取锁 v

“全栈2019”Java多线程第二十七章:Lock获取lock/释放unlock锁

难度 初级 学习时间 10分钟 适合人群 零基础 开发语言 Java 开发环境 JDK v11 IntelliJ IDEA v2018.3 文章原文链接 "全栈2019"Java多线程第二十七章:Lock获取lock/释放unlock锁 下一章 "全栈2019"Java多线程第二十八章:公平锁与非公平锁详解 学习小组 加入同步学习小组,共同交流与进步. 方式一:关注头条号Gorhaf,私信"Java学习小组". 方式二:关注公众号Gorhaf,回

JAVA——利用wait和notify实现生产者和消费者

经典的消费者和生产者的的实现: 注意事项: 1:在循环里面用wait(),因为当线程获得了锁,但是有可能还没有满足其他条件: 2:公用的缓冲池要用锁机制: 1 package demo; 2 3 import java.util.Vector; 4 5 public class Main { 6 7 public static void main(String[] args) { 8 Vector<Integer> pool=new Vector<Integer>(); 9 Pro

&lt;Java&gt;&lt;Multi-thread&gt;&lt;Lock interface&gt;

Overview 介绍java的lock interface. Motivation java拥有像synchronized这样的内置锁,那为什么还需要lock这样的外置锁呢? 首先,性能不是选择synchronized或lock的原因,因为jdk6中synchronized的性能已经和lock相差不大. 一般,选择lock是基于lock拥有的以下几个优点(内置锁不具备): 当获取锁时可以有一个等待时间,不会无期限等待下去: 当获取不到锁时,能够响应中断: 可以在多读少写的应用场景中,提高性能:

ReentrantLock解析,lock与unlock方法分析

介绍ReentrantLock之前,先介绍下背景知识,也就是要用到的知识点.这些知识点包括:比较并交换CAS(Compare And Swap ).ReentrantLock的类结构(其父类,内部类等). 声明: 我主要是通过一种通俗的语言进行内容的总结,帮助大家更好的理解,记忆,更容易去理解书上的讲解.对于一些专业的陈述,大家还是需要去看书. 1.CAS 举例说明.对于如下类 public class Blog { private int count; public int getCount(

深入java并发Lock一

java有像syncronized这样的内置锁,但为什么还需要lock这样的外置锁? 性能并不是选择syncronized或者lock的原因,jdk6中syncronized的性能已经与lock相差不大. 如果要选择lock的话,会基于lock拥有的几个优点(内置锁所不具备): 1.如果希望当获取锁时,有一个等待时间,不会无限期等待下去. 2.希望当获取不到锁时,能够响应中断 3.当读多,写少的应用时,希望提高性能 4.获取不到锁时,立即返回false.获取到锁时返回true. lock接口定义