信号量全面解析与使用

最新推荐文章于 2024-06-17 18:35:27 发布
最新推荐文章于 2024-06-17 18:35:27 发布
阅读量1.1k 收藏 26
点赞数 17
分类专栏： linux 文章标签： linux 开发语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sun_0228/article/details/138160558
版权
本文详细介绍了信号量在并发编程中的作用，包括基本概念、C++中使用信号量的示例，以及POSIX信号量的应用。还探讨了如何在生产者消费者模型中使用信号量和互斥锁实现线程安全的资源管理。
摘要由CSDN通过智能技术生成

文章目录

一、引言

在并发编程中，信号量（Semaphore）是一个非常重要的同步原语。它允许一定数量的线程同时访问某一资源或代码段，有效地防止了资源冲突和死锁等问题。本文将全面解析信号量在C++中的使用、功能，并给出相应的代码示例。

一、信号量的基本概念

信号量是一个整数变量，可以用来控制多个线程对共享资源的访问。它通常用于保护对临界区的访问，防止多个线程同时修改数据造成数据不一致。信号量的值表示可用的资源数量，当一个线程需要访问共享资源时，它会尝试减少信号量的值；当线程释放资源时，它会增加信号量的值。

什么是信号量？
信号量是一种计数器，用于控制对共享资源的访问。它主要由一个整型值表示，可以对其进行加减操作。在多线程环境下，通常使用信号量来实现线程的同步和互斥。

二、信号量的功能

  1. 同步：信号量可以实现线程之间的同步，确保线程在正确的时机访问共享资源。
  2. 互斥：通过设置信号量的初始值为1，可以实现互斥锁的功能，确保同一时间只有一个线程访问共享资源。
  3. 计数：信号量还可以用来限制对资源的并发访问数量，通过设置不同的初始值，可以控制同时访问资源的线程数。

三、C++中使用信号量的示例

在C++中，可以使用标准库中的std::condition_variable和std::mutex来实现信号量的功能。下面是一个简单的示例：

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>

class Semaphore {
private:
    std::mutex mtx_;
    std::condition_variable cv_;
    int count_;

public:
    Semaphore(int count) : count_(count) {}

    void wait() {
        std::unique_lock<std::mutex> lock(mtx_);
        cv_.wait(lock, [this] { return count_ > 0; });
        --count_;
    }

    void signal() {
        std::lock_guard<std::mutex> lock(mtx_);
        ++count_;
        cv_.notify_one();
    }
};

void worker(Semaphore& sem, int id) {
    sem.wait();  // 等待信号量可用
    std::cout << "Worker " << id << " is working." << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1));
    sem.signal();  // 释放信号量
}

int main() {
    Semaphore sem(3);  // 创建一个信号量，初始值为3
    std::vector<std::thread> threads;

    for (int i = 0; i < 10; ++i) {
        threads.emplace_back(worker, std::ref(sem), i);
    }

    for (auto& t : threads) {
        t.join();
    }

    return 0;
}

在上面的示例中，我们定义了一个Semaphore类，它内部使用了std::mutex和std::condition_variable来实现信号量的功能。wait方法用于等待信号量可用，而signal方法用于释放信号量。在worker函数中，线程首先调用wait方法等待信号量可用，然后执行一些工作，最后调用signal方法释放信号量。在main函数中，我们创建了一个初始值为3的信号量，并启动了10个线程。由于信号量的初始值为3，因此前3个线程可以立即开始工作，而后面的线程则需要等待其他线程释放信号量后才能开始工作。

信号量是一种强大的同步原语，可以用于控制多个线程对共享资源的访问。在C++中，我们可以通过结合使用std::mutex和std::condition_variable来实现信号量的功能。通过合理使用信号量，我们可以有效地防止资源冲突和死锁等问题，提高程序的并发性能。

四、POSIX信号量

在Linux环境下，信号量是一种重要的同步原语，用于在多线程环境下控制对共享资源的访问。下面我们将深入介绍信号量的概念、原理，并通过C语言代码示例详细解析在多线程环境下的应用。

  • sem_init(sem_t *sem, int pshared, unsigned int value)：初始化信号量，pshared指定信号量的类型，value指定初始计数值。
  • sem_wait(sem_t *sem)：等待信号量，如果信号量计数值为0，则线程会阻塞，直到计数值大于0。
  • sem_post(sem_t *sem)：增加信号量的计数值。
  • sem_destroy(sem_t *sem)：销毁信号量。
