温馨提示×

温馨提示×

您好,登录后才能下订单哦!

密码登录×
登录注册×
其他方式登录
点击 登录注册 即表示同意《亿速云用户服务条款》

生产者-消费者问题详解

发布时间:2020-06-30 11:43:28 来源:网络 阅读:2436 作者:Adam的blog 栏目:开发技术

1. 前言

  生产者-消费者问题是经典的线程同步问题(我会用java和c分别实现),主要牵扯到三个点:
 一:能否互斥访问共享资源(不能同时访问共享数据);
 二:当公共容器满时,生产者能否继续生产(生产者应阻塞并唤醒消费者消费);
 三:当公共容器为空时,消费者能否继续消费(消费者应阻塞并唤醒生产者生产)。

2. JAVA实现

step0:在java中我们创建线程是通过继承Thread类或者继承Runnable接口并实现他的run方法来实现的,这里我们采用后者
step1:定义一个放馒头的大筐(一个公共的容器类),这个筐具有push方法和pop方法,分别对应往筐中放馒头和从筐中取出馒头。由于在同一个时间段内只能有一个线程访问此方法,so,我们给这两个方法加锁。代码如下:

class SyncStack{//定义放馒头的筐,是栈,先进后出
    int index = 0;//定义筐里面馒头的编号
    WoTou[] arrWT = new WoTou[6];//定义一个引用类型的数组

    public synchronized void push(WoTou wt){//定义往筐里放馒头的方法,由于需要保证在一段特定时间里只能有一个线程访问此方法,所以用synchronized关键字
        while(index == arrWT.length){
            try{
                this.wait();
            }catch(InterruptedException e){
                e.printStackTrace();
            }
        }
        this.notify();
        arrWT[index] = wt;
        index ++;
    }

    public synchronized WoTou pop(){//定义从筐里往外拿馒头的方法,同理在一段时间只能有一个线程访问此方法,所以用synchronized关键字
        while(index == 0){
            try{
                this.wait();//当前的正在我这个对象访问的这个线程wait
            }catch(InterruptedException e){
                e.printStackTrace();
            }
        }
        this.notify();//唤醒一个等待的线程,叫醒一个正在wait在我这个对象上的线程
        index --;
        return arrWT[index];
    }
}

step2:分别定义生产者和消费者的类,他们均是不同的线程。给出代码:

class Producer implements Runnable{//定义生产者这个类,是一个线程
    SyncStack ss = null;//声明了筐子的引用变量ss,表示做馒头的人往那个筐里放馒头
    Producer(SyncStack ss){
        this.ss = ss;
    }

    public void run(){
        for(int i=0; i<20; i++){
            WoTou wt = new WoTou(i);//new出一个馒头,该馒头的编号为i
            ss.push(wt);//把第i个馒头放到筐中
            System.out.println(i);
            System.out.println("生产了:" + wt);    
            try{
                Thread.sleep((int)(Math.random() * 200));//每生产一个睡眠1s
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

class Consumer implements Runnable{//定义消费者这个类,也是一个线程
    SyncStack ss = null;//声明了筐子的引用变量ss,表示吃馒头的人往那个筐里拿馒头
    Consumer(SyncStack ss){
        this.ss = ss;
    }

    public void run(){
        for(int i=0; i<20; i++){
            WoTou wt = ss.pop();//取出一个馒头
            System.out.println("消费了:" + wt);//开始吃馒头

            try{
                Thread.sleep((int)(Math.random() * 1000));
                //每消费一个睡眠1s
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

step3:我们事先定义了一个馒头类,现在给出测试类测试:

/*
wait和sleep的区别
    -1:sleep不需要唤醒,线程不会释放对象锁,属于Thread类
    -2:wait需要notify()方法唤醒,线程会放弃对象锁,属于Object类
*/
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 WoTou{//定义馒头这个类
    int id;//定义馒头的编号
    WoTou(int id){
        this.id = id;
    }
    public String toString(){//重写toString方法
        return "WoTou:" + id;
    }
}

step4:看下测试结果,发现符合我们事先说的那三点:
生产者-消费者问题详解

3. C实现

step0:c语言在Windows下实现线程的需要导入#include<process.h>头文件,用_beginthread();来开始一个线程,用_endthread();来结束一个线程。具体操作方法,自行百度。
step1:C语言中缓冲区对应公共容器,我们通过定义互斥信号量mutex来实现线程对缓冲池的互斥访问。直接看下代码操作:

#include<stdio.h>
#include<process.h>
#define N 10

//代表执行生产和消费的变量 
int in=0, out=0;

//线程结束的标志 
int flg_pro=0, flg_con=0;

//mutex:互斥信号量,实现线程对缓冲池的互斥访问;
//empty和full:资源信号量,分别表示缓冲池中空缓冲池和满缓冲池的数量(注意初值,从生产者的角度) 
int mutex=1, empty=N, full=0;

//打印测试 
void print(char c){
    printf("%c    一共生产了%d个窝头,消费了%d个窝头,现在有%d个窝头\n", c, in, out, full);
}

//请求某个资源 
void wait(int *x){
    while((*x)<=0);
    (*x)--;
}

//释放某个资源 
void signal(int *x){
    (*x)++;
} 

//生产者 
void produce(void *a){
    while(1){
//      printf("开始阻塞生产者\n"); 
        wait(&empty);   //申请一个缓冲区,看有无其他线程访问 
        wait(&mutex);
//      printf("结束阻塞生产者\n");

        in++;

        signal(&mutex);  
        signal(&full);  //full加一,唤醒消费者,告诉消费者可以消费 

//      printf("结束生产。。。\n");
        print('p');

        Sleep(200);
        if(flg_pro == 1){
            _endthread();
        }   
    } 
} 

//消费者
void consumer(void * a){
    while(1){
//      printf("开始阻塞消费者\n");
        wait(&full);
        wait(&mutex);
//      printf("结束阻塞消费者\n");

        out++;

        signal(&mutex);
        signal(&empty);
//      printf("结束消费。。。\n");
        print('c');

        Sleep(200);
        if(flg_con == 1){
            _endthread();   
        }
    }
} 

//主函数 
int main(){
    _beginthread(consumer,0,NULL);  
    _beginthread(produce,0,NULL);
    //总的执行时间为1分钟 
    Sleep(10000);
    flg_pro=flg_con=1;
    system("pause");
    return 0;
}

step2:注意事项:
  1)用来实现互斥的wait(&mutex);signal(&mutex);必须成对出现在每一个线程中,对于资源信号量的waitsignal操作,分别成对出现在不同的线程中
  2)先执行对资源信号量的wait操作,在执行对互斥信号量的wait操作,不能颠倒否则导致死锁。
step3:测试结果,符合预期:
生产者-消费者问题详解

4. 总结

 现在缺乏的是一种把生活中具体的问题抽象成代码的能力,可能也是对c语言的不熟悉导致的问题,看着我宿舍大神写的代码,真漂亮,由衷的羡慕。熟知并非真知,还得多加思考才是。

向AI问一下细节

免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。

AI