c语言实现生产者消费者问题

时间: 2023-11-25 15:06:28 浏览: 63
生产者消费者问题是一个经典的并发问题,它涉及到多个进程或线程之间的同步和互斥。在C语言中,可以使用线程和信号量来实现生产者消费者问题。 具体实现步骤如下: 1. 定义一个共享的缓冲区,可以使用队列或环形缓冲区。 2. 定义一个生产者线程和一个消费者线程。 3. 在生产者线程中,不断生成随机数并将其添加到缓冲区内,并在此之后将 full 计数器加一。 4. 在消费者线程中,检索当前可用的缓冲区,如果满足条件,则从计数器中减去 1,并从缓冲区中读取数据,并在满足特定条件时输出该数据。 5. 使用信号量来实现同步和互斥,保证在生产者没有向缓冲区提交任何内容时,消费者不会读取缓冲区中的任何数字。 下面是一个简单的C语言实现生产者消费者问题的代码示例: ``` #include <stdio.h> #include <stdlib.h> #include <pthread.h> #include <semaphore.h> #define BUFFER_SIZE 10 int buffer[BUFFER_SIZE]; int in = 0; int out = 0; int count = 0; sem_t empty; sem_t full; pthread_mutex_t mutex; void *producer(void *arg) { int item; while (1) { item = rand() % 100; // 生成随机数 sem_wait(&empty); // 等待空缓冲区 pthread_mutex_lock(&mutex); // 加锁 buffer[in] = item; in = (in + 1) % BUFFER_SIZE; count++; printf("Producer produced item %d\n", item); pthread_mutex_unlock(&mutex); // 解锁 sem_post(&full); // 发送满缓冲区信号 } } void *consumer(void *arg) { int item; while (1) { sem_wait(&full); // 等待满缓冲区 pthread_mutex_lock(&mutex); // 加锁 item = buffer[out]; out = (out + 1) % BUFFER_SIZE; count--; if (item % 2 == 0) { printf("Consumer consumed item %d\n", item); } pthread_mutex_unlock(&mutex); // 解锁 sem_post(&empty); // 发送空缓冲区信号 } } int main() { pthread_t producer_thread, consumer_thread; sem_init(&empty, 0, BUFFER_SIZE); sem_init(&full, 0, 0); pthread_mutex_init(&mutex, NULL); pthread_create(&producer_thread, NULL, producer, NULL); pthread_create(&consumer_thread, NULL, consumer, NULL); pthread_join(producer_thread, NULL); pthread_join(consumer_thread, NULL); sem_destroy(&empty); sem_destroy(&full); pthread_mutex_destroy(&mutex); return 0; } ```

相关推荐

