线程 ---- 锁(生产者、消费者)

Java经典面试题 -----  生产者消费者

/**
 * 生产者 消费者问题
 * 解释 : wait notify 方法
 * sleep 与 wait的区别
 * 线程锁机制
 */
public class ProducerConsumer {
    public static void main(String[] args) {
        SyncStack ss = new SyncStack();
        Producer p = new Producer(ss);
        Consumer c = new Consumer(ss);

        new Thread(p).start();
        new Thread(c).start();
    }
}

class MT{
    int id ;
    MT(int id){
        this.id = id;
    }

    public String toString(){
        return "MT:" + id;
    }
}

class SyncStack {
    int index = 0 ;
    MT[] mts = new MT[6];

    public synchronized void push (MT mt){
        if(index == mts.length){
            try {
                this.wait();
            }catch(InterruptedException ex){
                ex.printStackTrace();
            }
        }
        this.notify();
        mts[index] = mt;
        index ++;
    }

    public synchronized MT pop(){
        if(index == 0){
            try {
                this.wait();
            }catch(InterruptedException ex){
                ex.printStackTrace();
            }
        }
        this.notify();
        index -- ;
        return mts[index];
    }
}

class Producer implements Runnable{
    SyncStack stack = null;

    public Producer(SyncStack stack) {
        this.stack = stack;
    }
    public void run(){
        for(int i = 0 ; i < 20 ; i ++){
            MT mt = new MT(i);
            stack.push(mt);
            System.out.println("生产了:" + mt);
            try{
                Thread.sleep((int)(Math.random()*200));
            }catch(InterruptedException ex){
                ex.printStackTrace();
            }
        }
    }
}

class Consumer implements Runnable{

    SyncStack stack = null;

    public Consumer(SyncStack stack) {
        this.stack = stack;
    }

    public void run(){
        for(int i = 0 ; i < 20 ; i ++){
            MT mt = stack.pop();
            System.out.println("消费了:" + mt);
            try{
                Thread.sleep((int)(Math.random()*1000));
            }catch(InterruptedException ex){
                ex.printStackTrace();
            }
        }
    }
}
时间: 2024-10-12 21:14:30

线程 ---- 锁(生产者、消费者)的相关文章

Java多线程-同步:synchronized 和线程通信:生产者消费者模式

大家伙周末愉快,小乐又来给大家献上技术大餐.上次是说到了Java多线程的创建和状态|乐字节,接下来,我们再来接着说Java多线程-同步:synchronized 和线程通信:生产者消费者模式. 一.同步:synchronized 多个线程同时访问一个对象,可能造成非线程安全,数据可能错误,所谓同步:就是控制多个线程同时访就是控制多线程操作同一个对象时,注意是同一个对象,数据的准确性, 确保数据安全,但是加入同步后因为需要等待,所以效率相对低下. 如:一个苹果,自己一个人去咬怎么都不会出问题,但是

JAVA并发编程6_线程协作/生产者-消费者

前面通过同步锁来同步任务的行为,两个任务在交替访问共享资源的时候,可以通过使用同步锁使得任何时候只有一个任务可以访问该资源,见博客:线程同步之synchronized关键字.下面主要讲的是如何使任务彼此间可以协作,使得多个任务可以一起工作去解决木某个问题,因为有些问题中,某些部分必须在其他部分被解决之前解决,就像在餐厅服务员要端菜就必须有厨师做好了菜.在任务协作时,可以让任务自身挂起,直至某些外部条件发生变化,表示是时候让这个任务向前推动了为止. wait/notify wait方法会在等待外部

线程的生产者消费者问题

package xiancheng;/** * wait() 等待 ,释放锁 sleep 不释放锁 * @author User * */ public class lianxi20 { //t 生产者生产 通知消费 f 消费者消费 通知生产 private boolean flag=true; //模拟生产的物品 private String picString; //生产 public synchronized void play(String picString){ //当flag为fal

jdk线程的生产者消费者问题

同步代码块实现生产者消费者模式 class Person { private String name; private String sex; private Boolean isEmpty = Boolean.TRUE; // 表示存储区域是否为空 //生产 public void set(String name, String sex) { synchronized (this) { // if(isEmpty) while (!isEmpty.equals(Boolean.TRUE)) {

线程同步-生产者消费者问题

在进行多线程编程时,难免还要碰到两个问题,那就线程间的互斥与同步: 线程同步是指线程之间所具有的一种制约关系,一个线程的执行依赖另一个线程的消息,当它没有得到另一个线程的消息时应等待,直到消息到达时才被唤醒. 线程互斥是指对于共享的进程系统资源,在各单个线程访问时的排它性.当有若干个线程都要使用某一共享资源时,任何时刻最多只允许一个线程去使用,其它要使用该资源的线程必须等待,直到占用资源者释放该资源.线程互斥可以看成是一种特殊的线程同步(下文统称为同步). 生产者消费者问题就是一个著名的线程同步

Java线程通信-生产者消费者问题

线程通信示例--生产者消费者问题 这类问题描述了一种情况,假设仓库中只能存放一件产品,生产者将生产出来的产品放入仓库,消费者将仓库中的产品取走消费.假设仓库中没有产品,则生产者可以将 产品放入仓库,有产品,则停止生产并等待,直到仓库中的产品被消费这取走为止. 如果仓库中放油产品,则消费者可以将产品取走消费,否则停止消费并等待,直到 仓库中再次放入产品为止. 显然,这是一个同步问题,生产者和消费这共享同一资源, 并且生产者和消费这之间彼此依赖,互为条件向前推进.Java提供了3个方法解决了线程间的

线程协作---生产者消费者模式之“管程法”实现

1 package cn.ftf.threadcooperation; 2 /** 3 * 协作模型:生产者消费者模式实现方式一:管程法,借助一个缓冲区 4 * @author 房廷飞 5 * 6 */ 7 8 public class CoTest01 { 9 public static void main(String[] args) { 10 SyContainer sy=new SyContainer(); 11 Productor pro=new Productor(sy); 12 p

python基础 信号量 semaphore evevt 线程queue 生产者消费者模型

线程锁相当于同时只能有一个线程申请锁,有的场景无数据修改互斥要求可以同时让多个线程同时运行,且需要限制并发线程数量时可以使用信号量 1 import threading, time, queue 2 3 def test(name): 4 semaphore.acquire() #获取信号量锁 5 print('my name is %s' %name) 6 time.sleep(1) 7 semaphore.release() #释放信号量锁 8 9 semaphore = threading

Java 线程池 +生产者消费者+MySQL读取300 万条数据

1.1需求 数据库300 万条用户数据 ,遍历获取所有用户, 各种组合关联, 获取到一个新的json ,存到redis 上. 1.2 难点 数据库比较多, 不可能单线程查询所有的数据到内存. 1.3解决办法 多线程读取, 生产者 每次获取200 条数据, 消费者去消费.(这里 主要是根据MySQL分页去获取下一个200 条数据) 1.4 代码 1.4.1 调用方法 /** * 线程启动 */ public void update() { //redis操作类 HashRedisUtil redi

java线程之生产者消费者

看了毕向东老师的生产者消费者,就照着视频参考运行了一下,感觉还好 这个值得学习的是条理特别清晰: ProducterConsumerDemo.java中,一个资源类Resources,生产者消费者都可以访问的到. 生产者类Producter,消费者Consumer都实现了Runnable接口,在其中的run方法中实现重载,对共享资源进行生产和消费 优化: 如果以后需要加入项目中,对ProducterConsumerDemo类中加一个构造方法,public ProducterConsumerDem