#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>

#define NUM_THREADS 2

// 共享资源
int shared_resource = 0;
// 信号量
sem_t semaphore;

// 线程函数1，增加共享资源的值
void *thread_function1(void *arg) {
    sem_wait(&semaphore); // 等待信号量
    shared_resource++; // 访问共享资源
    printf("Thread 1: shared_resource = %d\n", shared_resource);
    sem_post(&semaphore); // 释放信号量
    pthread_exit(NULL);
}

// 线程函数2，减少共享资源的值
void *thread_function2(void *arg) {
    sem_wait(&semaphore); // 等待信号量
    shared_resource--; // 访问共享资源
    printf("Thread 2: shared_resource = %d\n", shared_resource);
    sem_post(&semaphore); // 释放信号量
    pthread_exit(NULL);
}

int main() {
    pthread_t threads[NUM_THREADS];

    // 初始化信号量，初始值为1
    sem_init(&semaphore, 0, 1);

    // 创建线程
    pthread_create(&threads[0], NULL, thread_function1, NULL);
    pthread_create(&threads[1], NULL, thread_function2, NULL);

    // 等待线程结束
    pthread_join(threads[0], NULL);
    pthread_join(threads[1], NULL);

    // 销毁信号量
    sem_destroy(&semaphore);

    return 0;
}

在上述代码中，我们使用了pthread库来创建两个线程，并使用semaphore来控制对共享资源的访问。在main函数中，我们首先初始化了信号量，然后创建了两个线程，分别执行不同的操作。在每个线程函数中，我们使用sem_wait来等待信号量，表示线程需要获取共享资源的访问权限。之后，线程对共享资源进行操作，并使用sem_post释放信号量，表示操作结束。

在上述代码中，我们将信号量初始化为1，这里就相当于二元信号量（和互斥锁同理）

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

在这里插入图片描述

对于生产者和消费者来说，它们关注的资源是不同的：

  • 生产者关注的是环形队列当中是否有空间（empty），只要有空间生产者就可以进行生产。
  • 消费者关注的是环形队列当中是否有数据（full），只要有数据消费者就可以进行消费。
#include <iostream>
#include <cstring>
#include <semaphore.h>
#include <fcntl.h>           // For O_* constants
#include <sys/stat.h>        // For mode constants
#include <unistd.h>          // For close()

// 环形队列的固定大小
const int QUEUE_SIZE = 10;

// 环形队列结构
struct CircularQueue {
    int buffer[QUEUE_SIZE];
    sem_t full;    // 表示队列中当前有多少个元素
    sem_t empty;   // 表示队列中有多少个空位可以插入新元素
    int head;      // 队列头指针
    int tail;      // 队列尾指针
};

// 初始化环形队列
void initQueue(CircularQueue* queue) {
    queue->head = 0;
    queue->tail = 0;
    sem_init(&queue->full, 0, 0);  // 初始时队列为空
    sem_init(&queue->empty, 0, QUEUE_SIZE);  // 初始时队列有QUEUE_SIZE个空位
}

// 销毁环形队列
void destroyQueue(CircularQueue* queue) {
    sem_destroy(&queue->full);
    sem_destroy(&queue->empty);
}

// 入队操作
void enqueue(CircularQueue* queue, int item) {
    sem_wait(&queue->empty);  // 等待空位
    buffer[tail] = item;      // 将元素放入队列尾
    tail = (tail + 1) % QUEUE_SIZE;  // 更新尾指针
    sem_post(&queue->full);  // 增加队列中的元素数量
}

// 出队操作
int dequeue(CircularQueue* queue) {
    int item;
    sem_wait(&queue->full);  // 等待队列中有元素
    item = buffer[head];     // 取出队列头的元素
    head = (head + 1) % QUEUE_SIZE;  // 更新头指针
    sem_post(&queue->empty);  // 增加队列中的空位数量
    return item;
}

int main() {
    CircularQueue queue;
    initQueue(&queue);

    // 生产者线程入队操作
    for (int i = 0; i < 15; ++i) {
        enqueue(&queue, i);
        std::cout << "Enqueued item: " << i << std::endl;
    }

    // 消费者线程出队操作
    for (int i = 0; i < 10; ++i) {
        int item = dequeue(&queue);
        std::cout << "Dequeued item: " << item << std::endl;
    }

    destroyQueue(&queue);
    return 0;
}

