Linux线程同步之信号量-CSDN博客

本文链接：https://blog.csdn.net/qq_28576837/article/details/140730308

Linux中，信号量是实际开发中，实现线程同步的常用方式。

注：互斥锁处理互斥访问或者原子操作的问题；条件变量和信号量解决的是线程同步的问题。宏观上，应该都可以称为线程同步的问题，因为本质都是让线程有先后顺序。不必过于纠结。

在linux中，线程就相当于一个轻量级的进程，它常常被用来完成某种特定功能的事情。假如一个进程创建了多个线程，这些线程要一起配合完成一件更大的事情，这个时候就需要用到线程同步机制了。在Linux中通常用信号量实现线程间的同步。

信号量分为有名信号量和无名信号量，实际上线程间同步用的是无名信号量，进程间同步才用有名信号量（也可以用无名信号量进行进程间同步）。

使用信号量需要包含头文件semaphore.h，且编译时需要链接库-lrt或者-lpthread。

主要参考：

linux线程同步方式3——信号量（semaphore）_linux c++ 跨进程的信号量semaphore.h-CSDN博客

补充参考：

无名信号量——线程间同步 - Suzkfly - 博客园 (cnblogs.com)

信号量基本操作如下：

信号量初始化
发送信号量
将信号量值加 1
等待信号量
当信号量值为 0 时，程序等待；当信号量值大于 0 时，信号量减 1，程序继续运行。
销毁信号量。

对应的posix的API如下：

信号量初始化sem_init

对由sem指定的信号量进行初始化，设置好它的共享选项，并指定一个整数类型的初始值
 int sem_init (sem_t *sem , int pshared, unsigned int value);
调用成功时返回0，失败返回-1.

sem：初始化的信号量
pshared：信号量共享的范围。

　　　　　　　　0：线程间使用。

　　　　　　　　非0：进程间使用。
value：信号量的初始值；

信号量等待sem_wait

该函数用于以原子操作的方式将信号量的值减1。原子操作就是，如果两个线程企图同时给一个信号量加1或减1，它们之间不会互相干扰。

如果信号量的值大于0，将信号量的值减1，立即返回。如果信号量的值为0，则线程阻塞。直到该信号量值为非0值，相当于P操作。
int sem_wait(sem_t *sem);
调用成功时返回0，失败返回-1.

sem：指向的对象是由sem_init调用初始化的信号量

发送（释放）信号量sem_post

以原子操作的方式将信号量的值加1。当信号量的值大于0时，其它正在调用sem_wait等待信号量的线程将被唤醒，选择机制同样是由线程的调度策略决定的。
int sem_post(sem_t *sem);
调用成功时返回0，失败返回-1.

sem：指向的对象是由sem_init调用初始化的信号量

销毁信号量 sem_destroy

用于对用完的信号量的清理
int sem_destroy(sem_t *sem);
sem：是要销毁的信号量

只有用sem_init初始化的信号量才能用sem_destroy销毁。

使用演示

我们还是以上述打印一句完整的话为例来讲解信号量。

需要包含头文件：#include <semaphore.h>

一开始的程序是这样的：
static void *thread_fun1(void *param)
{
    while(1)
    {
        printf("this is a ");
        sem_post(&sem);
    }
    
    return NULL;
}

static void *thread_fun2(void *param)
{
    while(1)
    {
        sem_wait(&sem);
        printf("test for condition var\n");
        printf("---------------------------------\n"); 
    }
    
    return NULL;
}
发现有问题

问题在哪呢？那就是执行线程1的时候，可能程序会执行好多次，然后一直在释放信号量，信号量的值就会很大，当线程2获取到信号量的时候，又因为信号量可能很大，所以会连续打印很多次。因此没办法连成一句完整的话。

我的本意是，当线程1执行一次后，就线程2执行，然后反复循环，每次都是打印一句完整的话。

需要改进，让线程1执行一次后，阻塞一段时间，让线程2有机会被执行。
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#include <semaphore.h>

static sem_t sem;

static void *thread_fun1(void *param)
{
    int sval = 0;

    while(1)
    {
        printf("this is a ");
        sem_post(&sem);

        sem_getvalue(&sem, &sval);
        if(sval == 1)
        {
            sleep(1);
        }
    }
    
    return NULL;
}

static void *thread_fun2(void *param)
{
    while(1)
    {
        sem_wait(&sem);
        printf("test for condition var\n");
        printf("---------------------------------\n"); 
    }
    
    return NULL;
}

int main(int argc, char *argv[])
{
    pthread_t tid1, tid2;
    int ret;

    //init semaphore
    ret = sem_init(&sem, 0, 0);
    if (ret < 0) 
    {
        printf("sem_init failed\n");
        exit(-1);
    }

    ret = pthread_create(&tid1, NULL, thread_fun1, NULL);
    if (ret < 0)
    {
         printf("ERROR; return code from pthread_create() is %d\n", ret);
         exit(-1);
    }

    ret = pthread_create(&tid2, NULL, thread_fun2, NULL);
    if (ret < 0)
    {
         printf("ERROR; return code from pthread_create() is %d\n", ret);
         exit(-1);
    }

    pthread_exit(NULL);
}
相对条件变量来说，好用很多。

另外，补充下上述涉及到的一个测试信号量函数sem_getvalue
int sem_getvalue(sem_t *sem, int *sval);
获取信号量 sem 的当前值，把该值保存在 sval，若有 1 个或者多个线程正在调用 sem_wait 阻塞在该信号量上，该函数返回阻塞在该信号量上进程或线程个数。

信号量与条件变量的区别

应用场景：信号量即可用于进程间同步，也可用于线程间同步；条件变量只能用于线程间。

用法上：条件变量需要和互斥锁配合使用，而信号量之间使用就可以，所以信号量更像是条件变量和互斥锁的组合，所以必然的条件变量的使用会比信号量的使用更加灵活。毕竟，后出现的技术比之前的必然要有先进性（能解决特定的需求），才有其存在的意义。

底层实现上：信号量内部以计数方式来判定是否阻塞（有累计数量的功能），计数单次加减1即每次只能唤醒一个进程或线程。而条件变量以“自定义条件”来判定是否阻塞（优点来了），那么它就可以唤醒一个线程或所有线程（notify_all类似广播）。