大家好，又见面了，我是你们的朋友全栈君。
我们对线程做一些简单的同步处理，这里我们用互斥量(Mutex)。
互斥量(Mutex)和二元信号量类似，资源仅允许一个线程访问。与二元信号量不同的是，信号量在整个系统中可以被任意线程获取和释放，也就是说，同一个信号量可以由一个线程获取而由另一线程释放。而互斥量则要求哪个线程获取了该互斥量锁就由哪个线程释放，其它线程越俎代庖释放互斥量是无效的。
在使用互斥量进行线程同步时会用到以下几个函数：
代码语言：javascript复制HANDLE WINAPI CreateMutex(
LPSECURITY_ATTRIBUTES lpMutexAttributes, //线程安全相关的属性，常置为NULL
BOOL bInitialOwner, //创建Mutex时的当前线程是否拥有Mutex的所有权
LPCTSTR lpName //Mutex的名称
);说明： lpMutexAttributes也是表示安全的结构，与CreateThread中的lpThreadAttributes功能相同，表示决定返回的句柄是否可被子进程继承，如果为NULL则表示返回的句柄不能被子进程继承。bInitialOwner表示创建Mutex时的当前线程是否拥有Mutex的所有权，若为TRUE则指定为当前的创建线程为Mutex对象的所有者，其它线程访问需要先ReleaseMutex。lpName为Mutex的名称。
代码语言：javascript复制DWORD WINAPI WaitForSingleObject(
HANDLE hHandle, //要获取的锁的句柄
DWORD dwMilliseconds //超时间隔
);说明： WaitForSingleObject的作用是等待一个指定的对象(如Mutex对象)，直到该对象处于非占用的状态(如Mutex对象被释放)或超出设定的时间间隔。除此之外，还有一个与它类似的函数WaitForMultipleObjects，它的作用是等待一个或所有指定的对象，直到所有的对象处于非占用的状态，或超出设定的时间间隔。
hHandle：要等待的指定对象的句柄。dwMilliseconds：超时的间隔，以毫秒为单位；如果dwMilliseconds为非0，则等待直到dwMilliseconds时间间隔用完或对象变为非占用的状态，如果dwMilliseconds 为INFINITE则表示无限等待，直到等待的对象处于非占用的状态。
代码语言：javascript复制BOOL WINAPI ReleaseMutex(HANDLE hMutex);说明：释放所拥有的互斥量锁对象，hMutex为释放的互斥量的句柄。
代码语言：javascript复制#include "stdafx.h"
#include <windows.h>
#include <iostream>
#define NAME_LINE 40
//定义线程函数传入参数的结构体
typedef struct __THREAD_DATA
{
int nMaxNum;
char strThreadName[NAME_LINE];
__THREAD_DATA() : nMaxNum(0)
{
memset(strThreadName, 0, NAME_LINE * sizeof(char));
}
}THREAD_DATA;
HANDLE g_hMutex = NULL; //互斥量
//线程函数
DWORD WINAPI ThreadProc(LPVOID lpParameter)
{
THREAD_DATA* pThreadData = (THREAD_DATA*)lpParameter;
for (int i = 0; i < pThreadData->nMaxNum; i)
{
//请求获得一个互斥量锁
WaitForSingleObject(g_hMutex, INFINITE);
cout << pThreadData->strThreadName << " --- " << i << endl;
Sleep(100);
//释放互斥量锁
ReleaseMutex(g_hMutex);
}
return 0L;
}
int main()
{
//创建一个互斥量
g_hMutex = CreateMutex(NULL, FALSE, NULL);
//初始化线程数据
THREAD_DATA threadData1, threadData2;
threadData1.nMaxNum = 5;
strcpy(threadData1.strThreadName, "线程1");
threadData2.nMaxNum = 10;
strcpy(threadData2.strThreadName, "线程2");
//创建第一个子线程
HANDLE hThread1 = CreateThread(NULL, 0, ThreadProc, &threadData1, 0, NULL);
//创建第二个子线程
HANDLE hThread2 = CreateThread(NULL, 0, ThreadProc, &threadData2, 0, NULL);
//关闭线程
CloseHandle(hThread1);
CloseHandle(hThread2);
//主线程的执行路径
for (int i = 0; i < 5; i)
{
//请求获得一个互斥量锁
WaitForSingleObject(g_hMutex, INFINITE);
cout << "主线程 === " << i << endl;
Sleep(100);
//释放互斥量锁
ReleaseMutex(g_hMutex);
}
system("pause");
return 0;
}结果：
主线程 === 0 线程1 — 0 线程2 — 0 主线程 === 1 线程1 — 1 线程2 — 1 主线程 === 2 线程1 — 2 线程2 — 2 主线程 === 3 线程1 — 3 线程2 — 3 主线程 === 4 线程1 — 4 请按任意键继续… 线程2 — 4 线程2 — 5 线程2 — 6 线程2 — 7 线程2 — 8 线程2 — 9 为进一步理解线程同步的重要性和互斥量的使用方法，我们再来看一个例子。
买火车票是大家春节回家最为关注的事情，我们就简单模拟一下火车票的售票系统(为使程序简单，我们就抽出最简单的模型进行模拟)：有500张从北京到赣州的火车票，在8个窗口同时出售，保证系统的稳定性和数据的原子性。
【Demo4】：模拟火车售票系统 SaleTickets.h
代码语言：javascript复制#include "stdafx.h"
#include <windows.h>
#include <iostream>
#include <strstream>
#include <string>
using namespace std;
#define NAME_LINE 40
//定义线程函数传入参数的结构体
typedef struct __TICKET
{
int nCount;
char strTicketName[NAME_LINE];
__TICKET() : nCount(0)
{
memset(strTicketName, 0, NAME_LINE * sizeof(char));
}
}TICKET;
typedef struct __THD_DATA
{
TICKET* pTicket;
char strThreadName[NAME_LINE];
__THD_DATA() : pTicket(NULL)
{
memset(strThreadName, 0, NAME_LINE * sizeof(char));
}
}THD_DATA;
//基本类型数据转换成字符串
template<class T>
string convertToString(const T val)
{
string s;
std::strstream ss;
ss << val;
ss >> s;
return s;
}
//售票程序
DWORD WINAPI SaleTicket(LPVOID lpParameter);SaleTickets.cpp
代码语言：javascript复制#include "stdafx.h"
#include <windows.h>
#include <iostream>
#include "SaleTickets.h"
using namespace std;
extern HANDLE g_hMutex;
//售票程序
DWORD WINAPI SaleTicket(LPVOID lpParameter)
{
THD_DATA* pThreadData = (THD_DATA*)lpParameter;
TICKET* pSaleData = pThreadData->pTicket;
while(pSaleData->nCount > 0)
{
//请求获得一个互斥量锁
WaitForSingleObject(g_hMutex, INFINITE);
if (pSaleData->nCount > 0)
{
cout << pThreadData->strThreadName << "出售第" << pSaleData->nCount -- << "的票,";
if (pSaleData->nCount >= 0) {
cout << "出票成功!剩余" << pSaleData->nCount << "张票." << endl;
} else {
cout << "出票失败！该票已售完。" << endl;
}
}
Sleep(10);
//释放互斥量锁
ReleaseMutex(g_hMutex);
}
return 0L;
}测试程序：
代码语言：javascript复制//售票系统
void Test2()
{
//创建一个互斥量
g_hMutex = CreateMutex(NULL, FALSE, NULL);
//初始化火车票
TICKET ticket;
ticket.nCount = 100;
strcpy(ticket.strTicketName, "北京-->赣州");
const int THREAD_NUMM = 8;
THD_DATA threadSale[THREAD_NUMM];
HANDLE hThread[THREAD_NUMM];
for(int i = 0; i < THREAD_NUMM; i)
{
threadSale[i].pTicket = &ticket;
string strThreadName = convertToString(i);
strThreadName = "窗口" strThreadName;
strcpy(threadSale[i].strThreadName, strThreadName.c_str());
//创建线程
hThread[i] = CreateThread(NULL, NULL, SaleTicket, &threadSale[i], 0, NULL);
//请求获得一个互斥量锁
WaitForSingleObject(g_hMutex, INFINITE);
cout << threadSale[i].strThreadName << "开始出售 " << threadSale[i].pTicket->strTicketName << " 的票..." << endl;
//释放互斥量锁
ReleaseMutex(g_hMutex);
//关闭线程
CloseHandle(hThread[i]);
}
system("pause");
}结果：
窗口0开始出售 北京–>赣州 的票… 窗口0出售第100的票,出票成功!剩余99张票. 窗口1开始出售 北京–>赣州 的票… 窗口1出售第99的票,出票成功!剩余98张票. 窗口0出售第98的票,出票成功!剩余97张票. 窗口2开始出售 北京–>赣州 的票… 窗口2出售第97的票,出票成功!剩余96张票. 窗口1出售第96的票,出票成功!剩余95张票. 窗口0出售第95的票,出票成功!剩余94张票. 窗口3开始出售 北京–>赣州 的票… 窗口3出售第94的票,出票成功!剩余93张票. 窗口2出售第93的票,出票成功!剩余92张票. 窗口1出售第92的票,出票成功!剩余91张票. 窗口0出售第91的票,出票成功!剩余90张票. 窗口4开始出售 北京–>赣州 的票… 窗口4出售第90的票,出票成功!剩余89张票. 窗口3出售第89的票,出票成功!剩余88张票. 窗口2出售第88的票,出票成功!剩余87张票. 窗口1出售第87的票,出票成功!剩余86张票. 窗口0出售第86的票,出票成功!剩余85张票. 窗口5开始出售 北京–>赣州 的票… 窗口5出售第85的票,出票成功!剩余84张票. 窗口4出售第84的票,出票成功!剩余83张票. 窗口3出售第83的票,出票成功!剩余82张票. 窗口2出售第82的票,出票成功!剩余81张票.
发布者：全栈程序员栈长，转载请注明出处：https://javaforall.cn/153172.html原文链接：https://javaforall.cn
