Java多线程之生产者与消费者模式

Java多线程之生产者与消费者模式

synchronized版

问题:有2个线程,一个线程+1,一个线程-1,这样循环加减1,10次

public class ThreadWaitNotifyDemo {
    private int number = 0;

    //此方法实现对number+1操作
    public synchronized void increment() throws Exception{
        //此处一定要主要使用while判断,不能使用if判断,防止线程间的虚假唤醒
        while(number != 0){
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName() + "\t" + number);
        this.notifyAll();
    }

    //此方法实现对number-1操作
    public synchronized void decrement() throws InterruptedException{
        while(number == 0){
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName() + "\t" + number);
        this.notifyAll();
    }
}
class Main{
    public static void main(String[] args) {
        ThreadWaitNotifyDemo threadWaitNotifyDemo = new ThreadWaitNotifyDemo();
        new Thread(() ->{
            for (int i = 0; i < 10; i++) {
                try{
                    threadWaitNotifyDemo.increment();
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        },"AAA").start();

        new Thread(() ->{
            for (int i = 0; i < 10; i++) {
                try{
                    threadWaitNotifyDemo.decrement();
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        },"BBB").start();
    }
}
Lock版
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ThreadWaitNotifyDemo {
    private int number = 0;
    private Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    //此方法实现对number+1操作
    public void increment(){
        lock.lock();
        try{
            while(number != 0){
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName() + "\t" + number);
            condition.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    //此方法实现对number-1操作
    public void decrement(){
        lock.lock();
        try{
            while(number == 0){
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName() + "\t" + number);
            condition.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}
class Main{
    public static void main(String[] args) {
        ThreadWaitNotifyDemo threadWaitNotifyDemo = new ThreadWaitNotifyDemo();
        new Thread(() ->{
            for (int i = 0; i < 10; i++) {
                try{
                    threadWaitNotifyDemo.increment();
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        },"AAA").start();

        new Thread(() ->{
            for (int i = 0; i < 10; i++) {
                try{
                    threadWaitNotifyDemo.decrement();
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        },"BBB").start();
    }
}
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
多线程生产者消费者模式是一种常见的并发编程模式,用于解决生产者消费者之间的数据交互问题。在Java中,可以使用多线程和相关的同步机制来实现生产者消费者模式。 在这种模式中,生产者负责生成数据,并将数据放入共享的缓冲区中,而消费者则从缓冲区中取出数据进行处理。为了保证线程安全和避免竞态条件,需要使用锁或其他同步机制来控制对共享缓冲区的访问。 以下是一个简单的Java多线程生产者消费者的示例代码: ```java import java.util.LinkedList; class ProducerConsumer { private LinkedList<Integer> buffer = new LinkedList<>(); private int capacity = 10; public void produce() throws InterruptedException { int value = 0; while (true) { synchronized (this) { while (buffer.size() == capacity) { wait(); } System.out.println("Producer produced: " + value); buffer.add(value++); notify(); Thread.sleep(1000); } } } public void consume() throws InterruptedException { while (true) { synchronized (this) { while (buffer.isEmpty()) { wait(); } int value = buffer.removeFirst(); System.out.println("Consumer consumed: " + value); notify(); Thread.sleep(1000); } } } } public class Main { public static void main(String[] args) { ProducerConsumer pc = new ProducerConsumer(); Thread producerThread = new Thread(() -> { try { pc.produce(); } catch (InterruptedException e) { e.printStackTrace(); } }); Thread consumerThread = new Thread(() -> { try { pc.consume(); } catch (InterruptedException e) { e.printStackTrace(); } }); producerThread.start(); consumerThread.start(); } } ``` 上述代码中,ProducerConsumer类维护了一个缓冲区buffer和一个容量capacity。生产者通过调用produce方法向缓冲区中添加数据,消费者通过调用consume方法从缓冲区中取出数据。在生产者消费者的方法中,使用synchronized关键字来保证同一时间只有一个线程能够访问共享资源,并使用wait和notify方法来实现线程间的通信。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值