【Linux多线程】信号量以及线程池

最新推荐文章于 2024-07-12 15:10:30 发布
最新推荐文章于 2024-07-12 15:10:30 发布
阅读量884 收藏 31
点赞数 42
分类专栏： Linux 文章标签： linux 运维 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74215144/article/details/137361459
版权
本文介绍了Linux中的POSIX信号量和SystemV信号量，它们在进程间通信中的应用，以及如何在生产者消费者模型中使用信号量实现线程同步。特别关注了基于环形队列的生产者消费者案例，并扩展至多生产者多消费者场景下的线程池实现。
摘要由CSDN通过智能技术生成

【Linux多线程】信号量以及线程池

目录

作者：爱写代码的刚子

时间：2024.4.2

前言：本篇博客将会介绍Linux线程中的信号量以及线程池，完善生产者消费者模型

POSIX（可移植操作系统接口）信号量和 System V 信号量是两种不同的 IPC（进程间通信）机制，用于在多个进程之间同步和共享资源。它们有一些区别，下面是它们的主要区别：

  1. API 和标准：

    • POSIX 信号量：基于 POSIX 标准，通常在 Unix 系统上实现。
    • System V 信号量：System V IPC（Inter-Process Communication）是 Unix 系统上的一种 IPC 机制，其中包括信号量、消息队列和共享内存。

  2. 命名：

    • POSIX 信号量可以命名，因此可以在不相关的进程之间共享。
    • System V 信号量通常是匿名的，只能由相关的进程共享。

  3. 使用方式：

    • POSIX 信号量使用 sem_init()、sem_wait()、sem_post() 等函数进行操作。
    • System V 信号量使用 semget()、semop()、semctl() 等函数进行操作。

  4. 错误处理：

    • POSIX 信号量的错误处理更为简单，通常通过返回值或者设置全局变量 errno 来表示错误。
    • System V 信号量的错误处理相对复杂，需要通过检查返回值和设置 errno 来判断错误。

  5. 删除：

    • POSIX 信号量在系统关闭时会自动删除，不需要显式删除。
    • System V 信号量需要显式调用 semctl() 来删除。

  6. 可移植性：

    • POSIX 信号量具有更好的可移植性，因为 POSIX 是一个标准，因此可以在不同的系统上使用相同的 API。
    • System V 信号量在不同的 Unix 系统之间的行为可能会有所不同。

POSIX信号量

POSIX信号量和SystemV信号量作用相同，都是用于同步操作，达到无冲突的访问共享资源目的。 但POSIX可以用于线程间同步。

信号量的本质是一把计数器(临界资源的数量)，类似不等同于int cnt = n,描述临界资源中资源数量的多少。

  1. 申请计数器成功，就表示具有访问资源的权限了
  2. 申请了计数器资源，不代表当前访问了资源，申请了计数器资源是对资源的预定机制
  3. 计数器可以有效保证进入共享资源的执行流的数量

信号量只是限定进入共享资源执行流的数量，但是需要我们程序员来保证每个执行流访问自己的资源

信号量用来描述资源数目，把资源是否就绪放在了临界区之外，申请信号量时其实就间接的已经在做判断了

初始化信号量

#include <semaphore.h>
int sem_init(sem_t *sem, int pshared, unsigned int value); 
参数:
	pshared:0表示线程间共享，非零表示进程间共享 
  value:信号量初始值

在这里插入图片描述

销毁信号量

int sem_destroy(sem_t *sem);

在这里插入图片描述

等待信号量

功能:等待信号量，会将信号量的值减1 
int sem_wait(sem_t *sem); //P()

在这里插入图片描述

发布信号量

功能:发布信号量，表示资源使用完毕，可以归还资源了。将信号量值加1。 
int sem_post(sem_t *sem);//V()

在这里插入图片描述

上一篇生产者-消费者的例子是基于queue的,其空间可以动态分配,现在基于固定大小的环形队列重写这个程序 (POSIX信号量):

基于环形队列的生产者消费者模型

  • 环形队列采用数组模拟，用模运算来模拟环形特征

