利用信号量解决线程同步与互斥——以生产者消费者模型为例

线程同步和互斥的概念

        线程同步就是把同一进程环境下的一组并发线程，因直接制约而互相发送消息而进行互相合作、互相等待，使得各线程按一定的速度执行的过程。互斥是指不允许两个以上的共享该资源的并发线程同时进入临界区。其中直接制约是指同一进程环境下的一组并发线程，各自的执行结果互为对方的执行条件，从而限制各进程的执行速度的过程。由于共享某一共有资源而引起的在临界区内不允许并发线程交叉执行的现象，由共享共有资源而造成的对并发线程执行速度的间接制约简称为间接制约。受间接制约的类中各程序段在执行顺序上是任意的。我们将不允许多个并发线程交叉执行的一段程序称为临界区。临界区是由属于不同并发线程的程序段共享公用数据或公用数据变量而引起的。

        线程互斥是线程之间发生的一种间接性作用，由两个或两个以上的线程需要同时访问某个共享变量，因竞争共有资源而引起的间接制约带来的。两个线程不能同时进入临界区，否则就会导致数据的不一致，产生与时间有关的错误。线程的同步则是程序共享私有资源造成直接制约。所以为了增强计算机系统的处理能力和提高资源利用率所采取一种同时操作技术，即程序的并发执行。并发的实质是一个处理器在几个进程或多个进程之间的多路复用，并发是对有限的物理资源强制行使多用户共享，并且充分发挥硬件的并行性，以提高系统资源的利用率。进程的并发性可以调度多个多道程序增加资源的利用率，同时给用户信息的及时响应。

        如何实现并发线程的互斥？一种可能的办法是对临界区加锁以实现互斥。当某个线程进入临界区之后，它将锁上临界区，直到它退出临界区时为止。不过这种实现方法不能够保证并发线程互斥执行所要求的忙则等待的原则。

        因此引入信号量，信号量相当于多把锁, 可以理解为是加强版的互斥锁，可以实现忙则等待，用互斥锁只能实现生产一个消费一个，由于不能保证子线程执行的顺序，程序可能崩掉。原因就是没有等待阻塞。即生产者没有生产，消费者先消费就会出现错误。

相关函数

  1 定义信号量变量
        sem_t sem1;
        sem_t sem2;
    2 初始化信号量
        sem_init(&sem1, 0, 5);
        sem_init(&sem2, 0, 0);//第三个参数0——>消费者先阻塞
    3 加锁
        sem_wait(&sem1);
        //共享资源
        sem_post(&sem2);
        
        sem_wait(&sem2);
        //共享资源
        sem_post(&sem1);
    4 释放资源
        sem_destroy(sem1);
        sem_destroy(sem2);

代码如下：

#include<iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>
using namespace std;
typedef struct node
{
    int data;
    struct node*next;
}NODE;
 NODE*head=NULL;
 //定义信号量
sem_t sem_producer;
sem_t sem_consumer;
 void *producer(void *arg)
{
        NODE *pNode = NULL;
        while(1)
        {
                //生产一个节点
                pNode = (NODE *)malloc(sizeof(NODE));
                if(pNode==NULL)
                {
                        perror("malloc error");
                        exit(-1);
                }
                pNode->data = rand()%1000;
                printf("P:[%d]\n", pNode->data);

                //加锁
                sem_wait(&sem_producer); //--

                pNode->next = head;
                head = pNode;

                //解锁
                sem_post(&sem_consumer);  //相当于++

                sleep(rand()%3);
        }
}
//消费者线程
void *consumer(void *arg)
{
        NODE *pNode1 = NULL;
        while(1)
        {
                //加锁
                sem_wait(&sem_consumer); //相当于--(消费者消费了一个）

                printf("C:[%d]\n", head->data);
                pNode1 = head;
                head = head->next;

                //解锁
                sem_post(&sem_producer); //相当于++（生产者生产一个）

                free(pNode1);
                pNode1 = NULL;

                sleep(rand()%3);
        }
}
int main()
{
        int ret;
        pthread_t thread1;
        pthread_t thread2;

        //初始化信号量
        sem_init(&sem_producer, 0, 5);
        sem_init(&sem_consumer, 0, 0);

        //创建生产者线程
        ret = pthread_create(&thread1, NULL, producer, NULL);
        if(ret!=0)
        {
                cout << "pthread_create error, [" << strerror(ret) << "]" << endl;
                return -1;
        }

        //创建消费者线程
        ret = pthread_create(&thread2, NULL, consumer, NULL);
        if(ret!=0)
        {
                cout << "pthread_create error, [" << strerror(ret) << "]" << endl;
                return -1;
        }

        //等待线程结束
        pthread_join(thread1, NULL);
        pthread_join(thread2, NULL);

        //释放信号量资源
        sem_destroy(&sem_producer);
        sem_destroy(&sem_consumer);

        return 0;
}

 

运行结果如下，程序多次执行无误，因为消费者如果没有消费的资源就会有等待阻塞功能 。不会出现它先执行导致程序出错。