模拟多线程协作-生产者消费者问题

package syn;

public class TestPC {
    public static void main(String[] args) {
        SynContainer synContainer=new SynContainer();
        Producter producter=new Producter(synContainer);
        Consumer consumer=new Consumer(synContainer);
        producter.start();
        consumer.start();
    }
}
//生产者
class Producter extends Thread{
    SynContainer synContainer;
    public Producter(SynContainer synContainer){
        this.synContainer=synContainer;
    }
    @Override
    public void run(){
        for (int i = 0; i < 100; i++) {
            try {
                synContainer.producter();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//消费者
class Consumer extends Thread{
    SynContainer synContainer;
    public Consumer(SynContainer synContainer){
        this.synContainer=synContainer;
    }
    @Override
    public void run(){
        for (int i = 0; i < 100; i++) {
            try {
                synContainer.consumer();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}


class SynContainer{

    int count=0;
    //生产者生产
    public synchronized void producter() throws InterruptedException {
        if(count==10){
            this.wait();
        }
        count++;
        System.out.println("生产者生产了第"+count+"只鸡");
        this.notifyAll();
    }

    //消费者消费
    public synchronized void consumer() throws InterruptedException {
        if(count==0){
            this.wait();
        }

        System.out.println("消费者消费了第"+count--+"只鸡");
        this.notifyAll();
    }
}
  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
生产者-消费者问题是一个经典的同步问题,涉及到多个线程之间的协作,需要保证生产者消费者之间的生产和消费过程是互相协调和同步的。在Linux环境下,可以使用pthread库来实现多线程的同步和互斥。 下面是一种基本的生产者-消费者问题的模拟实现,使用了一个生产者线程和一个消费者线程,并且使用了一个共享的缓冲区来存储生产者生产的数据和消费者消费的数据。 ```c #include <pthread.h> #include <stdio.h> #include <unistd.h> #define BUFFER_SIZE 10 int buffer[BUFFER_SIZE]; int count = 0; pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; pthread_cond_t producer_cond = PTHREAD_COND_INITIALIZER; pthread_cond_t consumer_cond = PTHREAD_COND_INITIALIZER; void *producer(void *arg) { int i, j; for (i = 0; i < 20; i++) { pthread_mutex_lock(&mutex); if (count >= BUFFER_SIZE) { pthread_cond_wait(&producer_cond, &mutex); } buffer[count] = i; count++; printf("Producer produced %d\n", i); pthread_cond_signal(&consumer_cond); pthread_mutex_unlock(&mutex); sleep(1); } return NULL; } void *consumer(void *arg) { int i, j; for (i = 0; i < 20; i++) { pthread_mutex_lock(&mutex); if (count <= 0) { pthread_cond_wait(&consumer_cond, &mutex); } int data = buffer[count-1]; count--; printf("Consumer consumed %d\n", data); pthread_cond_signal(&producer_cond); pthread_mutex_unlock(&mutex); sleep(1); } return NULL; } int main() { pthread_t producer_thread, consumer_thread; pthread_create(&producer_thread, NULL, producer, NULL); pthread_create(&consumer_thread, NULL, consumer, NULL); pthread_join(producer_thread, NULL); pthread_join(consumer_thread, NULL); return 0; } ``` 在这个例子中,我们使用了一个长度为10的缓冲区来存储生产者生产的数据和消费者消费的数据。在生产者线程中,我们使用了一个循环来不断地生产数据,并且在缓冲区已满的情况下,使用pthread_cond_wait函数来等待消费者线程消费数据,同时释放锁。在消费者线程中,我们也使用了一个循环来不断地消费数据,并且在缓冲区为空的情况下,使用pthread_cond_wait函数来等待生产者线程生产数据,同时释放锁。在生产者线程生产了数据之后,我们使用pthread_cond_signal函数来唤醒消费者线程;在消费者线程消费了数据之后,我们使用pthread_cond_signal函数来唤醒生产者线程。 需要注意的是,在使用pthread_cond_wait函数等待条件变量的时候,需要先获取互斥锁,然后在等待条件变量时释放互斥锁。这样可以保证在等待条件变量的时候,其他线程可以获取到互斥锁并访问共享资源。同时,在发送条件变量通知的时候,也需要先获取互斥锁,然后发送通知,最后释放互斥锁。这样可以保证在通知其他线程之前,当前线程已经完成了对共享资源的访问,避免多个线程同时访问同一个共享资源的情况。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值