几个简单程序加深你对多线程和信号量的理解

最新推荐文章于 2023-05-04 10:16:05 发布
最新推荐文章于 2023-05-04 10:16:05 发布
阅读量8.6k 收藏 4
点赞数 1
分类专栏： S1: C/C++ S1: Win API s2: 软件进阶
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/stpeace/article/details/12359915
版权
s2: 软件进阶 同时被 3 个专栏收录
1053 篇文章 73 订阅
订阅专栏
S1: C/C++
972 篇文章 329 订阅
订阅专栏
S1: Win API
32 篇文章 6 订阅
订阅专栏 
#include <windows.h>
#include <iostream.h>

HANDLE g_hSemp1 = NULL;
HANDLE g_hSemp2 = NULL;

DWORD WINAPI ThreadProc(LPVOID pVoid);

int main()
{
	cout << "main thread" << endl;
	g_hSemp1 = CreateSemaphore(NULL, 1, 10, NULL);
	g_hSemp2 = CreateSemaphore(NULL, 1, 10, NULL);

	HANDLE hThread = CreateThread(NULL, 0, ThreadProc, NULL, 0, NULL);
	
	CloseHandle(hThread);
	CloseHandle(g_hSemp1);
	CloseHandle(g_hSemp2);

	return 0;
}

DWORD WINAPI ThreadProc(LPVOID pVoid)
{
	WaitForSingleObject(g_hSemp1, INFINITE);
	cout << "thread" << endl;
	ReleaseSemaphore(g_hSemp1, 1, NULL);

	return 0;
}

     结果：

main thread

 

#include <windows.h>
#include <iostream.h>

HANDLE g_hSemp1 = NULL;
HANDLE g_hSemp2 = NULL;

DWORD WINAPI ThreadProc(LPVOID pVoid);

int main()
{
	cout << "main thread" << endl;
	g_hSemp1 = CreateSemaphore(NULL, 1, 10, NULL);
	g_hSemp2 = CreateSemaphore(NULL, 1, 10, NULL);

	HANDLE hThread = CreateThread(NULL, 0, ThreadProc, NULL, 0, NULL);
	Sleep(1000);
	
	CloseHandle(hThread);
	CloseHandle(g_hSemp1);
	CloseHandle(g_hSemp2);

	return 0;
}

DWORD WINAPI ThreadProc(LPVOID pVoid)
{
	WaitForSingleObject(g_hSemp1, INFINITE);
	cout << "thread" << endl;
	ReleaseSemaphore(g_hSemp1, 1, NULL);

	return 0;
}

     结果：

main thread

thread

 

#include <windows.h>
#include <iostream.h>

HANDLE g_hSemp1 = NULL;
HANDLE g_hSemp2 = NULL;

DWORD WINAPI ThreadProc(LPVOID pVoid);

int main()
{
	cout << "main thread" << endl;
	g_hSemp1 = CreateSemaphore(NULL, 0, 10, NULL);
	g_hSemp2 = CreateSemaphore(NULL, 1, 10, NULL);

	HANDLE hThread = CreateThread(NULL, 0, ThreadProc, NULL, 0, NULL);
	Sleep(1000);
	
	CloseHandle(hThread);
	CloseHandle(g_hSemp1);
	CloseHandle(g_hSemp2);

	return 0;
}

DWORD WINAPI ThreadProc(LPVOID pVoid)
{
	WaitForSingleObject(g_hSemp1, INFINITE);
	cout << "thread" << endl;
	ReleaseSemaphore(g_hSemp1, 1, NULL);

	return 0;
}

     结果：

main thread

 

#include <windows.h>
#include <iostream.h>

HANDLE g_hSemp1 = NULL;
HANDLE g_hSemp2 = NULL;

DWORD WINAPI ThreadProc(LPVOID pVoid);

int main()
{
	cout << "main thread" << endl;
	g_hSemp1 = CreateSemaphore(NULL, 1, 10, NULL);
	g_hSemp2 = CreateSemaphore(NULL, 1, 10, NULL);

	HANDLE hThread = CreateThread(NULL, 0, ThreadProc, NULL, 0, NULL);
	Sleep(1000);
	
	CloseHandle(hThread);
	CloseHandle(g_hSemp1);
	CloseHandle(g_hSemp2);

	return 0;
}

