【并发程序设计】15.信号灯(信号量)

最新推荐文章于 2024-07-04 09:51:37 发布
最新推荐文章于 2024-07-04 09:51:37 发布
阅读量889 收藏 20
点赞数 19
分类专栏： Linux嵌入式学习笔记 文章标签： linux 运维 嵌入式硬件 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75563094/article/details/139397806
版权

15.信号灯(信号量)

Linux中的信号灯即信号量是一种用于进程间同步或互斥的机制，它主要用于控制对共享资源的访问。

在Linux系统中，信号灯作为一种进程间通信（IPC）的方式，与其他如管道、FIFO或共享内存等IPC方式不同，信号灯主要用于同步或互斥控制，以确保多个进程之间能够协调地访问共享资源。信号灯可以看作是内存中的一个标志，进程可以通过检查信号灯的状态来决定是否可以安全地访问某些共享资源。

要点

  1. 创建和操作：要在Linux中使用信号灯，首先需要创建一个信号灯，并指定其初始值。对于二值信号灯，这个初始值通常是1，表示资源一开始是可用的。
  2. 等待和释放：进程可以执行等待操作来测试信号灯的值，如果信号灯的值大于0，则进程可以继续执行并将信号灯的值减1；如果值为0，则进程必须等待直到信号灯的值变为正数。
  3. 共享资源控制：信号灯提供了一种机制，使得进程能够根据信号灯的状态来判断是否可以访问某些共享资源。这类似于互斥锁，确保了在任何时候只有一个进程可以访问临界区。
  4. 进程间通信：除了同步和互斥，信号灯还可以作为进程间通信的一种方式。它们存在于内核空间，与共享内存和消息队列一起构成了Linux中主要的IPC通信方式。
  5. 有名信号灯： 可以通过路径名在进程间共享，因此不同进程可以通过已知的路径名来访问同一个有名信号灯。 适用于需要在不同进程间进行同步的场景。
  6. 无名信号灯： 只能存在于内存中，因此使用无名信号灯的进程必须能够访问相同的内存区域。通过共享内存的方式创建，不依赖于文件系统中的路径名。适用于单进程内多线程间的同步或在已经映射相同内存内容的多个进程之间的同步。
  7. System V信号灯：Linux支持System V的信号灯，这是一种传统的信号灯实现，用于在同一系统内的进程间进行同步和互斥。

互斥和同步 是信号灯通常用于解决并发中的两个主要问题：

  1. 互斥：确保当一个进程使用共享资源时，其他进程不能同时访问该资源。例如，打印设备只能由一个进程使用，其他尝试访问打印设备的进程必须等待，直到当前进程完成打印任务。

  2. 同步：确保进程间的执行顺序符合特定的依赖关系。例如，一个进程生成数据，另一个进程消费这些数据，消费者进程需要等待生产者进程生成数据后才能继续执行。

PV操作

信号灯的工作原理基于PV操作，其中P操作用于请求资源（减少信号量的值），而V操作用于释放资源（增加信号量的值）。

  • P操作“proberen”（尝试）：如果信号量的值为正，则将其减一，允许进程继续执行。如果信号量的值为0或负，则进程被阻塞，直到信号量的值变为正数。

  • V操作“verhogen”（释放）：将信号量的值加一，如果有其他进程因等待该信号量而被阻塞，则其中一个进程会被唤醒。

POSIX是一组用于确保操作系统间可移植性的IEEE标准，主要针对Unix系统。POSIX标准为操作系统提供了一套共通的规则，使得软件开发更加高效，同时也让用户能够在不同的系统之间无缝地迁移和运行应用程序。

有名信号灯

用到的函数主要有：

  1. sem_open 有名信号灯打开
  2. sem_close 有名信号灯关闭
  3. sem_unlink 有名信号灯的删除
  4. sem_wait 信号灯P操作，申请资源
  5. sem_post 信号灯V操作，释放资源

sem_open 函数

  1. 原型：

    #include <fcntl.h>