生产者消费者问题是一个经典的多线程同步问题,下面是一个用C语言实现的基本示例: #include <stdio.h> #include <stdlib.h> #include #define BUFFER_SIZE 5 #define PRODUCER_NUM 2 #define CONSUMER_NUM 2 typedef struct { int buffer[BUFFER_SIZE]; int in; int out; int count; pthread_mutex_t mutex; pthread_cond_t full; pthread_cond_t empty; } buffer_t; buffer_t buffer = { .in = 0, .out = 0, .count = 0, .mutex = PTHREAD_MUTEX_INITIALIZER, .full = PTHREAD_COND_INITIALIZER, .empty = PTHREAD_COND_INITIALIZER }; int produce_item() { return rand() % 100; } void consume_item(int item) { printf("Consumed item %d\n", item); } void *producer(void *arg) { int item; while (1) { item = produce_item(); pthread_mutex_lock(&buffer.mutex); while (buffer.count == BUFFER_SIZE) { pthread_cond_wait(&buffer.empty, &buffer.mutex); } buffer.buffer[buffer.in] = item; buffer.in = (buffer.in + 1) % BUFFER_SIZE; buffer.count++; pthread_cond_signal(&buffer.full); pthread_mutex_unlock(&buffer.mutex); printf("Produced item %d\n", item); } return NULL; } void *consumer(void *arg) { int item; while (1) { pthread_mutex_lock(&buffer.mutex); while (buffer.count == 0) { pthread_cond_wait(&buffer.full, &buffer.mutex); } item = buffer.buffer[buffer.out]; buffer.out = (buffer.out + 1) % BUFFER_SIZE; buffer.count--; pthread_cond_signal(&buffer.empty); pthread_mutex_unlock(&buffer.mutex); consume_item(item); } return NULL; } int main() { pthread_t producers[PRODUCER_NUM]; pthread_t consumers[CONSUMER_NUM]; int i; for (i = 0; i < PRODUCER_NUM; i++) { pthread_create(&producers[i], NULL, producer, NULL); } for (i = 0; i < CONSUMER_NUM; i++) { pthread_create(&consumers[i], NULL, consumer, NULL); } for (i = 0; i < PRODUCER_NUM; i++) { pthread_join(producers[i], NULL); } for (i = 0; i < CONSUMER_NUM; i++) { pthread_join(consumers[i], NULL); } return 0; } 在该示例中,buffer_t是一个缓冲区结构体,包含一个固定大小的缓冲区、入队和出队指针、当前缓冲区中的元素个数以及互斥锁和条件变量等同步机制。produce_item()和consume_item()分别表示生产和消费一个元素的函数。producer()和consumer()是两个线程函数,分别表示生产者和消费者的行为。在生产者线程中,如果缓冲区已满,则线程将等待直到有空间可用。当元素被生产并插入缓冲区后,线程会通知消费者线程消费元素。在消费者线程中,如果缓冲区为空,则线程将等待直到有元素可用。当元素被消费后,线程会通知生产者线程生产更多的元素。最后,在main()函数中,创建多个生产者和消费者线程,并等待它们完成。
好的,以下是一个简易的C语言代码实现生产者消费者问题,附有注释: c #include <stdio.h> #include <stdlib.h> #include // 缓冲区大小 #define BUFFER_SIZE 10 // 缓冲区 int buffer[BUFFER_SIZE]; // 缓冲区中元素数量 int count = 0; // 互斥锁 pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; // 条件变量,用于生产者和消费者之间的同步 pthread_cond_t full = PTHREAD_COND_INITIALIZER; pthread_cond_t empty = PTHREAD_COND_INITIALIZER; // 生产者线程函数 void *producer(void *arg) { int i = 0; while (i < 20) { // 生产20个元素 pthread_mutex_lock(&mutex); // 加锁 // 如果缓冲区已满,则等待 while (count == BUFFER_SIZE) { pthread_cond_wait(&empty, &mutex); } // 生产一个元素,放入缓冲区 buffer[count++] = i; printf("Producing %d...\n", i); // 发出条件信号,唤醒等待在full条件变量上的消费者线程 pthread_cond_signal(&full); pthread_mutex_unlock(&mutex); // 解锁 i++; } return NULL; } // 消费者线程函数 void *consumer(void *arg) { int i = 0; while (i < 20) { // 消费20个元素 pthread_mutex_lock(&mutex); // 加锁 // 如果缓冲区为空,则等待 while (count == 0) { pthread_cond_wait(&full, &mutex); } // 从缓冲区中取出一个元素进行消费 int item = buffer[--count]; printf("Consuming %d...\n", item); // 发出条件信号,唤醒等待在empty条件变量上的生产者线程 pthread_cond_signal(&empty); pthread_mutex_unlock(&mutex); // 解锁 i++; } return NULL; } int main() { pthread_t p, c; // 创建生产者和消费者线程 pthread_create(&p, NULL, producer, NULL); pthread_create(&c, NULL, consumer, NULL); // 等待线程结束 pthread_join(p, NULL); pthread_join(c, NULL); return 0; } 该代码实现了一个简单的生产者消费者模型,使用了互斥锁和条件变量来实现线程之间的同步与互斥。生产者线程不断生产元素并将其放入缓冲区,而消费者线程不断从缓冲区中取出元素进行消费。当缓冲区已满时,生产者线程会等待,直到有消费者取出元素后才会继续生产;当缓冲区为空时,消费者线程会等待,直到有生产者生产元素后才会继续消费。
生产者与消费者问题可以使用线程和信号量来实现。 以下是一个简单的C语言程序,使用互斥锁和条件变量来解决生产者和消费者问题: c #include <stdio.h> #include <stdlib.h> #include #include <semaphore.h> #define BUFFER_SIZE 10 int buffer[BUFFER_SIZE]; int in = 0; int out = 0; pthread_mutex_t mutex; sem_t empty; sem_t full; void* producer(void* arg) { int item; while (1) { item = rand(); sem_wait(&empty); pthread_mutex_lock(&mutex); buffer[in] = item; in = (in + 1) % BUFFER_SIZE; printf("Produced item: %d\n", item); pthread_mutex_unlock(&mutex); sem_post(&full); } } void* consumer(void* arg) { int item; while (1) { sem_wait(&full); pthread_mutex_lock(&mutex); item = buffer[out]; out = (out + 1) % BUFFER_SIZE; printf("Consumed item: %d\n", item); pthread_mutex_unlock(&mutex); sem_post(&empty); } } int main() { pthread_t tid1, tid2; pthread_mutex_init(&mutex, NULL); sem_init(&empty, 0, BUFFER_SIZE); sem_init(&full, 0, 0); pthread_create(&tid1, NULL, producer, NULL); pthread_create(&tid2, NULL, consumer, NULL); pthread_join(tid1, NULL); pthread_join(tid2, NULL); pthread_mutex_destroy(&mutex); sem_destroy(&empty); sem_destroy(&full); return 0; } 在该程序中,生产者线程和消费者线程无限循环地执行。生产者线程生成一个随机数并将其放入缓冲区中,然后唤醒消费者线程。消费者线程从缓冲区中获取一个项目并打印出来,然后唤醒生产者线程。 互斥锁用于保护缓冲区的读写操作,而信号量则用于控制缓冲区的空闲和已用空间。当缓冲区已满时,生产者线程被阻塞在 sem_wait(&empty) 处,直到有空间可用。当缓冲区为空时,消费者线程被阻塞在 sem_wait(&full) 处,直到有项目可用。 注意,该程序仅为示例,实际应用中可能需要更复杂的同步机制和错误处理。
生产者消费者问题是一个经典的多线程同步问题,可以用信号量或互斥锁实现。下面是一个使用互斥锁和条件变量解决生产者消费者问题的 C 语言实现: c #include <stdio.h> #include <stdlib.h> #include #define BUFFER_SIZE 10 int buffer[BUFFER_SIZE]; int count = 0; // 缓冲区中的数据个数 pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; // 互斥锁 pthread_cond_t full = PTHREAD_COND_INITIALIZER; // 缓冲区满条件变量 pthread_cond_t empty = PTHREAD_COND_INITIALIZER; // 缓冲区空条件变量 void *producer(void *arg) { int item = 0; while (1) { pthread_mutex_lock(&mutex); if (count == BUFFER_SIZE) { // 缓冲区满了,等待消费者消费 pthread_cond_wait(&full, &mutex); } buffer[count++] = item++; // 生产一个物品 printf("Producer produced item %d\n", item); pthread_cond_signal(&empty); // 通知消费者有物品可取 pthread_mutex_unlock(&mutex); } } void *consumer(void *arg) { int item; while (1) { pthread_mutex_lock(&mutex); if (count == 0) { // 缓冲区空了,等待生产者生产 pthread_cond_wait(&empty, &mutex); } item = buffer[--count]; // 消费一个物品 printf("Consumer consumed item %d\n", item); pthread_cond_signal(&full); // 通知生产者有空闲缓冲区 pthread_mutex_unlock(&mutex); } } 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; } 在这个程序中,生产者不断地往缓冲区中生产物品,如果缓冲区已经满了,就等待消费者消费;消费者不断地从缓冲区中取出物品消费,如果缓冲区已经空了,就等待生产者生产。生产者和消费者之间通过条件变量进行通信,缓冲区中的数据个数通过互斥锁进行保护。
生产者多消费者问题是一个经典的同步问题,可以使用互斥锁和条件变量来实现。 以下是一个使用C语言实现的生产者多消费者问题: c #include #include <stdio.h> #define BUFFER_SIZE 10 #define PRODUCER_NUM 2 #define CONSUMER_NUM 3 int buffer[BUFFER_SIZE]; // 缓冲区 int in = 0, out = 0; // 缓冲区读写位置 int count = 0; // 缓冲区中的元素数量 pthread_mutex_t mutex; // 互斥锁 pthread_cond_t not_full; // 缓冲区不满的条件变量 pthread_cond_t not_empty; // 缓冲区不空的条件变量 void *producer(void *arg) { int id = *(int *)arg; while (1) { pthread_mutex_lock(&mutex); while (count == BUFFER_SIZE) { printf("producer %d: buffer is full, wait...\n", id); pthread_cond_wait(¬_full, &mutex); } buffer[in] = rand(); printf("producer %d: produce item %d\n", id, buffer[in]); in = (in + 1) % BUFFER_SIZE; count++; pthread_cond_signal(¬_empty); pthread_mutex_unlock(&mutex); sleep(1); } return NULL; } void *consumer(void *arg) { int id = *(int *)arg; while (1) { pthread_mutex_lock(&mutex); while (count == 0) { printf("consumer %d: buffer is empty, wait...\n", id); pthread_cond_wait(¬_empty, &mutex); } int item = buffer[out]; printf("consumer %d: consume item %d\n", id, item); out = (out + 1) % BUFFER_SIZE; count--; pthread_cond_signal(¬_full); pthread_mutex_unlock(&mutex); sleep(2); } return NULL; } int main(int argc, char *argv[]) { pthread_t producer_threads[PRODUCER_NUM]; pthread_t consumer_threads[CONSUMER_NUM]; int producer_ids[PRODUCER_NUM]; int consumer_ids[CONSUMER_NUM]; int i; pthread_mutex_init(&mutex, NULL); pthread_cond_init(¬_full, NULL); pthread_cond_init(¬_empty, NULL); for (i = 0; i < PRODUCER_NUM; i++) { producer_ids[i] = i + 1; pthread_create(&producer_threads[i], NULL, producer, &producer_ids[i]); } for (i = 0; i < CONSUMER_NUM; i++) { consumer_ids[i] = i + 1; pthread_create(&consumer_threads[i], NULL, consumer, &consumer_ids[i]); } for (i = 0; i < PRODUCER_NUM; i++) { pthread_join(producer_threads[i], NULL); } for (i = 0; i < CONSUMER_NUM; i++) { pthread_join(consumer_threads[i], NULL); } pthread_mutex_destroy(&mutex); pthread_cond_destroy(¬_full); pthread_cond_destroy(¬_empty); return 0; } 这个程序创建了两个生产者线程和三个消费者线程,它们共享一个缓冲区。当缓冲区已满时,生产者线程等待缓冲区不满的条件变量;当缓冲区为空时,消费者线程等待缓冲区不空的条件变量。生产者线程生产一个随机数并将其放入缓冲区中,消费者线程从缓冲区中取出一个元素并处理它。使用互斥锁来保护缓冲区的读写操作,以避免同时访问缓冲区造成的竞争情况。
以下是一个简单的生产者消费者问题的C语言实现代码: #include <stdio.h> #include <stdlib.h> #include #define BUFFER_SIZE 10 int buffer[BUFFER_SIZE]; int count = 0; pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; pthread_cond_t producer_condition = PTHREAD_COND_INITIALIZER; pthread_cond_t consumer_condition = PTHREAD_COND_INITIALIZER; void *producer(void *arg) { int item; while (1) { item = rand() % 100; // 随机生成一个整数,模拟生产一个数据项 pthread_mutex_lock(&mutex); while (count == BUFFER_SIZE) { pthread_cond_wait(&producer_condition, &mutex); // 如果缓冲区已满,等待消费者取走数据 } buffer[count++] = item; printf("Producer produced %d\n", item); pthread_mutex_unlock(&mutex); pthread_cond_signal(&consumer_condition); // 通知一个消费者可以取走数据了 } } void *consumer(void *arg) { int item; while (1) { pthread_mutex_lock(&mutex); while (count == 0) { pthread_cond_wait(&consumer_condition, &mutex); // 如果缓冲区已空,等待生产者产生数据 } item = buffer[--count]; printf("Consumer consumed %d\n", item); pthread_mutex_unlock(&mutex); pthread_cond_signal(&producer_condition); // 通知一个生产者可以继续生产数据了 } } int main(int argc, char *argv[]) { pthread_t p, c; srand((unsigned int) time(NULL)); pthread_create(&p, NULL, producer, NULL); pthread_create(&c, NULL, consumer, NULL); pthread_join(p, NULL); pthread_join(c, NULL); return 0; } 这个代码使用了互斥锁和条件变量来实现线程间的同步与通信。生产者线程随机生成一个整数,将其放入缓冲区中,同时通知一个消费者线程可以取走数据;消费者线程从缓冲区中取走一个数据,同时通知一个生产者线程可以继续生产数据。这种方法可以避免竞争条件和死锁问题。
生产者消费者问题是一个经典的多线程同步问题,C语言是一个非常适合处理多线程问题的编程语言。下面是一个简单的C语言实现生产者消费者问题的示例代码: #include <stdio.h> #include <stdlib.h> #include #define BUFFER_SIZE 10 int buffer[BUFFER_SIZE]; int count = 0; pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; pthread_cond_t cond_prod = PTHREAD_COND_INITIALIZER; pthread_cond_t cond_cons = PTHREAD_COND_INITIALIZER; void *producer(void *arg) { while (1) { pthread_mutex_lock(&mutex); if (count == BUFFER_SIZE) { pthread_cond_wait(&cond_prod, &mutex); } buffer[count] = rand() % 100; printf("Producer produces %d, count = %d\n", buffer[count], count + 1); count++; pthread_cond_signal(&cond_cons); pthread_mutex_unlock(&mutex); } return NULL; } void *consumer(void *arg) { while (1) { pthread_mutex_lock(&mutex); if (count == 0) { pthread_cond_wait(&cond_cons, &mutex); } printf("Consumer consumes %d, count = %d\n", buffer[count - 1], count - 1); count--; pthread_cond_signal(&cond_prod); pthread_mutex_unlock(&mutex); } return NULL; } int main() { pthread_t prod_tid, cons_tid; pthread_create(&prod_tid, NULL, producer, NULL); pthread_create(&cons_tid, NULL, consumer, NULL); pthread_join(prod_tid, NULL); pthread_join(cons_tid, NULL); return 0; } 这个示例代码中,我们使用了互斥锁和条件变量来实现线程之间的同步。生产者线程不断地往缓冲区中添加元素,如果缓冲区已满,则等待条件变量cond_prod的信号。消费者线程不断地从缓冲区中取出元素,如果缓冲区为空,则等待条件变量cond_cons的信号。当生产者线程向缓冲区中添加元素时,会发出条件变量cond_cons的信号,告诉消费者线程可以从缓冲区中取出元素了;当消费者线程从缓冲区中取出元素时,会发出条件变量cond_prod的信号,告诉生产者线程可以向缓冲区中添加元素了。这样,生产者线程和消费者线程之间就可以通过互斥锁和条件变量进行同步,避免了竞争条件和死锁的问题。
以下是一个简单的生产者与消费者问题的C语言实现: c #include <stdio.h> #include <stdlib.h> #include #include <semaphore.h> #define BUFFER_SIZE 5 // 缓冲区大小 int buffer[BUFFER_SIZE]; // 缓冲区 int in = 0; // 生产者将产品放入缓冲区的位置 int out = 0; // 消费者从缓冲区取走产品的位置 sem_t empty; // 空缓冲区信号量 sem_t full; // 满缓冲区信号量 pthread_mutex_t mutex; // 互斥锁 void *producer(void *arg) { // 生产者线程 for (int i = 0; i < 10; i++) { // 生产10个产品 sem_wait(&empty); // 等待空缓冲区 pthread_mutex_lock(&mutex); // 加锁 buffer[in] = i; // 将产品放入缓冲区 printf("Producer produces item %d at position %d.\n", i, in); in = (in + 1) % BUFFER_SIZE; // 更新in指针 pthread_mutex_unlock(&mutex); // 解锁 sem_post(&full); // 发出满缓冲区信号 sleep(1); // 生产一个产品需要1秒钟 } pthread_exit(NULL); } void *consumer(void *arg) { // 消费者线程 int item; for (int i = 0; i < 10; i++) { // 消费10个产品 sem_wait(&full); // 等待满缓冲区 pthread_mutex_lock(&mutex); // 加锁 item = buffer[out]; // 从缓冲区取走一个产品 printf("Consumer consumes item %d from position %d.\n", item, out); out = (out + 1) % BUFFER_SIZE; // 更新out指针 pthread_mutex_unlock(&mutex); // 解锁 sem_post(&empty); // 发出空缓冲区信号 sleep(2); // 消费一个产品需要2秒钟 } pthread_exit(NULL); } int main() { pthread_t producer_thread, consumer_thread; sem_init(&empty, 0, BUFFER_SIZE); // 初始化空缓冲区信号量为BUFFER_SIZE sem_init(&full, 0, 0); // 初始化满缓冲区信号量为0 pthread_mutex_init(&mutex, NULL); // 初始化互斥锁 pthread_create(&producer_thread, NULL, producer, NULL); // 创建生产者线程 pthread_create(&consumer_thread, NULL, consumer, NULL); // 创建消费者线程 pthread_join(producer_thread, NULL); // 等待生产者线程结束 pthread_join(consumer_thread, NULL); // 等待消费者线程结束 sem_destroy(&empty); // 销毁空缓冲区信号量 sem_destroy(&full); // 销毁满缓冲区信号量 pthread_mutex_destroy(&mutex); // 销毁互斥锁 return 0; } 在这个程序中,我们使用了一个长度为5的缓冲区来存放产品。生产者和消费者通过互斥锁来保证对缓冲区的访问是互斥的,通过信号量来保证生产者和消费者之间的同步。 在生产者线程中,每当生产一个产品,就需要先等待空缓冲区信号量,表示缓冲区中有空位置可以放置产品,然后再获得互斥锁,将产品放入缓冲区,更新in指针,释放互斥锁,发出满缓冲区信号量,表示缓冲区中已经有产品了。生产一个产品需要1秒钟。 在消费者线程中,每当消费一个产品,就需要先等待满缓冲区信号量,表示缓冲区中已经有产品可以取走,然后再获得互斥锁,从缓冲区中取走一个产品,更新out指针,释放互斥锁,发出空缓冲区信号量,表示缓冲区中又有空位置了。消费一个产品需要2秒钟。
好的,下面是一个使用 C 语言实现生产者消费者问题的示例代码: c #include <stdio.h> #include <stdlib.h> #include #define BUFFER_SIZE 10 int buffer[BUFFER_SIZE]; // 缓冲区 int in = 0, out = 0; // 生产者和消费者在缓冲区中的位置 int count = 0; // 缓冲区中元素的数量 pthread_mutex_t mutex; // 互斥锁 pthread_cond_t full, empty; // 条件变量 // 生产者函数 void *producer(void *arg) { int item; while (1) { item = rand() % 1000; pthread_mutex_lock(&mutex); // 如果缓冲区已满,等待消费者消费 while (count == BUFFER_SIZE) { pthread_cond_wait(&empty, &mutex); } buffer[in] = item; printf("Producer put item %d into the buffer.\n", item); in = (in + 1) % BUFFER_SIZE; count++; // 唤醒消费者 pthread_cond_signal(&full); pthread_mutex_unlock(&mutex); sleep(1); } pthread_exit(NULL); } // 消费者函数 void *consumer(void *arg) { int item; while (1) { pthread_mutex_lock(&mutex); // 如果缓冲区为空,等待生产者生产 while (count == 0) { pthread_cond_wait(&full, &mutex); } item = buffer[out]; printf("Consumer get item %d from the buffer.\n", item); out = (out + 1) % BUFFER_SIZE; count--; // 唤醒生产者 pthread_cond_signal(&empty); pthread_mutex_unlock(&mutex); sleep(1); } pthread_exit(NULL); } int main(int argc, char *argv[]) { pthread_t tid_producer, tid_consumer; pthread_mutex_init(&mutex, NULL); pthread_cond_init(&full, NULL); pthread_cond_init(&empty, NULL); pthread_create(&tid_producer, NULL, producer, NULL); pthread_create(&tid_consumer, NULL, consumer, NULL); pthread_join(tid_producer, NULL); pthread_join(tid_consumer, NULL); pthread_mutex_destroy(&mutex); pthread_cond_destroy(&full); pthread_cond_destroy(&empty); return 0; } 这个程序中使用了 pthread 库来实现线程和互斥锁,使用了条件变量来实现生产者和消费者之间的同步。缓冲区大小为 10,生产者和消费者每隔 1 秒向其中添加或取出一个元素。在生产者向缓冲区中添加元素时,如果缓冲区已满,则等待消费者消费;在消费者从缓冲区中取出元素时,如果缓冲区为空,则等待生产者生产。程序中还使用了 sleep 函数来模拟生产和消费的时间间隔。
可以采用多线程的方式来解决生产者消费者问题,其中用到了线程之间的同步和互斥机制。 具体实现方式可以参考下面的代码: #include <stdio.h> #include <stdlib.h> #include #define MAX_BUFFER_SIZE 10 int buffer[MAX_BUFFER_SIZE]; int count = 0; int index_producer = 0; int index_consumer = 0; pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; pthread_cond_t full = PTHREAD_COND_INITIALIZER; pthread_cond_t empty = PTHREAD_COND_INITIALIZER; void *producer(void *arg) { while (1) { pthread_mutex_lock(&lock); while (count == MAX_BUFFER_SIZE) { pthread_cond_wait(&empty, &lock); } buffer[index_producer] = rand() % 100; index_producer = (index_producer + 1) % MAX_BUFFER_SIZE; count++; printf("Producer produced %d\n", buffer[index_producer]); pthread_cond_signal(&full); pthread_mutex_unlock(&lock); } } void *consumer(void *arg) { while (1) { pthread_mutex_lock(&lock); while (count == 0) { pthread_cond_wait(&full, &lock); } int value = buffer[index_consumer]; index_consumer = (index_consumer + 1) % MAX_BUFFER_SIZE; count--; printf("Consumer consumed %d\n", value); pthread_cond_signal(&empty); pthread_mutex_unlock(&lock); } } int main() { pthread_t tid_producer, tid_consumer; srand(time(NULL)); pthread_create(&tid_producer, NULL, producer, NULL); pthread_create(&tid_consumer, NULL, consumer, NULL); pthread_join(tid_producer, NULL); pthread_join(tid_consumer, NULL); return 0; } 以上代码用到了三个互斥量和两个条件变量: 互斥量lock:保证线程之间的同步。 条件变量full:用于信号生产者生产完毕,缓冲区已满,需要等待消费者消费。 条件变量empty:用于信号消费者消费完毕,缓冲区为空,需要等待生产者生产。 在producer函数中,当缓冲区已满时,生产者线程需要等待消费者线程消费;当生产者线程生产完毕时,需要通知消费者线程可以消费了。 在consumer函数中,当缓冲区为空时,消费者线程需要等待生产者线程生产;当消费者线程消费完毕时,需要通知生产者线程可以生产了。 完整程序运行效果如下: Producer produced 28 Consumer consumed 28 Producer produced 35 Producer produced 10 Producer produced 43 Producer produced 68 Producer produced 98 Producer produced 19 Producer produced 44 Producer produced 62 Consumer consumed 35 Consumer consumed 10 Consumer consumed 43 Consumer consumed 68 Consumer consumed 98 Consumer consumed 19 Consumer consumed 44 Consumer consumed 62 Producer produced 52 Producer produced 98 Producer produced 83 Producer produced 86 Producer produced 21 Producer produced 97 Producer produced 7 Producer produced 6 Consumer consumed 52 Consumer consumed 98 Consumer consumed 83 Consumer consumed 86 Consumer consumed 21 Consumer consumed 97 Consumer consumed 7 Consumer consumed 6 ......
消费者问题是指一个生产者(Producer)和一个消费者(Consumer)在同一个缓冲区(Buffer)进行数据交互的问题。下面是一个使用 C 语言实现的消费者问题示例: #include <stdio.h> #include <stdlib.h> #include #include <semaphore.h> #define BUFFER_SIZE 10 int buffer[BUFFER_SIZE]; int in = 0, out = 0; sem_t empty_sem, full_sem; pthread_mutex_t mutex; void *producer(void *arg) { int i; for (i = 0; i < 20; i++) { sem_wait(&empty_sem); pthread_mutex_lock(&mutex); buffer[in] = i; printf("Producer produces the item %d at position %d\n", buffer[in], in); in = (in + 1) % BUFFER_SIZE; pthread_mutex_unlock(&mutex); sem_post(&full_sem); } } void *consumer(void *arg) { int i, item; for (i = 0; i < 20; i++) { sem_wait(&full_sem); pthread_mutex_lock(&mutex); item = buffer[out]; printf("Consumer consumes the item %d at position %d\n", item, out); out = (out + 1) % BUFFER_SIZE; pthread_mutex_unlock(&mutex); sem_post(&empty_sem); } } int main() { pthread_t pid, cid; sem_init(&empty_sem, 0, BUFFER_SIZE); sem_init(&full_sem, 0, 0); pthread_mutex_init(&mutex, NULL); pthread_create(&pid, NULL, producer, NULL); pthread_create(&cid, NULL, consumer, NULL); pthread_join(pid, NULL); pthread_join(cid, NULL); sem_destroy(&empty_sem); sem_destroy(&full_sem); pthread_mutex_destroy(&mutex); return 0; } 在这个示例中,生产者和消费者线程分别通过 pthread_create 函数创建,并分别执行 producer 和 consumer 函数。在 main 函数中,通过 pthread_join 函数等待线程结束。 这里用到了信号量和互斥锁来保证线程之间的同步和互斥。其中 empty_sem 表示缓冲区的空闲空间数量,full_sem 表示缓冲区中已有的数据数量,mutex 表示互斥锁。 在生产者和消费者的函数实现中,使用 sem_wait 和 sem_post 函数来操作信号量,使用 pthread_mutex_lock 和 pthread_mutex_unlock 函数来操作互斥锁。在生产者函数中,当缓冲区已满时,会调用 sem_wait 函数阻塞当前线程,直到有空闲空间;在消费者函数中,当缓冲区为空时,会调用 sem_wait 函数阻塞当前线程,直到有数据可取。 在操作缓冲区时,使用循环队列的方式来实现,通过 in 和 out 指针来指示当前位置。在每次插入或取出数据后,将指针向后移动,当指针到达缓冲区的末尾时,将其置为 0,形成循环队列的效果。