DWORD WINAPI ThreadProc(LPVOID pVoid)
{
	WaitForSingleObject(g_hSemp1, INFINITE);
	WaitForSingleObject(g_hSemp2, INFINITE);
	cout << "thread" << endl;
	ReleaseSemaphore(g_hSemp1, 1, NULL);
	ReleaseSemaphore(g_hSemp2, 1, NULL);

	return 0;
}

     结果：

main thread

thread

 

#include <windows.h>
#include <iostream.h>

HANDLE g_hSemp1 = NULL;
HANDLE g_hSemp2 = NULL;

DWORD WINAPI ThreadProc(LPVOID pVoid);

int main()
{
	cout << "main thread" << endl;
	g_hSemp1 = CreateSemaphore(NULL, 1, 10, NULL);
	g_hSemp2 = CreateSemaphore(NULL, 0, 10, NULL);

	HANDLE hThread = CreateThread(NULL, 0, ThreadProc, NULL, 0, NULL);
	Sleep(1000);
	
	CloseHandle(hThread);
	CloseHandle(g_hSemp1);
	CloseHandle(g_hSemp2);

	return 0;
}

DWORD WINAPI ThreadProc(LPVOID pVoid)
{
	WaitForSingleObject(g_hSemp1, INFINITE);
	WaitForSingleObject(g_hSemp2, INFINITE);
	cout << "thread" << endl;
	ReleaseSemaphore(g_hSemp1, 1, NULL);
	ReleaseSemaphore(g_hSemp2, 1, NULL);

	return 0;
}

     结果：

main thread

 

#include <windows.h>
#include <iostream.h>

HANDLE g_hSemp1 = NULL;
HANDLE g_hSemp2 = NULL;

DWORD WINAPI ThreadProc(LPVOID pVoid);

int main()
{
	cout << "main thread" << endl;
	g_hSemp1 = CreateSemaphore(NULL, 1, 10, NULL);
	g_hSemp2 = CreateSemaphore(NULL, 1, 10, NULL);

	HANDLE hThread = CreateThread(NULL, 0, ThreadProc, NULL, 0, NULL);
	Sleep(1000);
	
	CloseHandle(hThread);
	CloseHandle(g_hSemp1);
	CloseHandle(g_hSemp2);

	return 0;
}

DWORD WINAPI ThreadProc(LPVOID pVoid)
{
	WaitForSingleObject(g_hSemp1, INFINITE);
	WaitForSingleObject(g_hSemp1, INFINITE);
	cout << "thread" << endl;
	ReleaseSemaphore(g_hSemp1, 1, NULL);
	ReleaseSemaphore(g_hSemp2, 1, NULL);

	return 0;
}

     结果：

main thread

 

#include <windows.h>
#include <iostream.h>

HANDLE g_hSemp1 = NULL;
HANDLE g_hSemp2 = NULL;

DWORD WINAPI ThreadProc(LPVOID pVoid);

int main()
{
	cout << "main thread" << endl;
	g_hSemp1 = CreateSemaphore(NULL, 1, 10, NULL);
	g_hSemp2 = CreateSemaphore(NULL, 0, 10, NULL);

	HANDLE hThread = CreateThread(NULL, 0, ThreadProc, NULL, 0, NULL);
	Sleep(1000);
	
	CloseHandle(hThread);
	CloseHandle(g_hSemp1);
	CloseHandle(g_hSemp2);

	return 0;
}

DWORD WINAPI ThreadProc(LPVOID pVoid)
{
	WaitForSingleObject(g_hSemp1, INFINITE);
	WaitForSingleObject(g_hSemp2, INFINITE);
	ReleaseSemaphore(g_hSemp2, 1, NULL);
	cout << "thread" << endl;

	return 0;
}

     结果：

main thread

 

#include <windows.h>
#include <iostream.h>

HANDLE g_hSemp1 = NULL;
HANDLE g_hSemp2 = NULL;

