linux线程间同步信号量semp性能,自己实现的一个简单的信号量机制（用于线程同步）...

最新推荐文章于 2022-05-19 15:13:57 发布
最新推荐文章于 2022-05-19 15:13:57 发布
阅读量178 收藏
点赞数
文章标签： linux线程间同步信号量semp性能

根据信号量的原理，自己写了一个简单的信号量类，用于线程同步，以下代码在Linux下调试通过

#include

#include

#include

using namespace std;

class Sem

{

public:

Sem(int &initValue){ semValue = initValue;}

void WaitSem()

{

//信号量大于0，将信号量减1

if(semValue > 0)

{

semValue--;

}

else

{

//信号量 <= 0,则阻塞线程，直到信号量大于0

while(1)

{

if(semValue > 0)

{

semValue--;

break;

}

else

continue;

}

}

}

void PostSem()

{         //信号量加1

semValue++;

}

private:

int semValue;

};

int semp =0; //信号量初始值

Sem sem(semp);

int ncount = 0;

int threadnum = 0;

void *count1(void* arg)

{

sem.WaitSem();

threadnum++;

char name[20];

sprintf(name, "thread %d", threadnum);

cout << name << " start!" << endl;

for(int i = 0; i < 5; i++)

{

ncount += 3;

}

sleep(1);

cout << name << " ncount: " << ncount << endl;

sem.PostSem();

return (void*)0;

}

int main()

{

pthread_t tid[10];

cout << "start create thread!" << endl;

sem.PostSem();

for(int i = 0; i < 10; i++)

{

pthread_create(&tid[i], NULL, count1, NULL);

}

for(int i = 0; i < 10; i++)

{

pthread_join(tid[i], NULL);

}

sleep(2);

cout << "main thread" << endl;

return 0;

}

程序的运行结果如下

start create thread!

thread 1 start!

thread 1 ncount: 15

thread 2 start!

thread 2 ncount: 30

thread 3 start!

thread 3 ncount: 45

thread 4 start!

thread 4 ncount: 60

thread 5 start!

thread 5 ncount: 75

thread 6 start!

thread 6 ncount: 90

thread 7 start!

thread 7 ncount: 105

thread 8 start!

thread 8 ncount: 120

thread 9 start!

thread 9 ncount: 135

thread 10 start!

thread 10 ncount: 150

main thread

在一个线程对ncount进行操作的时候，其他线程被阻塞，因此打印出来的ncount依次累加15.

注释掉 sem.WaitSem()和sem.PostSem()之后，程序运行结果如下

start create thread!

thread 1 start!

thread 2 start!

thread 3 start!

thread 4 start!

thread 5 start!

thread 6 start!

thread 7 start!

thread 8 start!

thread 9 start!

thread 10 start!

thread 1 ncount: 150

thread 2 ncount: 150

thread 3 ncount: 150

thread 4 ncount: 150

thread 5 ncount: 150

thread 6 ncount: 150

thread 7 ncount: 150

thread 8 ncount: 150

thread 9 ncount: 150

thread 10 ncount: 150

main thread

因为在1秒钟里，10个线程都对ncount加了15，因此大于出来的ncount为150

此信号量类实现了简单的线程同步