我们上述代码没有处理多线程环境下可能发生的竞态条件。在真实的多线程环境中，你需要确保enqueue和dequeue操作的原子性，这通常通过使用互斥锁（如std::mutex或pthread_mutex_t）来实现。

此外，POSIX信号量在Unix-like系统上通常用于进程间同步，而不是线程间同步。

POSIX信号量（POSIX semaphores）确实最初设计用于进程间同步，允许不同进程之间协调对共享资源的访问。不过，这并不意味着信号量不能用于线程间同步。在多线程编程中，POSIX信号量同样可以发挥重要作用，特别是在需要跨线程边界进行同步时。

POSIX标准定义了两种信号量：未命名的信号量（也叫做内部或基于内存的信号量）和命名的信号量（也叫做外部或文件系统的信号量）。未命名的信号量通常用于同一进程内的线程间同步，而命名的信号量可以用于进程间同步。

在多线程应用中，如果你需要跨多个线程协调资源访问，或者确保某个代码段（临界区）不会被多个线程同时执行，可以使用未命名的POSIX信号量。这些信号量在进程地址空间内创建，可以被该进程内的所有线程共享和访问。

因此，尽管POSIX信号量最初是为进程间同步设计的，但它们同样适用于线程间同步。实际上，在Unix-like系统上，使用POSIX信号量进行线程间同步是一种常见做法，尤其是在需要跨多个线程协调资源访问时。

然而，对于线程间同步，许多现代编程语言和库也提供了其他机制，如互斥锁（mutexes）、条件变量（condition
variables）和读写锁（read-write
locks）等。这些机制通常更加轻量级，并且更易于在特定编程环境中使用。因此，在选择使用信号量还是其他同步机制时，应该根据具体的应用需求和编程环境来决定。

对于线程间同步，通常使用Pthreads库中的pthread_mutex_t和pthread_cond_t。

在实际应用中，确保正确处理信号量的初始化和销毁，避免资源泄漏，并且在不再需要时正确销毁它们。在上面的示例中，我们假设sem_init和sem_destroy用于初始化和销毁信号量，这在POSIX环境中是标准的做法。

于是我们进行下述修正

  1. 全局变量访问：在 enqueue 和 dequeue 函数中，对 buffer、head、tail 的访问是全局的，可能导致竞态条件。需要在访问这些全局变量时使用互斥锁或其他同步机制。

  2. 信号量使用：虽然使用了信号量 full 和 empty 来表示队列中的元素数量和空位数量，但在 enqueue 和 dequeue 函数中没有对这些信号量的操作进行保护，因此仍然可能存在竞态条件。

  3. 缺少互斥锁：在 enqueue 和 dequeue 函数中需要使用互斥锁来保护对共享资源的访问，以确保在多个线程同时访问时的数据一致性。

以下是修改后的代码示例，添加了互斥锁以保护对共享资源的访问：

#include <iostream>
#include <cstring>
#include <semaphore.h>
#include <fcntl.h>           // For O_* constants
#include <sys/stat.h>        // For mode constants
#include <unistd.h>          // For close()
#include <pthread.h>         // For pthread_mutex_t

// 环形队列的固定大小
const int QUEUE_SIZE = 10;

// 环形队列结构
struct CircularQueue {
    int buffer[QUEUE_SIZE];
    sem_t full;    // 表示队列中当前有多少个元素
    sem_t empty;   // 表示队列中有多少个空位可以插入新元素
    int head;      // 队列头指针
    int tail;      // 队列尾指针
    pthread_mutex_t mutex; // 互斥锁
};

// 初始化环形队列
void initQueue(CircularQueue* queue) {
    queue->head = 0;
    queue->tail = 0;
    sem_init(&queue->full, 0, 0);  // 初始时队列为空
    sem_init(&queue->empty, 0, QUEUE_SIZE);  // 初始时队列有QUEUE_SIZE个空位
    pthread_mutex_init(&queue->mutex, NULL); // 初始化互斥锁
}

// 销毁环形队列
void destroyQueue(CircularQueue* queue) {
    sem_destroy(&queue->full);
    sem_destroy(&queue->empty);
    pthread_mutex_destroy(&queue->mutex); // 销毁互斥锁
}