在这里插入图片描述

  • 环形结构起始状态和结束状态都是一样的（指向的都是同一个位置），无法判断为空或者为满，
  • 所以可以通过加计数器或者标记位来判断满或者空。另外也可以预留一个空的位置，作为满的状态

在这里插入图片描述

  • 但是我们有信号量这个计数器，就很简单的进行多线程间的同步过程
  • 指向同一个位置，只能一个人访问：

空：生产者访问（P（生产者）关注还剩余多少空间）

满：消费者访问（C（消费者）关注还剩余多少数据）

所以我们需要两个信号量

  • 小demo实验

Main.cc

#pragma once
#include <iostream>
#include <vector>
#include <semaphore.h>

const static int defaultcap = 5;

template <class T>
class RingQueue
{
private:
    void P(sem_t &sem)//申请信号量
    {
        sem_wait(&sem);

    }
    void V(sem_t &sem)//释放信号量
    {
        sem_post(&sem);
    }

public:
    RingQueue(int cap = defaultcap)
    :ringqueue_(cap),cap_(cap),c_step_(0),p_step_(0)
    {
        sem_init(&cdata_sem_,0,0);//第二个参数为0表示线程间共享，非0表示进程间共享
        sem_init(&cspace_sem_,0,cap);
    
    }

    //在环形队列为空或为满时能表现出局部的互斥特征
    void Push(const T&in)
    {
        P(cspace_sem_);
        ringqueue_[p_step_] = in;
        V(cdata_sem_);

        //位置后移，维持环形操作
        p_step_++;
        p_step_ %= cap_;

    }
    void Pop(T*out)
    {
        P(cdata_sem_);
        *out = ringqueue_[c_step_];
        V(cspace_sem_);

        c_step_++;
        c_step_%=cap_;
    }


    ~RingQueue(){
        sem_destroy(&cdata_sem_);
        sem_destroy(&cspace_sem_);
    }
private:
    std::vector<T> ringqueue_;
    int cap_;

    int c_step_;//消费者下标
    int p_step_;//生产者下标

    sem_t cdata_sem_;//消费者关心数据资源
    sem_t cspace_sem_;//生产者关心空间资源
};

RingQueue.hpp:

#pragma once
#include <iostream>
#include <vector>
#include <semaphore.h>

const static int defaultcap = 5;

template <class T>
class RingQueue
{
private:
    void P(sem_t &sem)//申请信号量
    {
        sem_wait(&sem);

    }
    void V(sem_t &sem)//释放信号量
    {
        sem_post(&sem);
    }

public:
    RingQueue(int cap = defaultcap)
    :ringqueue_(cap),cap_(cap),c_step_(0),p_step_(0)
    {
        sem_init(&cdata_sem_,0,0);//第二个参数为0表示线程间共享，非0表示进程间共享
        sem_init(&cspace_sem_,0,cap);
    }

    //在环形队列为空或为满时能表现出局部的互斥特征
    void Push(const T&in)
    {
        P(cspace_sem_);
        ringqueue_[p_step_] = in;
        V(cdata_sem_);

        //位置后移，维持环形操作
        p_step_++;
        p_step_ %= cap_;

    }
    void Pop(T*out)
    {
        P(cdata_sem_);
        *out = ringqueue_[c_step_];
        V(cspace_sem_);

        c_step_++;
        c_step_%=cap_;
    }
    ~RingQueue(){
        sem_destroy(&cdata_sem_);
        sem_destroy(&cspace_sem_);
    }
private:
    std::vector<T> ringqueue_;
    int cap_;

    int c_step_;//消费者下标
    int p_step_;//生产者下标

    sem_t cdata_sem_;//消费者关心数据资源
    sem_t cspace_sem_;//生产者关心空间资源
};

在这里插入图片描述

注意，这个是在单生产者单消费者的情况下能够保证线程安全，因为生产者和消费者的下标表示是不同的，同时信号量在环形队列为空或为满时能表现出局部的互斥特征，但是在多生产者和多消费者的场景中可能会对同一个下标产生竞争，不能保证线程安全

改进代码使其满足多生产多消费的场景：

生产者与消费者的互斥关系已经由信号量来维护了，但是生产者与生产者，消费者与消费者之间的互斥关系还是需要我们自己来维护！