#include <sys/stat.h>
#include <semaphore.h>
sem_t *sem_open(const char *name, int oflag, mode_t mode, unsigned int value);

  2. 功能：创建或打开一个有名信号量（named semaphore）的函数

  3. 参数：

    • name：信号量的名称，用于标识信号量。
    • oflag：打开选项，可以是以下值的组合：
      • O_CREAT：如果信号量不存在，则创建一个新的信号量。
      • O_EXCL：与O_CREAT一起使用，表示如果信号量已存在，则返回错误。
      • O_RDWR：允许对信号量进行读写操作。
    • mode：设置信号量的权限，通常设置为0644。
    • value：信号量的初始值。

  4. 返回值：

    • 成功时，返回一个指向信号量的指针。
    • 失败时，返回SEM_FAILURE（通常是NULL）。

sem_close 函数

  1. 原型：

    #include <semaphore.h>
int sem_close(sem_t *sem);

  2. 功能：用于关闭一个信号量的函数

  3. 参数：

    • sem：指向要关闭的信号量的指针

  4. 返回值：

    • 成功时，返回0。
    • 失败时，返回-1，并设置errno。

sem_unlink 函数

  1. 原型：

    #include <semaphore.h>
int sem_unlink(const char *name);

  2. 功能：删除一个命名信号量

  3. 参数：

    • name：要删除的信号量的名称

  4. 返回值：

    • 成功时，返回0
    • 失败时，返回-1，并设置errno

sem_wait 函数

  1. 原型：

    #include <semaphore.h>
int sem_wait(sem_t *sem);

  2. 功能：”P操作“等待一个信号量。当信号量的值大于0时，该函数会将信号量的值减1，并立即返回。如果信号量的值为0，则该函数会阻塞当前线程，直到信号量的值大于0为止。

  3. 参数：

    • sem：指向要等待的信号量的指针。

  4. 返回值：

    • 成功时，返回0。
    • 失败时，返回-1，并设置errno。

sem_post 函数

  1. 原型：

    #include <semaphore.h>
int sem_post(sem_t *sem);

  2. 功能：”V操作“增加一个信号量的值。当信号量的值大于0时，如果有其他线程正在等待该信号量，则sem_post函数会唤醒其中一个等待的线程。如果没有线程在等待，那么信号量的值简单地增加，它与sem_wait函数相对应.

  3. 参数：

    • sem：指向要操作的信号量的指针。

  4. 返回值：

    • 成功时，返回0。
    • 失败时，返回-1，并设置errno。

示例-有名信号灯使用

使用信号量和共享内存实现的简单进程间通信（IPC）示例

一个简单的命令行界面，用户可以在命令行中输入字符串，并将其存储到共享内存中。通过信号量来实现进程间的同步，确保数据的读写操作不会发生冲突

tes_semw.c 写程序

#include <fcntl.h>
#include <sys/stat.h>
#include <semaphore.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <signal.h>

void delsemfile(int sig)
{
sem_unlink("mysem_w");  // 删除名为"mysem_w"的信号量
exit(0);                // 退出程序
}

int main()
{
sem_t *sem_r,*sem_w;     // 定义两个信号量指针，分别用于读和写操作
key_t key;               // 定义键值，用于生成共享内存标识符
int shmid;               // 定义共享内存标识符
char *shmaddr;           // 定义共享内存地址指针

struct sigaction act;    // 定义信号处理结构体
act.sa_handler = delsemfile;  // 设置信号处理函数为delsemfile
act.sa_flags = 0;        // 设置信号处理标志为0
sigemptyset(&act.sa_mask);   // 清空信号集

sigaction(SIGINT,&act,NULL); // 注册信号处理函数，当接收到SIGINT信号时调用delsemfile函数

key = ftok(".",100);      // 生成键值，用于创建共享内存标识符
if(key<0)
{
   perror("ftok");      // 如果生成失败，打印错误信息
   return 0;            
}

shmid = shmget(key,500,0666|IPC_CREAT);  // 创建共享内存段，大小为500字节，权限为0666，如果不存在则创建
if(shmid<0)
{
   perror("shmget");    // 如果创建失败，打印错误信息
   return 0;           
}

shmaddr = shmat(shmid,NULL,0);  // 将共享内存段附加到进程的地址空间，并获取共享内存地址指针

sem_r = sem_open("mysem_r",O_CREAT|O_RDWR,0666,0);  // 创建名为"mysem_r"的信号量，初始值为0
sem_w = sem_open("mysem_w",O_CREAT|O_RDWR,0666,1);  // 创建名为"mysem_w"的信号量，初始值为1

while(1)
{
    sem_wait(sem_w);    // 等待名为"mysem_w"的信号量变为非零值
    printf(">");        // 输出提示符">"
    fgets(shmaddr,500,stdin);  // 从标准输入读取一行字符串，存储到共享内存中
    sem_post(sem_r);    // 增加名为"mysem_r"的信号量的值，表示数据已写入共享内存
}
}