最新推荐

300126锐奇股份财务报告资产负债利润现金流量表企业治理结构股票交易研发创新等1391个指标(2007-2022).xlsx

包含1391个指标,其说明文档参考: https://blog.csdn.net/yushibing717/article/details/136115027 数据来源:基于上市公司公告数据整理 数据期间:从具体上市公司上市那一年开始-2022年度的数据,年度数据 包含各上市公司股票的、多年度的上市公司财务报表资产负债表、上市公司财务报表利润表、上市公司财务报表现金流量表间接法、直接法四表合在一个面板里面,方便比较和分析利用 含各个上市公司股票的、多年度的 偿债能力 披露财务指标 比率结构 经营能力 盈利能力 现金流量分析 风险水平 发展能力 每股指标 相对价值指标 股利分配 11类财务指标分析数据合在一个面板里面,方便比较和分析利用 含上市公司公告的公司治理、股权结构、审计、诉讼等数据 包含1391个指标,如: 股票简称 证券ID 注册具体地址 公司办公地址 办公地址邮政编码 董事会秘书 董秘联系电话 董秘传真 董秘电子邮箱 ..... 货币资金 其中:客户资金存款 结算备付金 其中:客户备付金 .........

【路径规划】基于matlab原子搜索算法栅格地图机器人最短路径规划【含Matlab源码 2887期】.mp4

