Linux多线程实践(5) --Posix信号量与互斥量解决生产者消费者问题

Posix信号量

Posix 信号量
有名信号量	无名信号量
sem_open	sem_init
sem_close	sem_destroy
sem_unlink
sem_wait
sem_post

 

有名信号量

[cpp] view plain copy

1. #include <fcntl.h>           /* For O_* constants */  
2. #include <sys/stat.h>        /* For mode constants */  
3. #include <semaphore.h>  
4. sem_t *sem_open(const char *name, int oflag);  
5. sem_t *sem_open(const char *name, int oflag, mode_t mode, unsigned int value);  
6. int sem_close(sem_t *sem);  
7. int sem_unlink(const char *name);  

  与Posix类IPC用法类似: 名字以/somename形式标识，且只能有一个/ ，并且总长不能超过NAME_MAX-4 (i.e., 251)。

  Posix有名信号量需要用sem_open 函数创建或打开，PV操作分别是sem_wait 和 sem_post，可以使用sem_close 关闭，删除用sem_unlink。

  有名信号量用于不需要共享内存的进程间同步(可以通过名字访问), 类似System V 信号量。

 

匿名信号量

[cpp] view plain copy

1. #include <semaphore.h>  
2. int sem_init(sem_t *sem, int pshared, unsigned int value);  
3. int sem_destroy(sem_t *sem);  

  匿名信号量只存在于内存中, 并要求使用信号量的进程必须可以访问内存; 这意味着他们只能应用在同一进程中的线程, 或者不同进程中已经映射相同内存内容到它们的地址空间中的线程.

  匿名信号量必须用sem_init 初始化，sem_init 函数的第二个参数pshared决定了线程共享(pshared=0)还是进程共享(pshared!=0)，也可以用sem_post 和sem_wait 进行操作，在共享内存释放前，匿名信号量要先用sem_destroy 销毁。

 

Posix信号量PV操作

[cpp] view plain copy

1. int sem_wait(sem_t *sem);   //P操作  
2. int sem_post(sem_t *sem);   //V操作  

  wait操作实现对信号量的减1, 如果信号量计数原先为0则会发生阻塞;

  post操作将信号量加1, 在调用sem_post时, 如果在调用sem_wait中发生了进程阻塞, 那么进程会被唤醒并且sem_post增1的信号量计数会再次被sem_wait减1;

 

Posix互斥锁

[cpp] view plain copy

1. #include <pthread.h>  
2. int pthread_mutex_init(pthread_mutex_t *mutex,   
3.                        const pthread_mutexattr_t *mutexattr);       //互斥锁初始化, 注意:函数成功执行后，互斥锁被初始化为未锁住状态。  
4. int pthread_mutex_lock(pthread_mutex_t *mutex); //互斥锁上锁  
5. int pthread_mutex_trylock(pthread_mutex_t *mutex);  //互斥锁判断上锁  
6. int pthread_mutex_unlock(pthread_mutex_t *mutex);   //互斥锁解锁  
7. int pthread_mutex_destroy(pthread_mutex_t *mutex);  //消除互斥锁  

  互斥锁是用一种简单的加锁方法来控制对共享资源的原子操作。这个互斥锁只有两种状态，也就是上锁／解锁，可以把互斥锁看作某种意义上的全局变量。在同一时刻只能有一个线程掌握某个互斥锁，拥有上锁状态的线程能够对共享资源进行操作。若其他线程希望上锁一个已经被上锁的互斥锁，则该线程就会阻塞，直到上锁的线程释放掉互斥锁为止。可以说，这把互斥锁保证让每个线程对共享资源按顺序进行原子操作。

  其中，互斥锁可以分为快速互斥锁(默认互斥锁)、递归互斥锁和检错互斥锁。这三种锁的区别主要在于其他未占有互斥锁的线程在希望得到互斥锁时是否需要阻塞等待。快速锁是指调用线程会阻塞直至拥有互斥锁的线程解锁为止。递归互斥锁能够成功地返回，并且增加调用线程在互斥上加锁的次数，而检错互斥锁则为快速互斥锁的非阻塞版本，它会立即返回并返回一个错误信息。 

 

生产者消费者问题

运用C++, 将缓冲区封装成class Storage

[cpp] view plain copy

1. //Storage类设计  
2. class Storage  
3. {  
4. public:  
5.     Storage(unsigned int _bufferSize);  
6.     ~Storage();  
7.   
8.     void consume(int id);   //消费  
9.     void produce(int id);   //生产  
10.   
11. private:  
12.     // 打印缓冲区状态  
13.     void display(bool isConsumer = false);  
14.   
15. private:  
16.     unsigned int buffSize;  
17.     int *m_storage; //缓冲区  
18.   
19.     unsigned short int in;  //生产位置  
20.     unsigned short int out; //消费位置  
21.     unsigned int product_number;    //产品编号  
22.   
23.     sem_t sem_full; //满信号量  
24.     sem_t sem_empty;//空信号量  
25.     pthread_mutex_t mutex;  //互斥量: 保护缓冲区互斥访问  
26. };  