tes_semr.c 读程序

#include <fcntl.h>
#include <sys/stat.h>
#include <semaphore.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <signal.h>

void delsemfile(int sig)
{
sem_unlink("mysem_r");  // 删除名为"mysem_r"的信号量
exit(0);                // 退出程序
}

int main(){

sem_t *sem_r,*sem_w;     // 定义两个信号量指针，分别用于读和写操作
key_t key;               // 定义键值，用于生成共享内存标识符
int shmid;               // 定义共享内存标识符
char *shmaddr;           // 定义共享内存地址指针
struct sigaction act;    // 定义信号处理结构体
act.sa_handler = delsemfile;  // 设置信号处理函数为delsemfile
act.sa_flags = 0;        // 设置信号处理标志为0
sigemptyset(&act.sa_mask);   // 清空信号集

sigaction(SIGINT,&act,NULL); // 注册信号处理函数，当接收到SIGINT信号时调用delsemfile函数

key = ftok(".",100);      // 生成键值，用于创建共享内存标识符
if(key<0)
{
   perror("ftok");      // 如果生成失败，打印错误信息
   return 0;            
}

shmid = shmget(key,500,0666|IPC_CREAT);  // 创建共享内存段，大小为500字节，权限为0666，如果不存在则创建
if(shmid<0)
{
   perror("shmget");    // 如果创建失败，打印错误信息
   return 0;            
}

shmaddr = shmat(shmid,NULL,0);  // 将共享内存段附加到进程的地址空间，并获取共享内存地址指针

sem_r = sem_open("mysem_r",O_CREAT|O_RDWR,0666,0);  // 创建名为"mysem_r"的信号量，初始值为0
sem_w = sem_open("mysem_w",O_CREAT|O_RDWR,0666,1);  // 创建名为"mysem_w"的信号量，初始值为1

while(1)
{
    sem_wait(sem_r);    // 等待名为"mysem_r"的信号量变为非零值
    printf("%s\n",shmaddr);  // 输出共享内存中的字符串
    sem_post(sem_w);    // 增加名为"mysem_w"的信号量的值，表示数据已读取完成
}
}

在这里插入图片描述

运行效果如图，实现了两个进程通讯

可以通过命令ls /dev/shm查看信号量文件;在Linux系统中，/dev/shm目录是用于存放共享内存和信号量文件的特殊目录

ctrl + c退出程序后，捕获到SIGINT信号后执行delsemfile()删除信号量文件

无名信号灯

用到的函数有:

  1. sem_init 初始化无名信号量
  2. sem_destory 销毁无名信号量
  3. sem_wait 信号灯P操作，申请资源
  4. sem_post 信号灯V操作，释放资源

sem_init 函数

  1. 原型：

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

  2. 功能：初始化一个无名信号量

  3. 参数：

    • sem：指向要初始化的信号量的指针。
    • pshared：指定信号量的类型，如果为0，则表示该信号量是进程私有的；如果为非0值，则表示该信号量是进程间共享的。
    • value：指定信号量的初始值。

  4. 返回值：

    • 成功时，返回0；
    • 失败时，返回-1，并设置errno。