CSDN佛怒唐莲上传的视频均有对应的完整代码,皆可运行,亲测可用,适合小白; 1、代码压缩包内容 主函数:main.m; 调用函数:其他m文件;无需运行 运行结果效果图; 2、代码运行版本 Matlab 2019b;若运行有误,根据提示修改;若不会,私信博主; 3、运行操作步骤 步骤一:将所有文件放到Matlab的当前文件夹中; 步骤二:双击打开main.m文件; 步骤三:点击运行,等程序运行完得到结果; 4、仿真咨询 如需其他服务,可私信博主或扫描视频QQ名片; 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作

【语音隐写】基于matlab DCT扩频语音水印【含Matlab源码 466期】.mp4

CSDN佛怒唐莲上传的视频均有对应的完整代码,皆可运行,亲测可用,适合小白; 1、代码压缩包内容 主函数:main.m; 调用函数:其他m文件;无需运行 运行结果效果图; 2、代码运行版本 Matlab 2019b;若运行有误,根据提示修改;若不会,私信博主; 3、运行操作步骤 步骤一:将所有文件放到Matlab的当前文件夹中; 步骤二:双击打开main.m文件; 步骤三:点击运行,等程序运行完得到结果; 4、仿真咨询 如需其他服务,可私信博主或扫描视频QQ名片; 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作