我们采用先申请信号量再加锁（理由：1. 信号量资源是不需要被保护的，它本身就是原子的 2. 如果先申请锁，那么申请锁和申请信号量就会变成串行，反之先申请信号量能一定程度上变成并行（提高并发量））

采用了环形队列，当队列不为空不为满时，生产者和消费者不会互相干扰，因为采用的是不同的下标，但是队列为空为满时，由信号量来维护生产者和消费者之间的关系(重点)

改进后的完整代码：

RingQueue.hpp:

#pragma once
#include <iostream>
#include <vector>
#include <semaphore.h>

const static int defaultcap = 5;

template <class T>
class RingQueue
{
private:
    void P(sem_t &sem)//申请信号量
    {
        sem_wait(&sem);

    }
    void V(sem_t &sem)//释放信号量
    {
        sem_post(&sem);
    }

    void Lock(pthread_mutex_t &mutex)
    {
        pthread_mutex_lock(&mutex);
    }

    void Unlock(pthread_mutex_t &mutex)
    {
        pthread_mutex_unlock(&mutex);
    }

public:
    RingQueue(int cap = defaultcap)
    :ringqueue_(cap),cap_(cap),c_step_(0),p_step_(0)
    {
        sem_init(&cdata_sem_,0,0);//第二个参数为0表示线程间共享，非0表示进程间共享
        sem_init(&cspace_sem_,0,cap);
    
        pthread_mutex_init(&c_mutex_,nullptr);
        pthread_mutex_init(&p_mutex_,nullptr);
    }

    //在环形队列为空或为满时能表现出局部的互斥特征
    void Push(const T&in)
    { 
        P(cspace_sem_);
        Lock(p_mutex_);
        ringqueue_[p_step_] = in;

        //位置后移，维持环形操作
        p_step_++;
        p_step_ %= cap_;
        Unlock(p_mutex_);

        V(cdata_sem_);

    }
    void Pop(T*out)
    {
        P(cdata_sem_);
        Lock(c_mutex_);
        *out = ringqueue_[c_step_];
        
        c_step_++;
        c_step_%=cap_;
        Unlock(c_mutex_);
        V(cspace_sem_);
    }
    ~RingQueue(){
        sem_destroy(&cdata_sem_);
        sem_destroy(&cspace_sem_);

        pthread_mutex_destroy(&c_mutex_);
        pthread_mutex_destroy(&p_mutex_);
    }
private:
    std::vector<T> ringqueue_;
    int cap_;

    int c_step_;//消费者下标
    int p_step_;//生产者下标

    sem_t cdata_sem_;//消费者关心数据资源
    sem_t cspace_sem_;//生产者关心空间资源

    pthread_mutex_t c_mutex_;
    pthread_mutex_t p_mutex_;
};

Task.hpp

#pragma once
#include <iostream>
#include <string>

std::string opers = "+-*/%";

enum
{
    DivZero = 1,
    ModZero,
    Unknown
};

class Task
{
public:
    Task(int x, int y, char op) : data1_(x), data2_(y), oper_(op), result_(0), exitcode_(0)
    {
    }
    Task(){}
    void run()
    {
        switch (oper_)
        {
            case '+':
                result_ = data1_ + data2_;
                break;
            case '-':
                result_ = data1_ - data2_;
                break;
            case '*':
                result_ = data1_ * data2_;
                break;
            case '/':
            {
                if (data2_ == 0)
                    exitcode_ = DivZero;
                else
                    result_ = data1_ / data2_;
            }
            break;
            case '%':
            {
                if (data2_ == 0)
                    exitcode_ = ModZero;
                else
                    result_ = data1_ % data2_;
            }
            break;
            default:
                exitcode_ = Unknown;
                break;
        }
    }
    void operator ()()
    {
        run();
    }
    std::string GetResult()
    {
         std::string r = std::to_string(data1_);
        r += oper_;
        r += std::to_string(data2_);
        r += "=";
        r += std::to_string(result_);
        r += "[code: ";
        r += std::to_string(exitcode_);
        r += "]";
        return r;
    }