// 入队操作
void enqueue(CircularQueue* queue, int item) {
    sem_wait(&queue->empty);  // 等待空位
    pthread_mutex_lock(&queue->mutex); // 加锁
    queue->buffer[queue->tail] = item;      // 将元素放入队列尾
    queue->tail = (queue->tail + 1) % QUEUE_SIZE;  // 更新尾指针
    pthread_mutex_unlock(&queue->mutex); // 解锁
    sem_post(&queue->full);  // 增加队列中的元素数量
}

// 出队操作
int dequeue(CircularQueue* queue) {
    int item;
    sem_wait(&queue->full);  // 等待队列中有元素
    pthread_mutex_lock(&queue->mutex); // 加锁
    item = queue->buffer[queue->head];     // 取出队列头的元素
    queue->head = (queue->head + 1) % QUEUE_SIZE;  // 更新头指针
    pthread_mutex_unlock(&queue->mutex); // 解锁
    sem_post(&queue->empty);  // 增加队列中的空位数量
    return item;
}

int main() {
    CircularQueue queue;
    initQueue(&queue);

    // 生产者线程入队操作
    for (int i = 0; i < 15; ++i) {
        enqueue(&queue, i);
        std::cout << "Enqueued item: " << i << std::endl;
    }

    // 消费者线程出队操作
    for (int i = 0; i < 10; ++i) {
        int item = dequeue(&queue);
        std::cout << "Dequeued item: " << item << std::endl;
    }

    destroyQueue(&queue);
    return 0;
}

通过在 enqueue 和 dequeue 函数中加入互斥锁，保护了对共享资源的访问，从而确保了线程安全性。

又通过上述可知，POSIX信号量通过初始化成二元信号量可以变成互斥锁

使用二元信号量来模拟互斥锁，在初始化信号量时将初始值设置为1即可。在进入临界区之前，使用 sem_wait 函数来获得信号量；在离开临界区时，使用 sem_post 函数释放信号量。

#include <iostream>
#include <semaphore.h>

struct Mutex {
    sem_t semaphore;
};

void initMutex(Mutex* mutex) {
    sem_init(&mutex->semaphore, 0, 1); // 初始化二元信号量，初始值为1
}

void lockMutex(Mutex* mutex) {
    sem_wait(&mutex->semaphore); // 请求信号量
}

void unlockMutex(Mutex* mutex) {
    sem_post(&mutex->semaphore); // 释放信号量
}

int main() {
    Mutex mutex;
    initMutex(&mutex);

    // 进入临界区
    lockMutex(&mutex);
    std::cout << "Inside critical section" << std::endl;
    unlockMutex(&mutex);
    // 离开临界区

    return 0;
}

封装后的源码

在这里插入图片描述

#include <iostream>
#include <semaphore.h>
#include <pthread.h> // For pthread_mutex_t

class Mutex {
public:
    Mutex() {
        sem_init(&semaphore, 0, 1); // 初始化二元信号量，初始值为1
    }

    ~Mutex() {
        sem_destroy(&semaphore); // 销毁信号量
    }

    void lock() {
        sem_wait(&semaphore); // 请求信号量
    }

    void unlock() {
        sem_post(&semaphore); // 释放信号量
    }

private:
    sem_t semaphore;
};

// 环形队列的固定大小
const int QUEUE_SIZE = 10;

class CircularQueue {
public:
    CircularQueue() : head(0), tail(0) {
        sem_init(&full, 0, 0);      // 初始时队列为空
        sem_init(&empty, 0, QUEUE_SIZE);  // 初始时队列有QUEUE_SIZE个空位
    }

    ~CircularQueue() {
        sem_destroy(&full);
        sem_destroy(&empty);
    }

    // 入队操作
    void enqueue(int item) {
        sem_wait(&empty);  // 等待空位
        mutex.lock(); // 加锁
        buffer[tail] = item;      // 将元素放入队列尾
        tail = (tail + 1) % QUEUE_SIZE;  // 更新尾指针
        mutex.unlock(); // 解锁
        sem_post(&full);  // 增加队列中的元素数量
    }

    // 出队操作
    int dequeue() {
        int item;
        sem_wait(&full);  // 等待队列中有元素
        mutex.lock(); // 加锁
        item = buffer[head];     // 取出队列头的元素
        head = (head + 1) % QUEUE_SIZE;  // 更新头指针
        mutex.unlock(); // 解锁
        sem_post(&empty);  // 增加队列中的空位数量
        return item;
    }

private:
    int buffer[QUEUE_SIZE];
    sem_t full;    // 表示队列中当前有多少个元素
    sem_t empty;   // 表示队列中有多少个空位可以插入新元素
    int head;      // 队列头指针
    int tail;      // 队列尾指针
    Mutex mutex;   // 互斥锁
};