C#课程设计 扫雷游戏.zip

C#课程设计 扫雷游戏

Webs.zip(winXP到Win11的背景)

WinXP到win11的背景 由于时间不足,部分未找到,敬请谅解!

DAC简介及参考电路PPT学习教案.pptx

DAC简介及参考电路PPT学习教案.pptx

管理建模和仿真的文件

管理Boualem Benatallah引用此版本:布阿利姆·贝纳塔拉。管理建模和仿真。约瑟夫-傅立叶大学-格勒诺布尔第一大学,1996年。法语。NNT:电话:00345357HAL ID:电话:00345357https://theses.hal.science/tel-003453572008年12月9日提交HAL是一个多学科的开放存取档案馆,用于存放和传播科学研究论文,无论它们是否被公开。论文可以来自法国或国外的教学和研究机构,也可以来自公共或私人研究中心。L’archive ouverte pluridisciplinaire

OceanBase数据库简介及原理解析

# 1. OceanBase数据库概述 ## 1.1 OceanBase数据库的发展历程 OceanBase数据库是由阿里巴巴集团自主研发的一款分布式关系型数据库系统,起源于阿里集团的业务需求和技术挑战。自2010年开始研发,经过多年的迭代和优化,OceanBase已经成为阿里巴巴集团重要的核心数据库产品之一。在实际的业务场景中,OceanBase已经被广泛应用于金融、电商、物流等各个领域。 ## 1.2 OceanBase数据库的特点和优势 OceanBase数据库具有以下特点和优势: - **分布式架构**:OceanBase采用多副本分布式架构,可以实现高可用和数据容灾。 -

python的pandas读取excel怎么将excel表里的列从1开始而不是0

在 Pandas 中,数据框的列默认从0开始编号,但我们可以通过自定义函数来进行数据列的转换。可以先将读取的数据框列的第一个值设为1,然后对后续列进行递增处理。 以下是示例代码: ```python import pandas as pd # 读取 Excel 文件 df = pd.read_excel('your_excel_file.xlsx') # 定义函数将列从1开始 def reset_column(x): return str(int(x) + 1) # 应用函数到所有列名 df = df.rename(columns=reset_column) # 打印数据框

第三章薪酬水平、薪酬系统的运行与控制.pptx

第三章薪酬水平、薪酬系统的运行与控制.pptx