    std::string GetTask()
    {
        std::string r = std::to_string(data1_);
        r+=oper_;
        r += std::to_string(data2_);
        r += "=?";
        return r;
    }

    ~Task()
    {}

private:
    int data1_;
    int data2_;
    char oper_;

    int result_;
    int exitcode_;
};

Main.cc

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <ctime>
#include "RingQueue.hpp"
#include "Task.hpp"

using namespace std;

struct ThreadData
{
    RingQueue<Task> *rq;
    std::string threadname;
};

void *Productor(void *args)
{
    // sleep(3);
    ThreadData *td = static_cast<ThreadData*>(args);
    RingQueue<Task> *rq = td->rq;
    std::string name = td->threadname;
    int len = opers.size();
    while (true)
    {
        // 1. 获取数据
        int data1 = rand() % 10 + 1;
        usleep(10);
        int data2 = rand() % 10;
        char op = opers[rand() % len];
        Task t(data1, data2, op);

        // 2. 生产数据
        rq->Push(t);
        cout << "Productor task done, task is : " << t.GetTask() << " who: " << name << endl;

        sleep(1);
    }
    return nullptr;
}

void *Consumer(void *args)
{
    ThreadData *td = static_cast<ThreadData*>(args);
    RingQueue<Task> *rq = td->rq;
    std::string name = td->threadname;

    while (true)
    {
        // 1. 消费数据
        Task t;
        rq->Pop(&t);
       
        // 2. 处理数据
        t();
        cout << "Consumer get task, task is : " << t.GetTask() << " who: " << name << " result: " << t.GetResult() << endl;
        // sleep(1);

    }
    return nullptr;
}

int main()
{
    srand(time(nullptr) ^ getpid());
    RingQueue<Task> *rq = new RingQueue<Task>(50);

    pthread_t c[5], p[3];

    for (int i = 0; i < 1; i++)
    {
        ThreadData *td = new ThreadData();
        td->rq = rq;
        td->threadname = "Productor-" + std::to_string(i);

        pthread_create(p + i, nullptr, Productor, td);
    }
    for (int i = 0; i < 1; i++)
    {
        ThreadData *td = new ThreadData();
        td->rq = rq;
        td->threadname = "Consumer-" + std::to_string(i);

        pthread_create(c + i, nullptr, Consumer, td);
    }

    for (int i = 0; i < 1; i++)
    {
        pthread_join(p[i], nullptr);
    }
    for (int i = 0; i < 1; i++)
    {
        pthread_join(c[i], nullptr);
    }

    return 0;
}

线程池

/*threadpool.h*/ 
/* 线程池:
* 一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着 监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利 用，还能防止过分调度。可用线程数量应该取决于可用的并发处理器、处理器内核、内存、网络sockets等的数量。
* 线程池的应用场景:
* 1. 需要大量的线程来完成任务，且完成任务的时间比较短。 WEB服务器完成网页请求这样的任务，使用线程池技 术是非常合适的。因为单个任务小，而任务数量巨大，你可以想象一个热门网站的点击次数。 但对于长时间的任务，比如一个 Telnet连接请求，线程池的优点就不明显了。因为Telnet会话时间比线程的创建时间大多了。
* 2. 对性能要求苛刻的应用，比如要求服务器迅速响应客户请求。
* 3. 接受突发性的大量请求，但不至于使服务器因此产生大量线程的应用。突发性大量客户请求，在没有线程池情 况下，将产生大量线程，虽然理论上大部分操作系统线程数目最大值不是问题，短时间内产生大量线程可能使内存到达极限， 出现错误.
* 线程池的种类: * 线程池示例:
* 1. 创建固定数量线程池，循环从任务队列中获取任务对象，
* 2. 获取到任务对象后，执行任务对象中的任务接口
*/

Main.cc

#include <iostream>
#include <ctime>
#include "ThreadPool.hpp"
#include "Task.hpp"


pthread_spinlock_t slock;


