1、Windows
#include
#include #include // 线程个数
const int THREAD_NUM = 3;
// 循环次数
const int LOOP = 10;
// 子线程同步事件
HANDLE g_hThreadEvent[THREAD_NUM];
// 主线程与子线程同步
HANDLE g_Semaphore;
int g_Count = 0;
unsigned int __stdcall ThreadFunction(void *pPM)
{
int num = *(int *)pPM;
// 信号量++
ReleaseSemaphore(g_Semaphore, 1, NULL);
for (int i = 0;
i < LOOP;
i++)
{
// 等待该事件有效。
WaitForSingleObject(g_hThreadEvent[num], INFINITE);
g_Count++;
printf("第%d次 线程ID:%3d,线程打印:%c\n ", g_Count, GetCurrentThreadId(), num + 'A');
// 置位下一个事件有效。
SetEvent(g_hThreadEvent[(num + 1) % THREAD_NUM]);
}return 0;
}int main(void)
{
int i = 0;
HANDLE hThreadHandle[THREAD_NUM];
// 形参1：安全控制，一般为NULL
// 形参2：资源的初始值。
// 形参3：最大的资源数量。
// 形参4：该信号量的名称。
g_Semaphore = CreateSemaphore(NULL, 0, 1, NULL);
// 当前0个资源，最大允许1个同时访问for (i = 0;
i < THREAD_NUM;
i++)
{
// 形参1：安全控制。
// 形参2：该事件是手动复原（TRUE）还是自动复原（FALSE）。
// 形参3：指定事件的初始状态。若为TRUE，则为有信号状态，若为FALSE，则为无信号状态。
// 形参4：指定该事件的名称。
g_hThreadEvent[i] = CreateEvent(NULL, FALSE, FALSE, NULL);
}for (i = 0;
i < THREAD_NUM;
i++)
{
// 创建线程
hThreadHandle[i] = (HANDLE)_beginthreadex(nullptr, 0, ThreadFunction, &i, 0, nullptr);
// 每次创建完线程，该信号量都会等待，直至线程执行到释放信号量的代码为止。
WaitForSingleObject(g_Semaphore, INFINITE);
}
// 代码执行到这里，说明各个线程都已经执行到WaitForSingleObject，在等待确认信号。
// 置位线程1的事件。
SetEvent(g_hThreadEvent[0]);
// 等待所有线程返回。
WaitForMultipleObjects(THREAD_NUM, hThreadHandle, true, INFINITE);
for (i = 0;
i < THREAD_NUM;
i++)
{
CloseHandle(hThreadHandle[i]);
CloseHandle(g_hThreadEvent[i]);
}CloseHandle(g_Semaphore);
system("pause");
return 0;
} 2、Linux
#include
#include #include // 标记指定的线程是否处于等待 cond 的状态。
// 1处于等待 cond 的状态。
// 0cond 已成立或者处于阻塞状态。
bool g_flag_CA, g_flag_AB, g_flag_BC;
pthread_mutex_t g_mtx = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t g_condCA = PTHREAD_COND_INITIALIZER;
pthread_cond_t g_condAB = PTHREAD_COND_INITIALIZER;
pthread_cond_t g_condBC = PTHREAD_COND_INITIALIZER;
using PRINTFUNC = void *(*)(void *);
char g_cinfo[3] = {'A', 'B', 'C'};
char g_showcount = 10;
void MyCondWait(bool *pflag, pthread_cond_t *pcond, pthread_mutex_t *pmtx);
void MyCondSignal(bool *pflag, pthread_cond_t *pcond, pthread_mutex_t *pmtx);
void *PrintA(void *arg);
void *PrintB(void *arg);
void *PrintC(void *arg);
int main()
{
PRINTFUNC printfunc[3] = {
PrintA,
PrintB,
PrintC};
const size_t threadcount = sizeof(printfunc) / sizeof(PRINTFUNC);
pthread_t thread_pid[threadcount] = {0};
for (size_t i = 0;
i < threadcount;
i++)
{
if (pthread_create(thread_pid + i, nullptr, printfunc[i], (void *)(g_cinfo + i)) != 0)
{
std::cout << "Failed to create thread." << std::endl;
exit(1);
}
}
// 加 sleep(1) 的作用是使三个线程在执行完 sleep(1) 之后，
// 均堵塞在 pthread_cond_wait 。等待各自的条件的释放。
sleep(1);
pthread_mutex_lock(&g_mtx);
MyCondSignal(&g_flag_CA, &g_condCA, &g_mtx);
pthread_mutex_unlock(&g_mtx);
for (size_t i = 0;
i < threadcount;
i++)
{
pthread_join(thread_pid[i], nullptr);
}return 0;
}void *PrintA(void *arg)
{
char cinfo = *(char *)arg;
char showcount = g_showcount;
while (showcount--)
{
pthread_mutex_lock(&g_mtx);
MyCondWait(&g_flag_CA, &g_condCA, &g_mtx);
std::cout << 10 - showcount << "." << cinfo;
MyCondSignal(&g_flag_AB, &g_condAB, &g_mtx);
pthread_mutex_unlock(&g_mtx);
// 解的锁是 pthread_cond_wait 满足条件时加的锁。usleep(50);
}
// 防止线程 C ，在执行 MyCondSignal 函数时，由于 g_flag_CA = 0，导致程序执行在 while 循环中。
g_flag_CA = true;
return nullptr;
}void *PrintB(void *arg)
{
char cinfo = *(char *)arg;
char showcount = g_showcount;
while (showcount--)
{
pthread_mutex_lock(&g_mtx);
MyCondWait(&g_flag_AB, &g_condAB, &g_mtx);
std::cout << cinfo;
MyCondSignal(&g_flag_BC, &g_condBC, &g_mtx);
pthread_mutex_unlock(&g_mtx);
usleep(50);
}
return nullptr;
}void *PrintC(void *arg)
{
char cinfo = *(char *)arg;
char showcount = g_showcount;
while (showcount--)
{
pthread_mutex_lock(&g_mtx);
MyCondWait(&g_flag_BC, &g_condBC, &g_mtx);
std::cout << cinfo << std::endl;
MyCondSignal(&g_flag_CA, &g_condCA, &g_mtx);
pthread_mutex_unlock(&g_mtx);
usleep(50);
}
return nullptr;
}// 标记并使指定的线程处于等待 cond 满足的状态。
void MyCondWait(bool *pflag, pthread_cond_t *pcond, pthread_mutex_t *pmtx)
{
*pflag = true;
pthread_cond_wait(pcond, pmtx);
*pflag = false;
return;
}// 向指定的线程发出条件允许的通知。
void MyCondSignal(bool *pflag, pthread_cond_t *pcond, pthread_mutex_t *pmtx)
{
while (!*pflag)
{
// 执行到这里，说明该线程阻塞在 while 循环开头的 pthread_mutex_lock 函数位置。
// 需要调用 pthread_mutex_unlock() 函数将其解锁并执行到 pthread_cond_wait() 函数，使之处于等
// 待 cond 的状态。
pthread_mutex_unlock(&g_mtx);
usleep(50);
pthread_mutex_lock(&g_mtx);
}
// 执行到这里，说明指定的线程已经处于等待 cond 满足的状态。
pthread_cond_signal(pcond);
return;
} 【OS|编写一个程序，开启3个线程，这3个线程的ID分别为A、B、C，每个线程将自己的ID在屏幕上打印10遍，要求输出结果必须按ABC的顺序显示；如（ABCABC….依次递推。）】（SAW：Game Over！）
