第十一周Linux教材第十二章学习笔记——块设备I/O和缓冲区管理

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <pthread.h>
 4 #include <semaphore.h>
 5 
 6 #define BUFFER_SIZE 5
 7 
 8 int buffer[BUFFER_SIZE];
 9 sem_t empty, full, mutex;
10 int in = 0, out = 0;
11 
12 void produce(int item) {
13     // Produce an item
14     buffer[in] = item;
15     in = (in + 1) % BUFFER_SIZE;
16 }
17 
18 int consume() {
19     // Consume an item
20     int item = buffer[out];
21     out = (out + 1) % BUFFER_SIZE;
22     return item;
23 }
24 
25 void* producer(void* arg) {
26     int item;
27     while (1) {
28         // Produce an item
29         item = rand() % 100;
30         
31         // Wait for an empty buffer slot
32         sem_wait(&empty);
33         
34         // Wait for mutex to access the buffer
35         sem_wait(&mutex);
36         
37         // Produce the item into the buffer
38         produce(item);
39         
40         // Release mutex
41         sem_post(&mutex);
42         
43         // Signal that a buffer slot is full
44         sem_post(&full);
45     }
46     return NULL;
47 }
48 
49 void* consumer(void* arg) {
50     int item;
51     while (1) {
52         // Wait for a full buffer slot
53         sem_wait(&full);
54         
55         // Wait for mutex to access the buffer
56         sem_wait(&mutex);
57         
58         // Consume an item from the buffer
59         item = consume();
60         
61         // Release mutex
62         sem_post(&mutex);
63         
64         // Signal that a buffer slot is empty
65         sem_post(&empty);
66         
67         // Process the consumed item
68         printf("Consumed: %d\n", item);
69     }
70     return NULL;
71 }
72 
73 int main() {
74     // Initialize semaphores
75     sem_init(&empty, 0, BUFFER_SIZE); // Number of empty buffer slots
76     sem_init(&full, 0, 0); // Number of full buffer slots
77     sem_init(&mutex, 0, 1); // Mutex for buffer access
78 
79     // Create producer and consumer threads
80     pthread_t producer_thread, consumer_thread;
81     pthread_create(&producer_thread, NULL, producer, NULL);
82     pthread_create(&consumer_thread, NULL, consumer, NULL);
83 
84     // Wait for threads to finish (this example runs indefinitely)
85     pthread_join(producer_thread, NULL);
86     pthread_join(consumer_thread, NULL);
87 
88     // Destroy semaphores
89     sem_destroy(&empty);
90     sem_destroy(&full);
91     sem_destroy(&mutex);
92 
93     return 0;
94 }

P(S):
  while S <= 0 do
    ; // 等待资源可用
  S = S - 1; // 申请资源

V(S):
  S = S + 1; // 释放资源

 1 #include <stdio.h>
 2 #include <pthread.h>
 3 
 4 int S = 1;  // 信号量
 5 
 6 pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
 7 pthread_cond_t condition = PTHREAD_COND_INITIALIZER;
 8 
 9 // P（wait）操作
10 void P() {
11     pthread_mutex_lock(&mutex);
12 
13     while (S <= 0) {
14         // 等待资源可用
15         pthread_cond_wait(&condition, &mutex);
16     }
17 
18     // 申请资源
19     S--;
20 
21     pthread_mutex_unlock(&mutex);
22 }
23 
24 // V（signal）操作
25 void V() {
26     pthread_mutex_lock(&mutex);
27 
28     // 释放资源
29     S++;
30 
31     // 唤醒等待资源的线程
32     pthread_cond_signal(&condition);
33 
34     pthread_mutex_unlock(&mutex);
35 }
36 
37 void* producer(void* arg) {
38     while (1) {
39         P();  // 申请资源
40 
41         // 生产者的操作
42 
43         V();  // 释放资源
44     }
45     return NULL;
46 }
47 
48 void* consumer(void* arg) {
49     while (1) {
50         P();  // 申请资源
51 
52         // 消费者的操作
53 
54         V();  // 释放资源
55     }
56     return NULL;
57 }
58 
59 int main() {
60     pthread_t producer_thread, consumer_thread;
61 
62     // 创建生产者和消费者线程
63     pthread_create(&producer_thread, NULL, producer, NULL);
64     pthread_create(&consumer_thread, NULL, consumer, NULL);
65 
66     // 主线程等待线程结束
67     pthread_join(producer_thread, NULL);
68     pthread_join(consumer_thread, NULL);
69 
70     return 0;
71 }