sem_destory 函数

  1. 原型：

    #include <semaphore.h>
int sem_destroy(sem_t *sem);

  2. 功能：销毁一个无名信号量

  3. 参数：

    • sem：指向要销毁的信号量的指针。

  4. 返回值：

    • 成功时，返回0；
    • 失败时，返回-1，并设置errno。

  5. 注意：只有当信号量的引用计数变为0时，才能安全地销毁它。如果还有其他线程或进程正在等待该信号量，那么销毁操作将失败，并且errno将被设置为EBUSY。在这种情况下，需要确保所有使用该信号量的线程或进程都已经结束，然后再尝试销毁它。

示例-无名信号灯使用

使用信号量和共享内存实现的简单进程间通信（IPC）示例。主要功能是在一个进程中输入字符串，另一个进程中读取并打印这些字符串。

#include <fcntl.h>
#include <sys/stat.h> 
#include <semaphore.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <signal.h>
#include <pthread.h>

sem_t sem_r,sem_w; // 定义两个信号量，用于读写同步
char *shmaddr; // 共享内存地址指针

void destroysem(int sig) // 信号处理函数，用于销毁信号量并退出程序
{
sem_destroy(&sem_r); // 销毁读信号量
sem_destroy(&sem_w); // 销毁写信号量
exit(0); // 退出程序
}

void *readmem(void *arg) // 读取共享内存中的字符串并打印的线程函数
{
while(1)
{
  sem_wait(&sem_r); // 等待读信号量
  printf("%s\n",shmaddr); // 打印共享内存中的字符串
  sem_post(&sem_w); // 释放写信号量
}
}

int main()
{
key_t key; // 键值
int shmid; // 共享内存标识符

struct sigaction act; // 信号处理结构体
act.sa_handler = destroysem; // 设置信号处理函数
act.sa_flags = 0; // 设置信号处理标志
sigemptyset(&act.sa_mask); // 清空信号集

sigaction(SIGINT,&act,NULL); // 注册信号处理函数

key = ftok(".",100); // 生成键值
if(key<0)
{
 perror("ftok"); // 输出错误信息
 return 0;
}

shmid = shmget(key,500,0666|IPC_CREAT); // 创建共享内存
if(shmid<0)
{
 perror("shmget"); // 输出错误信息
 return 0;
}

shmaddr = shmat(shmid,NULL,0); // 将共享内存映射到进程地址空间

sem_init(&sem_r,0,0); // 初始化读信号量，初始值为0
sem_init(&sem_w,0,1); // 初始化写信号量，初始值为1

pthread_t tid; // 线程标识符
pthread_create(&tid,NULL,readmem,NULL); // 创建线程，执行readmem函数

while(1)
{
  sem_wait(&sem_w); // 等待写信号量
  printf(">"); // 提示用户输入
  fgets(shmaddr,500,stdin); // 从标准输入读取字符串并存储到共享内存中
  sem_post(&sem_r); // 释放读信号量
}
}

在这里插入图片描述

运行效果如图

在父进程中，它循环接收用户输入的数据并将其写入共享内存中。在子进程中，它循环读取共享内存中的数据并打印出来。

System V 信号灯

System V 信号灯是一种用于进程间同步和互斥的机制，它允许多个进程共享资源而不会产生冲突。

  1. 信号灯集合：System V 信号灯可以是一个或多个计数信号灯的集合。这意味着可以同时操作集合中的任意多个信号灯，以协调进程间的访问顺序。
  2. 信号灯操作：System V 信号灯的操作通常涉及三个步骤：初始化（创建）、P 操作（等待资源）和 V 操作（释放资源）。P 操作用于请求资源，如果资源不可用则进程将等待；V 操作用于释放资源，使得其他等待该资源的进程可以继续执行
  3. 避免死锁：通过申请多个资源时使用 System V 信号灯，可以减少死锁的风险。死锁是指两个或多个进程在互相等待对方释放资源时无法继续执行的状态。