int main()
{
    // pthread_spin_init(&slock, 0);
    // pthread_spin_destroy(&slock);

    std::cout << "process runn..." << std::endl;
    sleep(3);
    // ThreadPool<Task> *tp = new ThreadPool<Task>(5);
    ThreadPool<Task>::GetInstance()->Start();
    srand(time(nullptr) ^ getpid());

    while(true)
    {
        //构建任务
        int x = rand() % 10 + 1;
        usleep(10);
        int y = rand() % 5;
        char op = opers[rand()%opers.size()];

        Task t(x, y, op);
        ThreadPool<Task>::GetInstance()->Push(t);
        //交给线程池处理
        std::cout << "main thread make task: " << t.GetTask() << std::endl;

        sleep(1);
    }
}

ThreadPool.hpp

#pragma once

#include <iostream>
#include <vector>
#include <string>
#include <queue>
#include <pthread.h>
#include <unistd.h>

struct ThreadInfo
{
    pthread_t tid;
    std::string name;
};

static const int defalutnum = 5;

template <class T>
class ThreadPool
{
public:
    void Lock()
    {
        pthread_mutex_lock(&mutex_);
    }
    void Unlock()
    {
        pthread_mutex_unlock(&mutex_);
    }
    void Wakeup()
    {
        pthread_cond_signal(&cond_);
    }
    void ThreadSleep()
    {
        pthread_cond_wait(&cond_, &mutex_);
    }
    bool IsQueueEmpty()
    {
        return tasks_.empty();
    }
    std::string GetThreadName(pthread_t tid)
    {
        for (const auto &ti : threads_)
        {
            if (ti.tid == tid)
                return ti.name;
        }
        return "None";
    }

public:
    static void *HandlerTask(void *args)
    {
        ThreadPool<T> *tp = static_cast<ThreadPool<T> *>(args);
        std::string name = tp->GetThreadName(pthread_self());
        while (true)
        {
            tp->Lock();

            while (tp->IsQueueEmpty())
            {
                tp->ThreadSleep();
            }
            T t = tp->Pop();
            tp->Unlock();

            t();
            std::cout << name << " run, "
                      << "result: " << t.GetResult() << std::endl;
        }
    }
    void Start()
    {
        int num = threads_.size();
        for (int i = 0; i < num; i++)
        {
            threads_[i].name = "thread-" + std::to_string(i + 1);
            pthread_create(&(threads_[i].tid), nullptr, HandlerTask, this);
        }
    }
    T Pop()
    {
        T t = tasks_.front();
        tasks_.pop();
        return t;
    }
    void Push(const T &t)
    {
        Lock();
        tasks_.push(t);
        Wakeup();
        Unlock();
    }
    static ThreadPool<T> *GetInstance()
    {
        if (nullptr == tp_) // ???
        {
            pthread_mutex_lock(&lock_);
            if (nullptr == tp_)
            {
                std::cout << "log: singleton create done first!" << std::endl;
                tp_ = new ThreadPool<T>();
            }
            pthread_mutex_unlock(&lock_);
        }

        return tp_;
    }

private:
    ThreadPool(int num = defalutnum) : threads_(num)
    {
        pthread_mutex_init(&mutex_, nullptr);
        pthread_cond_init(&cond_, nullptr);
    }
    ~ThreadPool()
    {
        pthread_mutex_destroy(&mutex_);
        pthread_cond_destroy(&cond_);
    }
    ThreadPool(const ThreadPool<T> &) = delete;
    const ThreadPool<T> &operator=(const ThreadPool<T> &) = delete; // a=b=c
private:
    std::vector<ThreadInfo> threads_;
    std::queue<T> tasks_;

    pthread_mutex_t mutex_;
    pthread_cond_t cond_;

    static ThreadPool<T> *tp_;
    static pthread_mutex_t lock_;
};

template <class T>
ThreadPool<T> *ThreadPool<T>::tp_ = nullptr;

