经典的生产者消费者问题

最新推荐文章于 2024-07-18 14:16:46 发布

努力的阳光蓝孩

最新推荐文章于 2024-07-18 14:16:46 发布

阅读量395

点赞数

CC 4.0 BY-SA版权

分类专栏： 0702【java线程、并发】

本文链接：https://blog.youkuaiyun.com/qq_40996741/article/details/105884290

0702【java线程、并发】专栏收录该内容

13 篇文章

订阅专栏

本文探讨了多线程环境下生产者消费者问题的解决策略，通过synchronized关键字和Lock接口实现线程安全，确保共享资源的正确操作及线程间的有效通信。

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

1、使用 synchronized

package com.zenlayer.javabasis.test.thread;

/**
 * @author haoxiansheng
 * @date 2020-04-26
 */
public class ProductorTest {

    // 生产者消费者问题

    /**
     * 分析
     * 1、是否为多线程问题  生产者线程 、消费者线程
     * 2、是否有共享数据？ 产品数量
     * 3、如何处理线程的安全问题 同步机制：三种 方法 代码块 lock
     * 4、是否涉及线程通信 wait() notify() sleep() notifyAll()
     */
    public static void main(String[] args) {
        Clerk clerk = new Clerk();

        Producer producer = new Producer(clerk);
        producer.setName("生产者一");
        producer.start();

        Consumer consumer = new Consumer(clerk);
        consumer.setName("消费者一");
        consumer.start();
    }
}

class Clerk {
    private int productCount = 0;

    // 生产产品
    public synchronized void produceProduct() {
        if (productCount < 20) {
            productCount++;
            System.out.println(Thread.currentThread().getName() + "开始生产第" + productCount + "个产品");


            notify(); //唤醒对方消费
        } else {
            try {
                wait(); //等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    // 消费产品
    public synchronized void consumerProduct() {
        if (productCount > 0) {
            System.out.println(Thread.currentThread().getName() + "开始消费第" + productCount + "个产品");
            productCount--;

            notify(); //唤醒对方生产
        } else {
            try {
                wait(); //等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

/**
 * 生产者
 */
class Producer extends Thread {
    private Clerk clerk;

    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(getName() + "开始生产产品");
        while (true) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.produceProduct();
        }
    }
}

/**
 * 消费者
 */
class Consumer extends Thread {
    private Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(getName() + "开始消费产品");
        while (true) {
            try {
                Thread.sleep(110);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.consumerProduct();
        }
    }
}

2、使用lock

package com.example.juc;

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

/**
 * @author haoxiansheng
 */
public class ProductorTest {

    // 生产者消费者问题

    /**
     * 分析
     * 1、是否为多线程问题  生产者线程 、消费者线程
     * 2、是否有共享数据？ 产品数量
     * 3、如何处理线程的安全问题 同步机制：三种 方法 代码块 lock
     * 4、是否涉及线程通信 wait() notify() sleep() notifyAll()
     */
    public static void main(String[] args) {
        Clerk clerk = new Clerk();

        Producer producer = new Producer(clerk);
        producer.setName("生产者一");
        producer.start();

        Consumer consumer = new Consumer(clerk);
        consumer.setName("消费者一");
        consumer.start();
    }
}

class Clerk {
    private int productCount = 0;
    
    private Lock lock = new ReentrantLock();
    
    private Condition condition = lock.newCondition();

    // 生产产品
    public  void produceProduct() {
        lock.lock();
        try {
            if (productCount < 20) {
                productCount++;
                System.out.println(Thread.currentThread().getName() + "开始生产第" + productCount + "个产品");

                condition.signalAll(); //唤醒
            } else {
                try {
                    condition.await(); //等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } finally {
            lock.unlock();
        }

    }

    // 消费产品
    public  void consumerProduct() {
        lock.lock();
        try {
            if (productCount > 0) {
                System.out.println(Thread.currentThread().getName() + "开始消费第" + productCount + "个产品");
                productCount--;

                condition.signalAll(); //唤醒对方生产

            } else {
                try {
                    condition.await(); //等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } finally {
            lock.unlock();
        }

    }
}

/**
 * 生产者
 */
class Producer extends Thread {
    private Clerk clerk;

    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(getName() + "开始生产产品");
        while (true) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.produceProduct();
        }
    }
}

/**
 * 消费者
 */
class Consumer extends Thread {
    private Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(getName() + "开始消费产品");
        while (true) {
            try {
                Thread.sleep(110);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.consumerProduct();
        }
    }
}