DWORD WINAPI ThreadProc(LPVOID pVoid);

int main()
{
	cout << "main thread" << endl;
	g_hSemp1 = CreateSemaphore(NULL, 1, 10, NULL);
	g_hSemp2 = CreateSemaphore(NULL, 0, 10, NULL);

	HANDLE hThread = CreateThread(NULL, 0, ThreadProc, NULL, 0, NULL);
	Sleep(1000);
	
	CloseHandle(hThread);
	CloseHandle(g_hSemp1);
	CloseHandle(g_hSemp2);

	return 0;
}

DWORD WINAPI ThreadProc(LPVOID pVoid)
{
	WaitForSingleObject(g_hSemp1, INFINITE);
	ReleaseSemaphore(g_hSemp2, 1, NULL);
	WaitForSingleObject(g_hSemp2, INFINITE);
	cout << "thread" << endl;

	return 0;
}

     结果：

main thread

thread

 

     好了，如果你愿意，你可以自己去变换程序，然后运行，并分析结果，相信对你理解多线程和信号量是有帮助的。


 

涛歌依旧
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
java信号量_JAVA多线程--信号量(Semaphore)
weixin_42117037的博客
02-12 1450
简介信号量(Semaphore)，有时被称为信号灯，是在多线程环境下使用的一种设施, 它负责协调各个线程, 以保证它们能够正确、合理的使用公共资源。一个计数信号量。从概念上讲，信号量维护了一个许可集。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore 只对...
信号量的原理总结
Bing's Blog
09-22 1万+
谈到信号量，大多数会立马想到PV操作，这个用荷兰语表示的专有名词。对比前面我们说的，四种实现临界区互斥的软件设计算法，PV操作更加的优良，现在这里就将对其原理进行详细的解释分析，以及如何在题目的场景中使用，包括算法的设计和问题的分析。http://blog.csdn.net/u011240016/article/details/52628467首先，信号量机制我们着重谈两个设计思路，核心相同，设计有
C++11多线程编程——信号量的实现
m0_47313541的博客
05-04 2073
信号量里面用到了一个叫PV操作的东西，P操作时阻塞，一般用wait()函数，V操作是唤醒，一般用singal()函数，至于不叫WS操作，反而为什么叫PV操作呢？这里我也不得不提一句，条件变量和互斥锁组合使用真的非常强大，生产消费者模型中用到了，线程池中用到了，现在说的信号量也用到了，所以大家一定要好好掌握条件变量和互斥锁的使用，它们俩是你在多线程世界中纵横捭阖的利剑。假设先开始跑funA，执行到sem.wait()的时候，进入wait函数可知，count减1，小于0，会发生阻塞，等待其他线程唤醒。
多线程（11）多线程同步之信号量（Linux实现）
哈尼的博客
02-27 1769
多线程（11）多线程同步之信号量（Linux实现）
多线程中的信号量
fuchangyaocool的博客
07-31 2056
信号量用在多线程多任务同步的，一个线程完成了某一个动作就通过信号量告诉别的线程，别的线程再进行某些动作。信号量不一定是锁定某一个资源，而是流程上的概念，比如：有 A，B 两个线程，B 线程要等 A 线程完成某一任务以后再进行自己下面的步骤，这个任务并不一定是锁定某一资源，还可以是进行一些计算或者数据处理之类。 信号量（信号灯）与互斥锁和条件变量的主要不同在于” 灯” 的概念，灯亮则意味着资源可用，灯灭则意味着不可用。信号量主要阻塞线程，不能完全保证线程安全，如果要保证线程安全，需要信号量和互斥锁一起使..
多线程与信号量
qq_42152365的博客
11-16 6578
多线程与信号量 我们的目标是快乐地学习计算机！O(∩_∩)O~   【信号量】 虽然它叫信号，其实从算法理解上和信号没啥关系。更好的理解是用于进程之间通信“我要运行，你不要运行”的变量。 信号量为0(≤0)表示“别动”，信号量是非0（&gt;0）表示“可以动”   【操作】 信号量只有三个操作： ① 赋予一个初始值 （init） ② 判断是不是0，如果是0，挂起，如果是正数，信...
用多线程同步方法解决生产者-消费者问题(操作系统课设
12-23
通过这次课程设计，我们不但加深了对操作系统的认识，还了解了操作系统中使用信号量解决生产者-消费者问题的算法实现。 多线程同步方法是解决生产者-消费者问题的有效方法之一，而信号量是解决生产者-消费者问题的...
操作系统实现生产者消费者问题.docx
02-20
课程设计的主要目的是通过实践加深对操作系统中进程同步概念的理解，以及掌握如何利用信号量机制解决这类问题。信号量是一种用于控制多个进程访问共享资源的同步工具，它可以用来表示资源的数量或者作为互斥锁使用。...
操作系统 教学大纲.docx
03-30
3. **线程管理**：讨论用户层线程和内核层线程的区别，多线程模型及其问题。 4. **调度策略**：包括FCFS、SJF、最高响应比优先法、优先级算法和轮转法。 5. **同步与互斥**：涉及临界区、同步原语、信号量以及经典...
7操作系统期末复习.pdf
07-14
在考试中，你可能还会遇到作业调度算法（如FCFS、SJF、HRN）、信号量机制（P、V操作）以及具体的编程问题，例如用伪代码实现同步和互斥等。这些都需要理解和熟练应用。复习时，不仅要掌握理论知识，还要通过练习题来...
操作系统期末复习重点(史上最全)[参考].pdf
10-12
5. **操作系统发展史**：从早期的手工操作、监督程序到批处理系统、多道批处理系统，再到分时系统、实时系统、网络操作系统、分布式操作系统，以及现在的嵌入式系统和智能卡操作系统，操作系统经历了从简单到复杂，...
c++多线程同步——信号量
04-27
c++多线程同步——信号量。非常简单的MFC工程。
利用信号量处理多线程示例
05-07
利用信号量，等待函数，处理多线程示例，处理生产者和消费者问题，谢谢
Linux进程通信---信号量 代码实现
不忘初心的专栏
08-30 1296
1、信号量使用流程（1）获得keyVal值值要一样。keyVal = ftok(PATH_SHM,PRI_SHM_ID);（2）创建信号量或打开信号量的键值nSemid = semget(keyVal,1,IPC_CREAT);（3）设置信号量 semctl(nSemid,0,SETVAL,1)（4）判断现在该资源是否被加锁，如果加锁则阻塞，如果不枷锁，则该进程把这块资源加锁，现在由这个进程使用。在
线程 互斥量 信号量——多线程服务器端的实现
amoscykl的博客
05-15 862
理解线程的概念 多进程模型的缺点：--创建进程的过程会带来一定的开销--为了完成进程间数据交换，需要特殊的IPC技术 最大的缺点：--每秒少则数十次，多则数前次的“上下文切换"是创建进程时最大的开销。  线程相比进程具有如下优点：--线程的创建和上下文切换比进程的创建和上下文切换更快。--线程间交换数据时无需特殊技术。 线程和进程的差异                               ...
【多线程】使用信号量进行同步
鱼思故渊的专栏
11-03 3040
信号量是最早出现的用来解决进程同步与互斥问题的机制(也可实现进程通信)，包括一个称为信号量的变量及对它进行的两个原语操作。信号量为一个整数，我们设这个信号量为：sem。很显然，我们规定在sem大于等于零的时候代表可供并发进程使用的资源实体数，sem小于零的时候，表示正在等待使用临界区的进程的个数。根据这个原则，在给信号量附初值的时候，我们显然就要设初值大于零。 p操作和v操作是不可中断的程序段，
Windows环境下利用“共享内存”实现进程间通信的C/C++代码---利用CreateFileMapping和MapViewOfFile
热门推荐
认知 行动 坚持
09-25 3万+
进程间的通信方式有很多种， 上次我们说了最傻瓜的“共享文件”的方法。
pyqt多线程信号量
最新发布
04-08
下面是一个简单的示例代码，演示了如何在PyQt中使用多线程和信号量： ```python from PyQt5.QtCore import QThread, QSemaphore class WorkerThread(QThread): def __init__(self, semaphore): super().__init__...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值