int main() {
    CircularQueue queue;

    // 生产者线程入队操作
    for (int i = 0; i < 15; ++i) {
        queue.enqueue(i);
        std::cout << "Enqueued item: " << i << std::endl;
    }

    // 消费者线程出队操作
    for (int i = 0; i < 10; ++i) {
        int item = queue.dequeue();
        std::cout << "Dequeued item: " << item << std::endl;
    }

    return 0;
}

恭喜你已经完整地理解到POSIX信号量了！

长安0511
关注
  • 17
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
信号量
xiaohui987987的博客
04-30 5375
什么是信号量信号量主要保护共享资源的，确保该资源在同一时刻只有一个线程占用。换句话说它就是控制多进程（多线程）共同访问共享资源的一种手段。信号量的定义最初的定义：信号量是一个特殊的变量，它只能取正整数值，并且程序对其访问都是原子操作。正式的定义：它是一个特殊的变量，只允许对它进行等待和发送信号。信号量就是一种特殊的计数器当其值&gt;0时，其表示可用临界资源的个数当其值&lt;0,表示资源忙，至少...
信号量的设计与实现--课程设计指导书
05-25
信号量的设计与实现 信号量是一种大于或等于 0 的整...通过实验，掌握模块化操作系统和信号量的实现机制，对于进程同步与互斥使用资源、操作系统服务程序的编写等有全面认识。在 MINIX 3 操作系统中实现 P、V 操作。
进程间通信(6)——信号量
私房菜
04-19 2022
通过前面几篇博文，大概清楚这些IPC 的设计都是为了进程间数据的共享而设计的，例如，本文将要介绍的信号量(semaphore) 跟这些有些区别，更确切说它是为了共享数据的访问服务，它是一个计数器，是由提出，并通过PV(通过&释放，是荷兰文缩写)操作对信号量进行控制。的数据结构为一个值和一个指针，指针指向等待该信号量的下一个进程。信号量的值与相应资源的使用情况有关。当它的值大于0时，表示当前可用资源的数量；当它的值小于0时，其绝对值表示等待使用该资源的进程个数。注意，信号量的值仅能由PV操作来改变。
线程互斥机制--信号量的使用
m0_65731372的博客
10-22 1047
在多线程编程中使用广泛的一种机制——信号量
Linux系统：生产消费模型 & 读者写者模型
最新发布
盒马的博客
06-17 1210
讲解Linux中的生产者消费者模型，以及其的两种实现方式：阻塞队列，环形队列。随后简单讲解了类似的读者写者模型
Linux的信号量
肖肖的博客
10-31 1664
信号量（semaphore）与已经介绍过的 IPC 结构不同，它是一个计数器。信号量用于实现进程间的互斥与同步，而不是用于存储进程间通信数据。 ** 1、特点 ** 1、信号量用于进程间同步，若要在进程间传递数据需要结合共享内存。 2、信号量基于操作系统的 PV 操作，程序对信号量的操作都是原子操作。 3、每次对信号量的 PV 操作不仅限于对信号量值加 1 或减 1，而且可以加减任意正整数。 4、支持信号量组。 例子：就像一个房间，信号量相当于开门的钥匙，房间相当于连接资源（一次仅允许一个进程使用的资源；如
c语言信号量的使用实例
02-16
在c语言中如何用信号量。信号量的原理。和一些例子举例说明
一文搞懂信号量
m0_73731708的博客
09-21 4051
信号量是一种同步机制，用于控制对共享资源的访问。它是由计算机科学家 Edsger Dijkstra 在 1965 年提出的。信号量可以理解为一个计数器，它可以表示可用资源的数量，可以是整数类型。信号量有两个主要操作：P（等待）和 V（释放）。P（等待）操作：当一个进程或线程需要访问共享资源时，它会尝试执行 P 操作。如果信号量的值大于 0，则进程可以继续访问资源，并将信号量的值减 1；如果信号量的值等于 0，则进程会被阻塞，直到信号量的值变为正数。
操作系统——信号量（理解什么是信号量，信号量如何解决同步互斥问题，信号量一些注意点）
热门推荐
weixin_43914272的博客
08-31 6万+
信号量是什么 信号量（semaphore）是操作系统用来解决并发中的互斥和同步问题的一种方法。 信号量是一个与队列有关的整型变量，你可以把它想象成一个数后面拖着一条排队的队列，如图： 那信号量上面值n代表什么意思呢？ n>0：当前有可用资源，可用资源数量为n n=0：资源都被占用，可用资源数量为0 n<0：资源都被占用，并且还有n个进程正在排队 那信号量拖着的那个队列就是用来放正在排队想要使用这一资源的进程 信号量伪代码 信号量的伪代码又如何实现呢 在代码中我们可以看到有两个对信号量的cou
信号量的概念 及其 操作函数（有名、无名信号量）
challenglistic的博客
05-19 5343
介绍信号量的概念、信号量的申请和释放过程及其操作函数
信号与系统全套课件.pptx
10-02
参考书籍包括《信号与系统》（Oppenheim著，刘树堂译）、《信号与系统例题分析及习题》（乐正友、杨为理、应启珩著）和《掌握和精通MATLAB》（张志涌、刘瑞桢、杨祖樱著），这些书籍为深入学习提供了丰富的资源。...
信号与系统思维导图.zip
06-21
这个压缩包“信号与系统思维导图.zip”显然包含了对这一核心课程的全面梳理，通过使用xmind这款流行的思维导图软件制作，旨在帮助学习者构建清晰的知识框架。 信号在电子领域中是指随时间变化的物理量，如电压、...
信号完整性与电源完整性分析 第3版.pdf
04-06
总之，《信号完整性与电源完整性分析 第3版》是一本全面而深入的教材，适合电子工程专业的学生、研究人员和工程师阅读。它不仅提供了理论基础，还提供了大量的实践经验，帮助读者提升在高速数字系统设计中的专业技能...
互斥量和信号量的区别
wangsifu2009的专栏
05-10 1768
1. 互斥量用于线程的互斥，信号量用于线程的同步。   这是互斥量和信号量的根本区别，也就是互斥和同步之间的区别。   互斥：是指某一资源同时只允许一个访问者对其进行访问，具有唯一性和排它性。但互斥无法限制访问者对资源的访问顺序，即访问是无序的。 同步：是指在互斥的基础
linux信号量
oguro的博客
12-25 1003
信号量 进化版的互斥锁（1 --> N） 由于互斥锁的粒度比较大，如果我们希望在多个线程间对某一对象的部分数据进行共享，使用互斥锁是没有办法实现的，只能将整个数据对象锁住。这样虽然达到了多线程操作共享数据时保证数据正确性的目的，却无形中导致线程的并发性下降。线程从并行执行，变成了串行执行。与直接使用单进程无异。 信号量，是相对折中的一种处理方式，既能保证同步，数据不混乱，又能提高线程并发。
Linux基础（四）——信号量与PV操作
lixiangsheng2012的博客
10-26 5574
在计算机操作系统中，PV操作是进程管理中的难点。1、基本含义      什么是信号量？信号量（semaphore）的数据结构为一个值和一个指针，指针指向等待该信号量的下一个进程。信号量的值与相应资源的使用情况有关。当它的值大于0时，表示当前可用资源的数量；当它的值小于0时，其绝对值表示等待使用该资源的进程个数。      PV操作的含义：PV操作由P操作原语和V操作原语组成（原语是不可中断的过程）...
【Linux篇】第十七篇——信号量
m0_58367586的博客
11-06 1万+
(2)V(sv):我们将释放信号量称为V操作，释放信号量的本质就是归还临界资源中某块资源的使用权限，当释放成功时临界资源中资源的数目就应该加一，因此V操作本质就是让计数器加一，如果有其他进程因等待sv而被挂起，就让它恢复运行，如果没有进程因等待sv而挂起，就给他加1。(1)P(sv):我们将申请信号量称为P操作，申请信号量的本质就是申请获得临界资源中某块资源的使用权限，当申请成功时临界资源中资源的数目应该减去一，因此P操作的本质就是让计数器减一，如果sv的值大于零，就给它减1；
信 号 量
g200407331的专栏
10-15 1242
1 、信 号 量 1.1 信号量的概念及其作用 　　信号量（semaphores）是 20 世纪 60 年代中期 Edgser Dijkstra 发明的。使用信号量的最初目的是为了给共享资源建立一个标志，该标志表示该共享资源被占用情况。这样，当一个任务在访问共享资源之前，就可以先对这个标志进行查询，从而在了解资源被占用的情况之后，再来决定自己的行为。 　　实际的应用中，信号量的作用又该如何体...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值