王信文
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
利用信号量实现线程同步
weixin_30387423的博客
05-21 1022
本篇使用信号量机制实现对全局资源的正确使用，包括以下两点： 各个子线程对全局资源的互斥使用 主线程对子线程的同步 信号量 简单的说，信号量内核对象，也是多线程同步的一种机制，它可以对资源访问进行计数，包括最大资源计数和当前资源计数，是两个32位的值；另外，计数是以原子访问的方式进行...
信号量Semaphore 工作原理
weixin_36666151的博客
09-07 333
限流器：让一组线程只能同时让固定数量的线程同时执行。各种同步器其实都是基于AQS实现的。其中最重要的是 state 和里面的同步等待队列，说明就是一个链表 Semaphore semp = new Semaphore(5); 也可以声明为公平的同步构造器 public Semaphore(int permits, boolean fair) { sync = fai...
Semaphore（信号量）理解
p0p0p0p01的专栏
10-26 1655
一、简介       信号量是一个线程同步结构，它能够在线程间发送信号以避免信号丢失 或者像使用一个锁一样用户保护 临界区。java5在java.util.concurrent包中已经有了信号量的实现。      从概念上讲，信号量维护了一个许可集。当一个线程想要访问某个共享资源，首先，它必须获得semaphore。如果semaphore的内部计数器的值大于0，那么semaphore减少计数器
对信号量sem的一些总结
amumu_123的博客
04-21 6650
1、首先来说说信号量和互斥锁的区别： 信号量用在多线程多任务同步的，一个线程完成了某一个动作就通过信号量告诉别的线程， 别的线程再进行某些动作（大家都在semtake的时候，就阻塞在哪里）。 而互斥锁是用在多线程多任务互斥的，一个线程占用了某一个资源，那么别的线程就无法访问， 直到这个线程unlock，其他的线程才开始可以利用这个资源。 作用域 信号量: 进程间或线程间(linux
Qt 自定义类型信号槽
Poseidon's Maserati
09-25 150
背景：信号槽传递自定义类型数据时报错。QObject::connect: Cannot queue arguments of type 'Test' (Make sure 'Test' is registed using qRegisterMetaType().) 原因：项目编译时，signal函数是和参数一起放到队列去构造的，此应用多半又是跨线程，接收方slot不知道传递的参数类型，也就没办法构造。如果传递的参数是指针地址则没问题，但是使用上不方便，发送完不能立即释放，增大内存管理难度。 办法：头文件
JAVA多线程--信号量(Semaphore)_.docx
10-09
单个信号量的Semaphore对象可以实现互斥锁的功能，并且可以是由一个线程获得了“锁”，再由另一个线程释放“锁”，这可应用于死锁复原的一些场合。 在Java中，使用Semaphore可以轻松地实现多线程环境下的资源访问...
SEMP14Server完整版(含教程).part2
最新发布
05-14
第二部分的软件，教程超过1G，所以只能分两次上传，杀毒软件服务管理平台。
Python库 | solace_semp_config-9.2.0.14-py2.py3-none-any.whl
05-10
资源分类：Python库 所属语言：Python 资源全名：solace_semp_config-9.2.0.14-py2.py3-none-any.whl 资源来源：官方 安装方法：https://lanzao.blog.csdn.net/article/details/101784059
BA 5820 齿轮减速机 SEMP, SZMP 500, 750, 2600, 2810[手册].pdf
09-15
BA 5820 齿轮减速机 SEMP, SZMP 500, 750, 2600, 2810[手册]pdf,
uSEMP:与SMA Home Master通信的SMAs SEMP协议的最基本实现
04-13
这是一个非常基本的Arduino C ++库，通过SMA实现了SEMP“简单能源管理协议”，由于Esp8266WebServer的内部使用，目前仅适用于Esp8266。 我可能永远不会解决的问题... 安装 要安装此库，只需将整个文件夹作为子文件夹...
信号量机制实现线程同步
05-20
用信号量实现线程同步，多个线程共享一个资源。
使用信号量解决两个线程同步问题
Soul Professior
01-26 3851
1.同步问题 我们知道多道程序设计理念的提出，使得线程（进程）和线程（进程）之间可以并发执行，但是有一些特殊的情况，请看下面的例子： (http://img.blog.csdn.net/20170126160159642?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvcXFfMzM2NTA5Nzg=/font/5a6L5L2T/font
[Linux]多线程同步之sem_wait()学习笔记
modi000的博客
05-21 1111
转载：https://blog.csdn.net/tzshlyt/article/details/53150697 1、semaphore 的这种信号量不仅可用于同一进程的线程同步，也可以用于不同进程间同步。 一个生产者-消费者例子：生产者不停的向一个固定大小的环形队列中添加数据，消费者从环形队列中清零数据，如果生产者积累的数据大于环形队列长度，则等待消费者清除数据有空位后再生产。 #include <stdlib.h> #include <pthread.h> #incl.
关于Linux信号量的理解和探讨(别说看不懂，耐心看完，你会恍然大悟~)
pang9998的博客
06-27 3918
工作环境(蓝色粗体字为特别注意内容)1，实验环境：Linux2.62，参考文献:https://www.cnblogs.com/LZYY/p/3453582.html最近在操作设备文件的时候，要求使用独占模式使用串口设备，即一个进程用完之后释放该串口，供其他进程使用。该如何实现该需求呢？自然想到了用信号量来实现。信号量是什么呢？首先了解一下，信号量机概念是由荷兰科学家Dijkstr引入，值得一提的...
信号量实现同步
cjsycyl的专栏
09-27 996
http://blog.csdn.net/wtz1985/article/details/3835781 在上一篇文章中已经用信号量来实现线程间的互斥，达到了互斥锁的效果，今天这篇文章将讲述怎样用信号量去实现同步。 信号量的互斥同步都是通过PV原语来操作的，我们可以通过注册两个信号量，让它们在互斥的问题上互动，从而达到同步。通过下面实例就可以很容易理解：   [cpp:no
Linux多线程编程---线程间同步（互斥锁、条件变量、信号量和读写锁）
热门推荐
君子性非异
10-10 2万+
本篇博文转自http://zhangxiaoya.github.io/2015/05/15/multi-thread-of-c-program-language-on-linux/ Linux下提供了多种方式来处理线程同步，最常用的是互斥锁、条件变量、信号量和读写锁。  下面是思维导图： 简介 进程— 资源分配的最小单位 线程— 程序执行的最小单位 进程是一个程序的一个实例，拥有自...
信号量---实现同步互斥
Code_ZX的博客
12-14 1万+
前言 了解信号量之前，要先了解临界资源、同步与互斥的概念 1.临界资源：在同一时间只能被一个进程调用的资源，也称互斥资源。 2.同步：保证访问的时序可控性，使调用资源的的顺序合理。 3.互斥：在进程调用临界资源是，不同进程之间要竞争该资源，那么一个进程调用了该资源，另一个进程无法再调用该资源的情形就叫互斥！ 4.临界区：代码中涉及到了操作临界资源的代码段叫临界区。 5.原子操作：该操作无法被打断 ...
【Linux 性能优化系列】Linux 性能优化 -- 网络性能篇 (C10K、C1000K、C10M 问题总结)
CopperSun 技术博客
05-27 468
【Linux 性能优化系列】Linux 性能优化 -- 网络优化(C10K、C1000K、C10M 问题总结) 【1】C10K 问题以及优化方法简介 C10K 表示单机同时处理 1 万个请求 (并发连接 1 万) 的问题； 主要待解决的问题 问题一，怎样在一个线程内处理多个请求，即要在一个线程内响应多个网络 I/O； 问题二，怎么更节省资源地处理客户请求，即要用更少的线程来服务这些请求； 参考致谢 本博客为博主的学习实践总结，并参考了众多博主的博文，在此表示感谢，博主若有不足之处，请批评指.
linux并发机制Ⅲ---信号量机制分析
05-19 538
1概述 信号量semaphore，是操作系统中一种常用的同步与互斥的机制； 信号量允许多个进程（计数值>1）同时进入临界区； 如果信号量的计数值为1，一次只允许一个进程进入临界区，这种信号量叫二值信号量； 信号量可能会引起进程睡眠，开销较大，适用于保护较长的临界区； 与读写自旋锁类似，linux内核也提供了读写信号量的机制； 2信号量 2.1 流程分析 可以将信号量比喻成一个盒子，初始化时在盒子里放入N把钥匙，钥匙先到先得，当N把钥匙都被拿走完后，再来拿钥匙的人就需要等待了，只有等...
在多用户并发访问情况下，服务器为每个用户连接建立一个进程。为了保证数据库数据的一致性，要求对数据库读写操作的限制条件是： (1) 允许任意多的进程对数据库同时读访问； (2) 一次只允许一个写进程对数据库进行写访问； (3) 如果有一个进程正在进行写数据库操作，禁止任何读进程进行读操作。 试写出数据库读进程和写进程的示意程序代码，通过信号量和wait、signal函数实现上述读写限制。
06-09
以下是基于信号量和wait、signal函数实现的数据库读写限制程序示例： ```c #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <signal.h> #include <sys/sem.h> #include <sys/shm.h> #define SHM_KEY 0x1234 // 共享内存的key #define SEM_KEY 0x5678 // 信号量的key #define BUFF_SIZE 1024 // 数据库缓冲区大小 union semun { int val; // value for SETVAL struct semid_ds *buf; // buffer for IPC_STAT & IPC_SET unsigned short *array; // array for GETALL & SETALL struct seminfo *__buf; // buffer for IPC_INFO }; // 定义共享内存结构体 typedef struct { char buffer[BUFF_SIZE]; // 数据库缓冲区 } ShmData; // 初始化信号量 int semInit(int semid, int value) { union semun sem_union; sem_union.val = value; return semctl(semid, 0, SETVAL, sem_union); } // P操作 int semP(int semid) { struct sembuf sem_b; sem_b.sem_num = 0; sem_b.sem_op = -1; sem_b.sem_flg = SEM_UNDO; return semop(semid, &sem_b, 1); } // V操作 int semV(int semid) { struct sembuf sem_b; sem_b.sem_num = 0; sem_b.sem_op = 1; sem_b.sem_flg = SEM_UNDO; return semop(semid, &sem_b, 1); } // 数据库读进程 void dbReadProc(int semid, ShmData *shm) { while (1) { semP(semid); // 请求访问数据库 printf("Reading data from database: %s\n", shm->buffer); sleep(1); // 模拟读取数据的耗时 semV(semid); // 释放数据库 } } // 数据库写进程 void dbWriteProc(int semid, ShmData *shm) { while (1) { semP(semid); // 请求访问数据库 printf("Writing data to database...\n"); fgets(shm->buffer, BUFF_SIZE, stdin); // 从标准输入中读取数据 sleep(1); // 模拟写入数据的耗时 semV(semid); // 释放数据库 } } int main() { // 创建共享内存 int shmid = shmget(SHM_KEY, sizeof(ShmData), 0666 | IPC_CREAT); if (shmid == -1) { perror("shmget"); exit(EXIT_FAILURE); } // 连接共享内存 ShmData *shm = (ShmData *)shmat(shmid, NULL, 0); if (shm == (void *)-1) { perror("shmat"); exit(EXIT_FAILURE); } // 创建信号量 int semid = semget(SEM_KEY, 1, 0666 | IPC_CREAT); if (semid == -1) { perror("semget"); exit(EXIT_FAILURE); } // 初始化信号量 semInit(semid, 1); // 初始值为1，表示允许读和写 // 创建数据库读进程和写进程 pid_t pid; if ((pid = fork()) == -1) { perror("fork"); exit(EXIT_FAILURE); } else if (pid == 0) { // 子进程执行读进程 dbReadProc(semid, shm); } else { // 父进程执行写进程 dbWriteProc(semid, shm); } // 等待子进程结束 if (waitpid(pid, NULL, 0) == -1) { perror("waitpid"); exit(EXIT_FAILURE); } // 删除共享内存和信号量 if (shmctl(shmid, IPC_RMID, 0) == -1) { perror("shmctl"); exit(EXIT_FAILURE); } if (semctl(semid, 0, IPC_RMID) == -1) { perror("semctl"); exit(EXIT_FAILURE); } return 0; } ``` 在该示例程序中，我们使用了共享内存来存储数据库缓冲区，利用信号量来实现读写操作的并发控制。其中，P操作用来请求访问数据库，V操作用来释放数据库。读进程和写进程在访问数据库之前都需要执行P操作，然后在访问完成后执行V操作。在写进程访问数据库期间，读进程会一直被阻塞，直到写进程释放数据库。这样就保证了对数据库读写操作的限制条件。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值