生产消费者的同步

 生产者消费者

    生产者线程生产物品，然后将物品放置在一个空缓冲区中供消费者线程消费。消费者线程从缓冲区中获得物品，然后释放缓冲区。当生产者线程生产物品时，如果没有空缓冲区可用，那么生产者线程必须等待消费者线程释放出一个空缓冲区。当消费者线程消费物品时，如果没有满的缓冲区，那么消费者线程将被阻塞，直到新的物品被生产出来。

转自  http://www.cnblogs.com/svitter/p/4006129.html
  1 /*=============================================================================
#
# Author: svtter - svtter@qq.com
#
# QQ : 57180160
#
# Last modified: 2014-10-03 20:35
#
# Filename: producer_consumer.cc
#
# Description: 
#
=============================================================================*/
#include <cstdio>
#include <unistd.h>
#include <semaphore.h>
#include <pthread.h>
#include <sys/types.h>
#include <stdlib.h>
#include <iostream>

using namespace std;

#define N 5
#define item int

// P/V操作
void P(sem_t* sem)
{
    if(sem_wait(sem))
        perror("P error!");
    
}

void V(sem_t* sem)
{
    if(sem_post(sem))
        perror("V error!");
}

sem_t mutex;
sem_t full;
sem_t empty;
item buffer[N];
int i = 0, j = -1;

void init_sem()
{
    sem_init(&mutex, 0, 1);
    sem_init(&full, 0, 0);
    sem_init(&empty, 0, N);
}

void* producer(void *arg)
{
    int product;
    while(1)
    {
        //生成随机数字
        product = rand()%100;
        // cout << "producer running..." << endl;
        P(&empty);
        P(&mutex);
        buffer[i] = product;
        printf("producer produced %d @ %d pos
",
                product, i);
        i=(i+1)%N;
        V(&mutex);
        V(&full);
        sleep(1);
    }
}

void* consumer(void *arg)
{
    int product, temp;
    while(1)
    {
        // cout << "consumer running..." << endl;
        P(&full);
        P(&mutex);
        j = (j+1)%N;
        product = buffer[j];
        V(&mutex);
        V(&empty);
        printf("Consumer consumed %d @ %d pos
",
                product, j);
        sleep(3);
    }
}

int main()
{
    //random num
    srand(time(NULL));
    init_sem();
    
    int error;
    pthread_t producer_t, consumer_t;

    error = pthread_create(&producer_t, NULL, producer, NULL);
    if(error != 0)
        printf("error in create producer.
");
    else
        printf("create producer success!
");

    pthread_create(&consumer_t, NULL, consumer, NULL);
    if(error != 0)
        printf("error in create consumer.
");
    else
        printf("create consumer success!
");
    
    pthread_join(producer_t, NULL);
    pthread_join(consumer_t, NULL);

    return 0;
}

 Java:

 class Producer implements Runnable {  
 
    private String producerName = null; 
 
    private StoreHouse storeHouse = null; 
 
    public Producer(String producerName, StoreHouse storeHouse) { 
        this.producerName = producerName; 
        this.storeHouse = storeHouse; 
    } 
 
    public void setProducerName(String producerName) { 
        this.producerName = producerName; 
    } 
 
    public String getProducerName() { 
        return producerName; 
    } 
     
    public void produceProduct() { 
        int i = 0; 
        while (true) { 
            i++; 
            Product pro = new Product(i); 
            storeHouse.push(pro); 
            System.out.println(getProducerName() + " 生产了 " + pro); 
            try { 
                Thread.sleep(2000); 
            } catch (InterruptedException e) { 
                return; 
            } 
        } 
    } 
 
    public void run() { 
        produceProduct(); 
    } 
 
} 

class Consumer implements Runnable { 
     
    private String consumerName = null; 
     
    private StoreHouse storeHouse = null; 
 
    public Consumer(String consumerName, StoreHouse storeHouse) { 
        this.consumerName = consumerName; 
        this.storeHouse = storeHouse; 
    } 
     
    public void setConsumerName(String consumerName) { 
        this.consumerName = consumerName; 
    } 
     
    public String getConsumerName() { 
        return consumerName; 
    } 
     
    public void consumerProduct() { 
        while (true) { 
            System.out.println(getConsumerName() + " 消费了 " + storeHouse.pop()); 
            try { 
                Thread.sleep(5000); 
            } catch (InterruptedException e) { 
                return; 
            } 
        } 
    } 
 
    public void run() { 
        consumerProduct(); 
    } 
 
} 


 
class Product { 
 
    private int productId = 0; 
     
    public Product(int productId) { 
        this.productId = productId; 
    } 
 
    public int getProductId() { 
        return productId; 
    } 
 
    public String toString() { 
        return Integer.toString(productId); 
    } 
} 

class StoreHouse { 
 
    private int base = 0; 
 
    private int top = 0; 
 
    private Product[] products = new Product[10]; 
 
    public synchronized void push(Product product) { 
        while (top == products.length) { 
            notify(); 
            try { 
                System.out.println("仓库已满，正等待消费..."); 
                wait(); 
            } catch (InterruptedException e) { 
                System.out.println("stop push product because other reasons"); 

            } 
        } 
        products[top] = product; 
        top++; 
    } 
 
    public synchronized Product pop() { 
        Product pro = null; 
        while (top == base) { 
            notify(); 
            try { 
                System.out.println("仓库已空，正等待生产..."); 
                wait(); 
            } catch (InterruptedException e) { 
                System.out.println("stop push product because other reasons"); 

            } 
        } 
        top--; 
        pro = products[top]; 
        products[top] = null; 
        return pro; 
    } 
} 

public class TestPC { 
    public static void main(String[] args) { 
        StoreHouse storeHouse = new StoreHouse(); 
        Producer producer = new Producer("生产者", storeHouse); 
        Consumer comsumer = new Consumer("消费者", storeHouse); 
        Thread t1 = new Thread(producer); 
        Thread t2 = new Thread(comsumer); 
        t1.start(); 
        t2.start(); 
    } 
}