System V 信号灯是一种重要的同步机制，它在多进程编程中扮演着关键角色，确保了资源的有序访问和数据的一致性。

用到的函数有：

  1. semget 创建/打开信号灯
  2. semop 对信号灯集合中的信号量进行P - V操作
  3. semctl 信号灯集合的控制（初始化/删除）

semget 函数

  1. 原型：

    #include <sys/sem.h>
int semget(key_t key, int nsems, int semflg);

  2. 功能：获取一个信号量集的标识符

  3. 参数：

    • key：是一个键值，用于唯一标识一个信号量集。通常使用ftok()函数生成。
    • nsems：指定需要创建或获取的信号量数量。
    • semflg：设置信号量集的访问权限和创建标志。可以是以下值的组合：
      • IPC_CREAT：如果信号量集不存在，则创建一个新的信号量集。
      • IPC_EXCL：与IPC_CREAT一起使用，表示如果信号量集已经存在，则返回错误。
      • 0：表示不设置任何特殊标志。

  4. 返回值：

    • 如果成功，返回信号量集的标识符（非负整数）。
    • 如果失败，返回-1，并设置errno为相应的错误码。

semop 函数

  1. 原型：

    #include <sys/sem.h>
int semop(int semid, struct sembuf *sops, unsigned nsops);

  2. 功能：改变信号量的值,对信号灯集合中的信号量进行P - V操作

  3. 参数：

    • semid：是一个信号量集的标识符，由semget()函数返回。
    • sops：是一个指向struct sembuf结构体数组的指针，该数组定义了要执行的操作。
    • nsops：指定sops数组中操作的数量。

    struct sembuf结构体：

    struct sembuf {
  unsigned short sem_num;  // 信号量编号
  short sem_op;            // 操作类型
  short sem_flg;           // 操作标志
};

    各个字段的含义如下：

    • sem_num：指定要操作的信号量的编号。如果设置为0，则表示对整个信号量集进行操作。
    • sem_op：指定要对信号量执行的操作类型。
      • 当sem_op> 0，它表示进程释放控制的资源，即信号量的值将增加sem_op的数量。
      • 当sem_op= 0，如果没有设置IPC_NOWAIT标志，调用进程将进入睡眠状态直到信号量的值为0；如果设置了该标志且信号量值不为0，则进程不会进入睡眠，而是直接返回EAGAIN。
      • 当sem_op< 0，它表示尝试获取资源使用权，信号量的值将增加sem_op的绝对值。如果此时信号量的值小于或等于sem_op的绝对值，操作将会阻塞，直到信号量的值大于或等于sem_op的绝对值。
    • sem_flg：指定操作的标志。可以是以下值的组合：
      • IPC_NOWAIT：非阻塞模式，如果无法立即执行操作，则立即返回。
      • SEM_UNDO：撤销之前的操作。
      • 0：不设置任何特殊标志。

  4. 返回值：

    • 如果成功，返回0。
    • 如果失败，返回-1，并设置errno为相应的错误码。

semctl 函数

  1. 原型：

    #include <sys/sem.h>
int semctl(int semid, int semnum, int cmd, ...);

  2. 功能：控制信号量集

  3. 参数：

    • semid：是一个信号量集的标识符，由semget()函数返回。
    • semnum：指定要操作的信号量的编号。如果设置为0，则表示对整个信号量集进行操作。
    • cmd：指定要执行的命令。可以是以下值之一：
      • IPC_RMID：删除信号量集。(常用)
      • IPC_SET：设置信号量集的属性。(常用)
      • IPC_STAT：获取信号量集的状态信息。(常用)
      • SETVAL：设置信号灯的值，需要用到第四个参数：共用体。(常用)
      • IPC_INFO：获取系统支持的信号量集的最大数量和当前使用的数量。
      • SEM_STAT：获取指定信号量的状态信息。
      • GETALL：获取所有信号量的值。
      • GETNCNT：获取等待某个信号量变为非零值的进程数。
      • GETPID：获取最后一个操作指定信号量的进程ID。
      • GETVAL：获取指定信号量的值。
      • GETZCNT：获取等待某个信号量变为零值的进程数。
      • SETALL：设置所有信号量的值。
    • ...：根据cmd的不同，可能需要传递额外的参数。

  4. 返回值：

    • 如果成功，返回相应的结果或状态信息。
    • 如果失败，返回-1，并设置errno为相应的错误码