template <class T>
pthread_mutex_t ThreadPool<T>::lock_ = PTHREAD_MUTEX_INITIALIZER;
爱写代码的刚子
关注
专栏目录
线程同步方式——信号量
萧海的博客
06-08 2219
1 信号量 信号量(Semaphore)，有时被称为信号灯，是在多线程环境下使用的一种设施，是可以用来保证两个或多个关键代码段不被并发调用。 在进入一个关键代码段之前，线程必须获取一个信号量；一旦该关键代码段完成了，那么该线程必须释放信号量。其它想进入该关键代码段的线程必须等待直到第一个线程释放信号量。为了完成这个过程，需要创建一个信号量VI，然后将Acquire Semaphore VI以及Release Semaphore VI分别放置在每个关键代码段的首末端。确认这些信号量VI引用的是初始创建的信号量
详解Linux多线程使用信号量同步
01-20
如果一个程序中有多个线程试图改变一个信号量的值，系统将保证所有的操作都将依次进行。 而只有0和1两种取值的信号量叫做二进制信号量，在这里将重点介绍。而信号量一般常用于保护一段代码，使其每次只被一个执行...
linux线程笔记9
01-09 256
线程同步和互斥---线程信号量 信号量从本质上是一个非负整数计数器，是共享资源的数目，通常被用来控制对共享资源的访问。 信号量可以实现线程的同步和互斥 通过sem_post()和wem_wait()函数对信号量进行加减操作从而解决线程的同步和互斥。 信号量数据类型 sem_t 信号量的创建和销毁 #include int sem_init(sem_t *sem,int pshar
【线程系列之四】信号量介绍
最新发布
qq_40604302的博客
07-12 694
如果信号量的值大于0，则将其减1，表示有一个资源被占用，线程或进程可以继续执行。如果信号量的值为0，则线程或进程将被阻塞，直到信号量的值大于0。当线程或进程完成对资源的访问后，它会执行V操作，将信号量的值加1，表示释放了一个资源。如果有其他线程或进程因为信号量的值为0而被阻塞，那么其中一个（或多个，取决于具体的实现）将被唤醒以继续执行。创建的信号量是未命名的，实际上在多个进程间共享这样的信号量需要其他机制，如通过共享内存映射）。然而，在更复杂的场景中，信号量的值可能会因为其他线程或进程的操作而改变。
多线程——信号量、条件变量、互斥量互斥锁
qq_44423388的博客
11-05 3389
信号量是所有原语里面功能最强大的。它不光是一个通信原语，还是一个同步原语。 多线程——信号量、条件变量、互斥量互斥锁
Linux线程安全之---信号量
weixin_45897952的博客
05-14 1331
目录 1.信号量： 1.1、信号量的原理 1.2、信号量的接口 1.2.1、初始化接口： 1.2.2、等待接口： 1.2.3、释放接口： 1.2.4、销毁接口： 2.生产者与消费者信号量代码实现： 3.线程池： 3.1、应用场景 3.2、原理： 3.3、构造线程池要完成的事情 3.4、代码实现 4.读写锁 4.1、应用场景： 4.2、读写锁的三种状态 4.3、读写锁的接口： 面试题： 1.信号量： 1.1、信号量的原理 资源计数器+PCB等待队列
线程间通信——信号量
qq_48633111的博客
01-04 2375
一、信号量 信号量就是操作系统中所用到的PV原子操作，它广泛用于进程或线程间的同步与互斥。信号量本质上是一个非负的整数计数器，它被用来控制对公共资源的访问。 PV原子操作主要用于进程或线程间的同步和互斥这两种典型情况。若用于互斥，几个进程（或线程）往往只设置一个信号量sem，如图1。 当信号量用于同步操作时，往往设置多个信号量，并安排不同的初始值来实现它们之间的顺序执行，它们的操作如图。 二、主要函数 #include <semaphore...
Linux系统下的多线程编程入门.pdf
07-14
在Linux系统中，多线程编程是开发高效并发应用程序的关键技术。线程是操作系统调度的基本单位，它允许在一个进程中执行多个并发线程，共享资源，从而提高程序的响应速度和系统资源利用率。与进程相比，线程具有启动...
linux多线程服务端编程.rar
07-05
在Linux系统中，多线程...总之，Linux多线程服务端编程涉及的内容广泛，包括线程的创建、同步、通信以及服务端的架构设计、性能优化等多个方面。通过深入学习和实践，开发者可以构建出高效、稳定的多线程服务端应用。
getcard-1.0.rar_linux 多线程
09-20
在这个场景中，我们讨论的是一个名为"getcard-1.0.rar_linux 多线程"的项目，它是一个专为Linux系统设计的多线程服务。这个服务的主要功能是监控特定目录下的文件变化，对这些文件进行相应的移动操作，并将它们上传...
Linux多线程编程手册
04-08
在Linux多线程编程手册中，除了对各种API进行详细说明外，也会对常见的编程模式和设计原则进行指导，例如如何处理线程同步问题、死锁避免、线程池的使用等。此外，手册可能还会讨论特定于平台的特性，例如在Linux上...
线程同步之信号量
StudyWinter的博客
06-26 1393
由于互斥锁的粒度比较大，如果我们希望在多个线程间对某一对象的部分数据进行共享，使用互斥锁是没有办法实现的，只能将整个数据对象锁住。这样虽然达到了多线程操作共享数据时保证数据正确性的目的，却无形中导致线程的并发性下降。线程从并行执行，变成了串行执行。与直接使用单进程无异。信号量，是相对折中的一种处理方式，既能保证同步，数据不混乱，又能提高线程并发。作用：初始化一个信号量 2.2 sem_destroy函数 作用：销毁一个信号量 2.3 sem_wait函数 作用：给信号量加锁-- 2.4
多线程中的信号量
fuchangyaocool的博客
07-31 2094
信号量用在多线程多任务同步的，一个线程完成了某一个动作就通过信号量告诉别的线程，别的线程再进行某些动作。信号量不一定是锁定某一个资源，而是流程上的概念，比如：有 A，B 两个线程，B 线程要等 A 线程完成某一任务以后再进行自己下面的步骤，这个任务并不一定是锁定某一资源，还可以是进行一些计算或者数据处理之类。 信号量（信号灯）与互斥锁和条件变量的主要不同在于” 灯” 的概念，灯亮则意味着资源可用，灯灭则意味着不可用。信号量主要阻塞线程，不能完全保证线程安全，如果要保证线程安全，需要信号量和互斥锁一起使..
【Linux】线程同步之信号量（Semaphore）
m0_61011506的博客
06-05 1838
Linux信号量
＜ Linux ＞ 多线程（信号量）
bit_zyx的博客
03-15 1068
目录 1、POSIX信号量 信号量的原理 信号量的概念 信号量函数 2、基于环形队列的生产消费模型 生产者和消费者的申请和释放资源 代码实现（单生产者单消费者） 代码实现（多生产者多消费者）
最全面的 linux 信号量解析
布袋和尚
12-29 5991
在做这个之前，要确定所有对这个有名信号量的引用都已经通过 sem_close() 函数关闭了，然后只需在退出或是退出处理函数中调用 sem_unlink() 去删除系统中的信号量，注意如果有任何的处理器或是线程引用这个信号量，sem_unlink() 函数不会起到任何的作用。字创建一个新的 IPC 结构。由于有名信号量的值是保存在文件中的，所以对于相关进程来说，子进程是继承了父进程的文件描述符，那么子进程所继承的文件描述符所指向的文件是和父进程一样的，当然文件里面保存的有名信号量值就共享了。
【Linux】多线程——信号量
努力进大厂的小码娄
03-25 1062
信号量的原理概念|本质就是一把计数器和等待队列|信号量的接口PV操作|基于环形队列设计生产消费者模型，并发程度更高|节省空间资源，加锁保护
多线程 --- 信号量
m0_62229058的博客
02-27 700
参数解释：sem_t 是 POSIX 标准中定义的信号量类型。pshared： 值为0时，该信号量将被线程共享；值为非0时，该信号量将被进程共享。value： 表示信号量的初始值。返回值：成功，返回0；失败，返回相应的错误码 (errno)。
Linux 多线程：信号量
weixin_57761086的博客
03-30 693
介绍了信号量的原理，用信号量如何实现同步与互斥，以及信号量的相关接口。
Linux多线程编程详解：pthread实践与指南
Linux多线程编程指南是一份由Sun Microsystems提供的文档，专注于在Linux环境下使用POSIX线程库（pthread）进行并发编程。这份文档涵盖了多线程编程的基础概念、设计原则以及在Solaris操作系统中的应用。 1. **概述...
评论 14
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

爱写代码的刚子

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值