java线程（三）：线程设计模型—生产者和消费者

╰+攻爆jí腚メ 2022-09-22 11:58 253阅读 0赞

## 生产者-消费者-仓库模型是在程序设计中一个比较经典的问题。问题描述如下： ##

## 生产者-消费者问题是一个经典的进程同步问题，该问题最早由Dijkstra提出，用以演示他提出的信号量机制。 他要求设计在同一个进程地址空间内执行的两个线程。 生产者线程生产物品，然后将物品放置在一个空缓冲区中供消费者线程消费。 消费者线程从缓冲区中获得物品，然后释放缓冲区。 当生产者线程生产物品时，如果没有空缓冲区可用，那么生产者线程必须等待消费者线程释放出一个空缓冲区。 当消费者线程消费物品时，如果没有满的缓冲区，那么消费者线程将被阻塞，直到新的物品被生产出来。 ##

## 说到底需要做的就是在线程同步的基础上，设计监视器、对生产者线程以及消费者线程进行同步。监视器就是问题中的仓库。下面就根据实际背景并应用消费者-生产者模型解决。 ##

## **问题背景**： ##

## 创建一个实现火车站卖火车票的类，注意在该类中不能出现多次卖同一张票，或者某一张票没卖的情况。 ##

## 将以上转化为消费者-生产者模型是：售票台对应生产者，买票人对应消费者、仓库是存放火车票的容器。 ##

## 下面是实现生产者与消费者线程同步的程序： ##

public class Tickets implements Runnable {
        
        int tickets = 4;
        public void run() {
            while (true) {
                synchronized (this) {                            
                    if (tickets > 0) {
                        System.out.println("顾客到达"
                                + Thread.currentThread().getName() + "售票台");
                        System.out.println("售票台" + Thread.currentThread().getName()
                                + "准备买第" + tickets + "张票");
                        try {
                            System.out.println("售票台需要五分钟处理卖票");
                            for (int i = 1; i <= 5; i++) {
                                Thread.sleep(5);
                                System.out.print(i + "分钟");
                            }
                            System.out.println("\n售票台"
                                    + Thread.currentThread().getName() + "买完第"
                                    + tickets + "张票");
                            System.out.println("顾客从"
                                    + Thread.currentThread().getName() + "售票台买到票");
                            --tickets;
                        } catch (InterruptedException e) {
                            System.err.println("买票不成功");
                            System.exit(1);
                        }
                    }
                }
            }
        }
    }

## 上面程序中初始ticket=4，对同步块进行加锁。在同步块中分别输出生产者与消费者相关信息以及当前tickets数量，tickets相当于监视器，当tickets>0才会运行同步块。其余的就是在main方法里面创建线程即可。 ##

## 下面再来看这个完整例子： ##

//创建一个汉堡包盒子的类
    ///totalmaterial是指所有的能作汉堡包的材料
    ///box是一个监视器对象
    ///sales是指销售了多少个汉堡包
    ///production是指总共有多少个汉堡包
    class ham13                                       //把装汉堡包的盒子作为监视器类
    {
        static Object box=new Object();
        static int totalmaterial=10;
        static int sales=0;
        static int production=5;
    }
    class hmaker13 extends Thread                      //厨师线程类
    {
        public void make()
        {
            synchronized(ham13.box)
            {
                (ham13.production)++;
                try
                {
                    ham13.box.notify();
                }
                catch(Exception e){}
            } 
        }
        public void run()
        {
            while(ham13.production<ham13.totalmaterial)
            {      
                if(ham13.production>0) 
                {
                    System.out.println("厨师"+getName()+":"+"汉堡来了(总共"+(ham13.production-ham13.sales)+"个)");
                } 
                try 
                { 
                    sleep(3000);
                } 
                catch(Exception e){}
                make(); 
            } 
         } 
    }
    ///这是一个营业员的线程类
    ///sell函数是营业员卖汉堡包的方法
    ///run方法就是线程需要运行的内容
    ///使用条件判断语句来判断汉堡包盒子里面是否还有汉堡包
    ///在run方法内使用循环语句来使得营业员在盒子里面有汉堡包里有汉堡包的情况下不断的卖
    class hassistant13 extends Thread 
    {
        public void sell()
        {
            if(ham13.production==0)
            {
                System.out.println("营业员：顾客朋友们，请稍微等一下,汉堡没了!!");
            }
            try 
            { 
                ham13.box.wait();
            } 
            catch(Exception e){} 
            ham13.sales++; 
            System.out.println("营业员：顾客好，汉堡上来了，（总共卖了"+ham13.sales+"个）"); 
        }
        public void run()
        { 
            while(ham13.sales<ham13.production)
            { 
                try 
                { 
                    sleep(1000); 
                } 
                catch(Exception e){} 
                sell(); 
            } 
        } 
    } 
    public class thread13 
    {
         
        public static void main(String[] args) 
        { 
            hmaker13 maker=new hmaker13(); 
            hassistant13 assistant=new hassistant13(); 
            maker.setName("甲"); 
            maker.start(); 
            assistant.start(); 
        }
    }

## 以上示例代码来自《零基础学java》（常建功 第3版） ##

## 线程设计生产者—消费者模型还能在GUI界面设计中发挥着重大的作用。总之很多问题都能转化为生产者—消费者模型，是线程中重要的部分。 ##

## **关于死锁问题** ##

## 另外在使用线程同步和生产者-消费者模型时一定要防死锁。因为一旦死锁，线程都都得不到锁，这样程序就没法执行了。 ##

## 所谓死锁： 是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。(来自百度百科)。 ##

## **死锁是因为多线程访问共享资源，由于访问的顺序不当所造成的**，通常是一个线程锁定了一个资源A，而又想去锁定资源B；在另一个线程中，锁定了资源B，而又想去锁定资源A以完成自身的操作，两个线程都想得到对方的资源，而不愿释放自己的资源，造成两个线程都在等待，而无法执行的情况。 ##

## 在设计中应该合理设计线程访问共享资源的顺序，避免死锁情况发生。 ##