[cpp] view plain copy

1. //Storage类实现  
2. Storage::Storage(unsigned int _bufferSize)  
3.     :buffSize(_bufferSize), in(0), out(0), product_number(0)  
4. {  
5.     m_storage = new int[buffSize];  
6.     for (unsigned int i = 0; i < buffSize; ++ i)  
7.         m_storage[i] = -1;  
8.   
9.     sem_init(&sem_full, 0, 0);  
10.     //将empty信号量初始化为缓冲区大小  
11.     sem_init(&sem_empty, 0, buffSize);  
12.     pthread_mutex_init(&mutex, NULL);  
13. }  
14.   
15. Storage::~Storage()  
16. {  
17.     delete []m_storage;  
18.   
19.     pthread_mutex_destroy(&mutex);  
20.     sem_destroy(&sem_empty);  
21.     sem_destroy(&sem_full);  
22. }  

[cpp] view plain copy

1. void Storage::produce(int id)  
2. {  
3.     printf("producer %d is waiting storage not full\n", id);  
4.     //获取empty信号量  
5.     sem_wait(&sem_empty);  
6.     //获取互斥量  
7.     pthread_mutex_lock(&mutex);  
8.   
9.     //生产  
10.     cout << "++ producer " << id << " begin produce "  
11.          << ++product_number << " ..." << endl;  
12.     m_storage[in] = product_number;  
13.     //打印此时缓冲区状态  
14.     display(false);  
15.     in = (in+1)%buffSize;  
16.     cout << "   producer " << id << " end produce ...\n" << endl;  
17.   
18.     //释放互斥量  
19.     pthread_mutex_unlock(&mutex);  
20.     //释放full信号量  
21.     sem_post(&sem_full);  
22.     sleep(1);  
23. }  
24. void Storage::consume(int id)  
25. {  
26.     printf("consumer %d is waiting storage not empty\n", id);  
27.     //获取full信号量  
28.     sem_wait(&sem_full);  
29.     //获取互斥量  
30.     pthread_mutex_lock(&mutex);  
31.   
32.     //消费  
33.     int consume_id = m_storage[out];  
34.     cout << "-- consumer " << id << " begin consume "  
35.          << consume_id << " ..." << endl;  
36.     m_storage[out] = -1;  
37.     //打印此时缓冲区状态  
38.     display(true);  
39.     out = (out+1)%buffSize;  
40.     cout << "   consumer " << id << " end consume ...\n" << endl;  
41.   
42.     //解锁互斥量  
43.     pthread_mutex_unlock(&mutex);  
44.     //释放empty信号量  
45.     sem_post(&sem_empty);  
46.     sleep(1);  
47. }  

[cpp] view plain copy

1. void Storage::display(bool isConsme)  
2. {  
3.     cout << "states: { ";  
4.     for (unsigned int i = 0; i < buffSize; ++i)  
5.     {  
6.         if (isConsme && out == i)  
7.             cout << '#';  
8.         else if (!isConsme && in == i)  
9.             cout << '*';  
10.   
11.         if (m_storage[i] == -1)  
12.             cout << "null ";  
13.         else  
14.             printf("%-4d ", m_storage[i]);  
15.     }  
16.     cout << "}" << endl;  
17. }  

[cpp] view plain copy

1. //生产者, 消费者代码实现  
2. //缓冲区  
3. Storage *storage;  
4. //生产者-线程  
5. void *producer(void *args)  
6. {  
7.     int id = *(int *)args;  
8.     delete (int *)args;  
9.   
10.     while (1)  
11.         storage->produce(id);   //生产  
12.     return NULL;  
13. }  
14. //消费者-线程  
15. void *consumer(void *args)  
16. {  
17.     int id = *(int *)args;  
18.     delete (int *)args;  
19.   
20.     while (1)  
21.         storage->consume(id);   //消费  
22.     return NULL;  
23. }  
24. //主控线程  
25. int main()  
26. {  
27.     int nProducer = 1;  
28.     int nConsumer = 2;  
29.     cout << "please input the number of producer: ";  
30.     cin >> nProducer;  
31.     cout << "please input the number of consumer: ";  
32.     cin >> nConsumer;  
33.     cout << "please input the size of buffer: ";  
34.   
35.     int size;  
36.     cin >> size;  
37.     storage = new Storage(size);  
38.   
39.     pthread_t *thread = new pthread_t[nProducer+nConsumer];  
40.     //创建消费者进程  
41.     for (int i = 0; i < nConsumer; ++i)  
42.         pthread_create(&thread[i], NULL, consumer, new int(i));  
43.     //创建生产者进程  
44.     for (int i = 0; i < nProducer; ++i)  
45.         pthread_create(&thread[nConsumer+i], NULL, producer, new int(i));  
46.   
47.     //等待线程结束  
48.     for (int i = 0; i < nProducer+nConsumer; ++i)  
49.         pthread_join(thread[i], NULL);  
50.   
51.     delete storage;  
52.     delete []thread;  
53. }  

完整源代码:http://download.csdn.net/download/hanqing280441589/8444613