用线程实现经典生产者消费者问题

解决生产者消费者问题的方法一般采用同步机制保证生产者和消费者之间的同步，这种方式有较高的效率，并且易于实现，代码的可控制性较好，属于常用的模式。

同步问题核心在于：如何保证同一资源被多个线程并发访问时的完整性。常用的同步方法是采用信号或加锁机制，保证资源在任意时刻至多被一个线程访问。Java语言在多线程编程上实现了完全对象化，提供了对同步机制的良好支持。

生产者与消费者模型中，要保证以下几点：

同一时间内只能有一个生产者生产 生产方法加锁sychronized
同一时间内只能有一个消费者消费 消费方法加锁sychronized
共享空间空时消费者不能继续消费 消费前循环判断是否为空，空的话将该线程wait，释放锁允许其他同步方法执行
共享空间满时生产者不能继续生产 生产前循环判断是否为满，满的话将该线程wait，释放锁允许其他同步方法执行
生产者模型：一直生产，直到生产完10个。在生产过程中，如果库存中存满（1个）则停止生产（由clerk控制）

public class Producer implements Runnable {
    private Clerk clerk;
 
    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }
 
    @Override
    public void run() {
        System.out.println("生产者生产中...");
        for (int product = 1; product <= 1000; product++) {
            try {
                clerk.setProdect(product);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

消费者模型：不断消费，直到消费10个。消费过程中，如果库存有货则消费，没货等待（clerk中wait()）

public class Consumer implements Runnable {
    private Clerk clerk;
 
    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }
 
    @Override
    public void run() {
        System.out.println("消费者购买中...");
        for (int i = 1; i <= 1000; i++) {
            try {
                clerk.getProdect();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

最后转为Linux所用代码

#include <stdio.h>
#include <pthread.h>
#define MAX 10 
pthread_mutex_t the_mutex;
pthread_cond_t condc, condp;
int buffer = 0;

void *producer(void *ptr)
{
    int i;
    for(i=1; i<=MAX; i++)
    {
        pthread_mutex_lock(&the_mutex); 
        while(buffer !=0) pthread_cond_wait(&condp, &the_mutex);
        printf("procucer produce item %d\n",i);
        buffer = i; 
        pthread_cond_signal(&condc);
        pthread_mutex_unlock(&the_mutex);
    }
    
    pthread_exit(0);

}

void *consumer(void *ptr)
{

    int i;
    for(i=1; i<=MAX; i++)
    {
        pthread_mutex_lock(&the_mutex);
        while(buffer ==0) pthread_cond_wait(&condc, &the_mutex);
        printf("consumer consume item %d\n",i);
        buffer = 0;
        pthread_cond_signal(&condp);
        pthread_mutex_unlock(&the_mutex);
    }
    pthread_exit(0);

}

int main(int argc, char *argv[])
{
    pthread_t pro, con;
    pthread_mutex_init(&the_mutex, 0);
    pthread_cond_init(&condc,0);
    pthread_cond_init(&condp,0);
    pthread_create(&con, 0, consumer, 0);
    pthread_create(&pro, 0, producer, 0);
    pthread_join(pro,0);
    pthread_join(con,0);
    pthread_cond_destroy(&condc);
    pthread_cond_destroy(&condp);
    pthread_mutex_destroy(&the_mutex);
    return 0;    
}