示例-System V信号灯使用

基于信号量和共享内存的进程间通信（IPC）示例。它创建了一个父子进程，并使用信号量和共享内存进行数据传递。

#include <semaphore.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <sys/sem.h>

#define SEM_READ   0
#define SEM_WRITE  1

//semctl函数用到的参数
union semun {
int val;
};               

// P操作函数，用于对信号量进行减一操作
void Poperation(int semid,int semindex)
{
struct sembuf sbuf;
sbuf.sem_num =  semindex;
sbuf.sem_op = -1;
sbuf.sem_flg = 0;

semop(semid,&sbuf,1);
}

// V操作函数，用于对信号量进行加一操作
void Voperation(int semid,int semindex)
{
struct sembuf sbuf;
sbuf.sem_num =  semindex;
sbuf.sem_op = 1;
sbuf.sem_flg = 0;

semop(semid,&sbuf,1);
}

int main()
{
key_t key; // 定义键值key
char *shmaddr; // 共享内存地址指针
int semid,shmid; // 信号量和共享内存的ID
key = ftok(".",100); // 生成键值
if(key<0)
{
    perror("ftok"); // 如果生成失败，输出错误信息
    return 0;
}

semid = semget(key,2,IPC_CREAT |0666); // 创建信号量集合
if(semid<0)
{
    perror("semget"); // 如果创建失败，输出错误信息
    return 0;
}
shmid = shmget(key,500,IPC_CREAT |0666); // 创建共享内存
shmaddr = shmat(shmid,NULL,0); // 将共享内存映射到进程地址空间
union semun mysem; // 定义信号量联合体
mysem.val = 0; // 初始化读信号量的值为0
semctl(semid,SEM_READ,SETVAL,mysem); // 设置读信号量的值
mysem.val = 1; // 初始化写信号量的值为1
semctl(semid,SEM_WRITE,SETVAL,mysem); // 设置写信号量的值

pid_t pid; // 定义进程ID
pid = fork(); // 创建子进程
if(pid<0)
{
    perror("fork"); // 如果创建失败，输出错误信息
    shmctl(shmid,IPC_RMID,NULL); // 删除共享内存
    semctl(semid,0,IPC_RMID); // 删除信号量集合
    exit(-1);
}else if(pid == 0)
{
    // 子进程循环读取共享内存中的数据并打印
    while(1)
    {
        Poperation(semid,SEM_READ); // 对读信号量进行P操作
        printf("%s\n",shmaddr); // 打印共享内存中的数据

        Voperation(semid,SEM_WRITE); // 对写信号量进行V操作
    }
}
else
{
    // 父进程循环接收用户输入的数据并写入共享内存
    while(1)
    {
        Poperation(semid,SEM_WRITE); // 对写信号量进行P操作
        printf(">"); // 提示用户输入数据
        fgets(shmaddr,32,stdin); // 从标准输入读取数据并写入共享内存

        Voperation(semid,SEM_READ); // 对读信号量进行V操作
    }
}
}

在这里插入图片描述

运行结果如图

在父进程中，它循环接收用户输入的数据并将其写入共享内存中。在子进程中，它循环读取共享内存中的数据并打印出来。

真果粒wrdms
关注
  • 19
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Linux内核中的信号量
rengui1228的博客
06-11 1013
Linux内核中的信号量         信号量的本质是⼀种数据操作锁，它本身不具有数据交换的功能，而是通过控制其他的通信资源（文件，外部设备）来实现进程间通信，它本身只是一种外部资源的标识。信号量在此过程中负责数据操作的互斥、同步等功能。当请求⼀个使用信号量来表示的资源时，进程需要先读取信号量的值来判断资源是否可⽤。大于0，资源可以请求，等于0，⽆资源可⽤，进程会进入睡眠状态直⾄资源可⽤。当进
交通信号灯实现程序
12-25
综上所述，"交通信号灯实现程序"是一个涉及多线程、并发控制、状态机设计、事件驱动编程、用户界面开发以及异常处理等多个知识点的项目。通过实现这样一个程序，开发者可以提升对这些技术的理解和运用能力。
计算机操作系统信号量简介,信号量
weixin_39957186的博客
07-15 869
信号量(Semaphore)，有时被称为信号灯，是在多线程环境下使用的一种设施，是可以用来保证两个或多个关键代码段不被并发调用。在进入一个关键代码段之前，线程必须获取一个信号量；一旦该关键代码段完成了，那么该线程必须释放信号量。其它想进入该关键代码段的线程必须等待直到第一个线程释放信号量。为了完成这个过程，需要创建一个信号量VI，然后将Acquire Semaphore VI以及Release S...
Linux并发程序设计思路,Linux并发程序设计你该这么学
weixin_33955740的博客
05-01 52
第01课进程(一)课时1进程基本概念试听00 :28 :41开始学习课时2进程常用命令试听00 :15 :30开始学习课时3进程的创建和结束00 :24 :09开始学习课时4进程的回收00 :14 :33开始学习第02课进程(二)课时1exec函数族00 :20 :47开始学习课时2守护进程100 :15 :00开始学习课时3守护进程200 :10 :44开始学习第03课线程(一)课时1线程的概念...
并发程序设计
Y_G_X的博客
04-22 1052
并发程序设计
php 信号量 关闭,php 信号量
weixin_36058303的博客
03-09 176
一些理论基础：信号量：又称为信号灯、旗语 用来解决进程(线程同步的问题)，类似于一把锁，访问前获取锁(获取不到则等待)，访问后释放锁。临界资源：每次仅允许一个进程访问的资源。临界区：每个进程中访问临界资源的那段代码叫临界区进程互斥：两个或以上的进程不能同时进入关于同一组共享变量的临界区域，即一个进程正在访问临界资源，另一个进程要想访问必须等待。进程同步主要研究如何确定数个进程之间的执行顺序和避免数...
并发编程之信号量机制
weixin_42579072的博客
12-27 609
百度百科：信号量(Semaphore)，有时被称为信号灯，是在多线程环境下使用的一种设施，是可以用来保证两个或多个关键代码段不被并发调用。在进入一个关键代码段之前，线程必须获取一个信号量；一旦该关键代码段完成了，那么该线程必须释放信号量。其它想进入该关键代码段的线程必须等待直到第一个线程释放信号量。 一、信号量机制包含以下几个核心概念： 1、信号量S，整型变量，需要初始化值大于0 2、P原语，...
【并发程序设计】总篇集 Linux下 C语言 实现并发程序设计
2201_75563094的博客
06-03 1540
在Linux中，进程是操作系统分配资源和调度运行的基本单位。Linux中的进程有以下用处：进程在Linux系统中扮演着至关重要的角色，它们不仅提高了系统的资源利用率，还实现了多任务的并行处理，使得用户可以更加高效地进行工作。以下是一些关于Linux进程的重要概念：进程的内容通常包括以下几个主要部分：在Linux中，子进程是由父进程创建的进程。当一个进程被创建时，它会自动成为一个新进程的父进程，而新进程则成为子进程。子进程可以通过系统调用来创建。回收子进程的必要性：回收子进程不仅是为了维护操作系统资源的有效性
并发程序设计笔记
Y_G_X的博客
04-22 265
并发程序设计
Linux并发程序设计
qq_26771783的博客
09-12 749
进程编程及守护进程 进程控制块 进程控制块（pcb） 进程标识PID 进程用户 进程状态、优先级 文件描述符表 寄存器 ----- pc:program counter(存放进程下一条指令的地址) ...
信号灯法实现生产者与消费者模式.rar
12-21
"信号灯法"（也称为信号量或Semaphore）是一种有效的方法，用于解决生产者与消费者问题，这种模式在并发编程中非常常见。下面我们将深入探讨这个主题。 **生产者与消费者模式** 是一个经典的多线程问题，涉及到两个...
计算机操作系统课程设计——信号灯模拟程序
12-23
《计算机操作系统课程设计——信号灯模拟程序》 在计算机科学领域，操作系统是计算机系统的核心组成部分，它负责管理和控制系统的硬件和软件资源。本项目聚焦于操作系统中的一个关键概念——信号灯模拟，这是一个常...
linux多线程信号量.pdf
09-29
Linux多线程编程中，信号量是一种重要的同步机制，它源于E.W.Dijkstra在二十世纪六十...在设计多线程程序时，开发者应根据具体需求选择适合的同步机制，如互斥锁、条件变量或信号量，以实现高效且无冲突的资源访问。
基于ARM的多线程应用程序设计实用文档doc.doc
12-01
"基于ARM的多线程应用程序设计实用文档" 本文档是基于ARM的多线程应用程序设计实用文档，旨在帮助开发者了解基于ARM的多线程应用程序设计的相关知识和技术。文档中涵盖了多线程应用程序设计的系统概述、设计要求、...
【Linux杂货铺】Linux学习之路：期末总结篇1
聆风吟的博客
06-28 1220
本文主要讲了作者本人期末复习时的总结，欢迎大家借鉴浏览。
正式邀测！ OS Copilot——一款基于大模型构建的 Linux 智能操作系统助手
weixin_60347558的博客
07-02 488
重塑操作系统交互新体验，开启您的智能化系统管理之旅
深入了解Linux中的dnsmasq：配置与优化指南
最新发布
小灰灰的博客
07-04 244
是一个轻量级的网络服务，主要用于提供DNS缓存和DHCP服务。它广泛应用于家庭路由器、网络服务器以及各种嵌入式设备中。本文将详细介绍如何在Linux系统中安装、配置和优化。可以通过包管理器轻松安装。：配置DHCP服务器的IP地址范围。：为特定MAC地址分配固定IP。在大多数Linux发行版中，，以提升网络性能和安全性。：设置DNS缓存条目数量。：指定上游DNS服务器。：防止DNS重绑定攻击。：为本地网络设置域名。：阻止特定域名的解析。在Linux系统中，：启用详细日志记录。
Linux：系统安全及应用
pangdongqiqi的博客
07-01 1159
通过su命令可以非常方便地切换为另一个用户，但前提条件是必须知道目标用户的登 录密码。例如，若要从zhangsan 用户切换为 root 用户，必须知道 root 用户的密码。对于生产环 境中的 Linux 服务器，每多一个人知道特权密码，其安全风险也就增加一分。有没有一种折中的办法，既可以让普通用户拥有一部分管理权限，又不需要将 root 用户的密码告诉他呢？答案是肯定的，使用 sudo命令就可以提升执行权限。
基于信号量机制的并发程序设计
06-08
基于信号量机制的并发程序设计是一种常见的并发编程技术，它使用信号量来协调多个并发执行的线程之间的同步和互斥操作。信号量是一个计数器，用于控制对共享资源的访问。当一个线程需要访问共享资源时，它必须首先获取一个信号量，如果信号量的计数器为0，则线程会被阻塞，直到另一个线程释放了信号量。当一个线程完成对共享资源的访问时，它必须释放信号量，以便其他线程可以访问该资源。 在基于信号量机制的并发程序设计中，通常使用两种类型的信号量：二元信号量和计数信号量。二元信号量只有两种状态：0和1，它常用于实现互斥操作。计数信号量有一个计数器，它可以是任意大于等于0的整数，它常用于实现同步操作。 在使用信号量机制时，需要考虑死锁和饥饿问题。死锁是指两个或多个线程互相等待对方释放资源的情况，导致它们都无法继续执行。饥饿是指某个线程无法获得所需的资源，因此无法继续执行的情况。为避免这些问题，需要合理地使用信号量，并遵循一定的编程规范和约定。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值