#include "stdafx.h"
#include <iostream>
#include <windows.h>using namespace std;
int ticker = 100;
HANDLE mutex;
DWORD WINAPI newThread1(LPVOID lpParam);
DWORD WINAPI newThread2(LPVOID lpParam);
int main(int argc, char* argv[])
{
HANDLE t1;
HANDLE t2;
t1 = CreateThread(NULL, 0, newThread1, NULL, NULL, NULL);
t2 = CreateThread(NULL, 0, newThread2, NULL, NULL, NULL);
CloseHandle(t1);
CloseHandle(t2);
mutex = CreateMutex(NULL, FALSE, NULL);
ReleaseMutex(mutex);
Sleep(4000);
return 0;
}DWORD WINAPI newThread1(LPVOID lpParam){ WaitForSingleObject(mutex, INFINITE);
cout<<"aaaaaaa1\n";
return 0;
}DWORD WINAPI newThread2(LPVOID lpParam){
WaitForSingleObject(mutex, INFINITE);
cout<<"aaaaaaa2\n";
return 0;
}打印结果为:
aaaaaaa1
aaaaaaa2
不明白为什么,我已经设置为互斥的啊!
#include <iostream>
#include <windows.h>using namespace std;
int ticker = 100;
HANDLE mutex;
DWORD WINAPI newThread1(LPVOID lpParam);
DWORD WINAPI newThread2(LPVOID lpParam);
int main(int argc, char* argv[])
{
HANDLE t1;
HANDLE t2;
t1 = CreateThread(NULL, 0, newThread1, NULL, NULL, NULL);
t2 = CreateThread(NULL, 0, newThread2, NULL, NULL, NULL);
CloseHandle(t1);
CloseHandle(t2);
mutex = CreateMutex(NULL, FALSE, NULL);
ReleaseMutex(mutex);
Sleep(4000);
return 0;
}DWORD WINAPI newThread1(LPVOID lpParam){ WaitForSingleObject(mutex, INFINITE);
cout<<"aaaaaaa1\n";
return 0;
}DWORD WINAPI newThread2(LPVOID lpParam){
WaitForSingleObject(mutex, INFINITE);
cout<<"aaaaaaa2\n";
return 0;
}打印结果为:
aaaaaaa1
aaaaaaa2
不明白为什么,我已经设置为互斥的啊!
谢谢啊!
你那个结果是正常的。
mutex = CreateMutex(NULL, FALSE, NULL); //创建mutex,不属于任何线程。此时mutex已经属于激发状态。DWORD WINAPI newThread1(LPVOID lpParam){ WaitForSingleObject(mutex, INFINITE);
cout < <"aaaaaaa1\n";
return 0;
}
//上面的第一个线程,在mutex出于激发状态的时候可以立即动作,自然会打印. aaaaaa1,线程1结束后mutex仍然回到激发状态DWORD WINAPI newThread2(LPVOID lpParam){
WaitForSingleObject(mutex, INFINITE);
cout < <"aaaaaaa2\n";
return 0;
}
//第二个线程在线程1完成之后可以得到处于激发状态的mutex,自然可以完成打印.
写错了一下重写.
mutex = CreateMutex(NULL, FALSE, NULL); //创建mutex,不属于任何线程。此时mutex已经属于激发状态。 DWORD WINAPI newThread1(LPVOID lpParam){ WaitForSingleObject(mutex, INFINITE);
cout < <"aaaaaaa1\n";
return 0;
}
//上面的第一个线程,在mutex出于激发状态的时候可以立即动作,自然会打印. aaaaaa1,线程1结束后,你没有释放mutex, ReleaseMutex(mutex);所以即使线程结束,mutex也不会被摧毁.
DWORD WINAPI newThread2(LPVOID lpParam){
WaitForSingleObject(mutex, INFINITE);
cout < <"aaaaaaa2\n";
return 0;
}
//第二个线程在线程1完成之后,WaitForSingleObject(mutex, INFINITE); 该函数会返回,但是返回值介于WAIT_ABANDONED_0与WAIT_ABANDONED_0_n+1之间,可以完成打印.
#include <iostream>
#include <windows.h> using namespace std;
int ticker = 100;
HANDLE hEvent;
DWORD WINAPI newThread1(LPVOID lpParam);
DWORD WINAPI newThread2(LPVOID lpParam);
int main(int argc, char* argv[])
{
HANDLE t1;
HANDLE t2;
t1 = CreateThread(NULL, 0, newThread1, NULL, CREATE_SUSPENDED, NULL);
t2 = CreateThread(NULL, 0, newThread2, NULL, CREATE_SUSPENDED, NULL); hEvent= CreateEvent(NULL, false, false, NULL); //一个自动重置的事件
ResumeThread(t1);
ResumeThread(t2);
SetEvent(hEvent);// set hEvent,只会打印一个...Sleep(4000); CloseHandle(t1);
CloseHandle(t2);
CloseHandle(hEvent);
//会有一个线程无法结束.
return 0;
} DWORD WINAPI newThread1(LPVOID lpParam){ WaitForSingleObject(hEvent, INFINITE);
cout < <"aaaaaaa1\n";
return 0;
} DWORD WINAPI newThread2(LPVOID lpParam){
WaitForSingleObject(hEvent, INFINITE);
cout < <"aaaaaaa2\n";
return 0;
}
首先,CreateMutex要放在创建线程之前,不然线程执行到WaitForSingleObject的时候,可能Mutex还没有创建。
WaitForSingleObject获得Mutex之后,最后还要ReleaseMutex释放,否则其它线程无法获得。
t1 = CreateThread(NULL, 0, newThread1, NULL, NULL, NULL);
t2 = CreateThread(NULL, 0, newThread2, NULL, NULL, NULL);
Sleep(4000);
CloseHandle(t1);
CloseHandle(t2);
ReleaseMutex(mutex);
return 0;
其对具体同步信号的表现因不同的信号而议。
比如说自动event, waitfor...之后event会变成非激发态。
手动event, waitfor...之后仍然激发态。
互斥量,只在互斥量处于激发态之后才能返回,返回后调用ReleaseMutex来使互斥量处于激发态。
然后一个线程使用完了 ReleaseMutex释放,让另一个线程得到互斥量,从而另一个线程开始工作
aaaaaaa1
aaaaaaa2没把这个问题说清楚。
which means "The specified object is a mutex object that was not released by the thread that owned the mutex object before the owning thread terminated. Ownership of the mutex object is granted to the calling thread, and the mutex is set to nonsignaled.".Actually, I think lz's code is meaningless for mutil-tread demo as both threads have been returned.
#include <iostream>
#include <windows.h> using namespace std;
int ticker = 100;
HANDLE mutex;
DWORD WINAPI newThread1(LPVOID lpParam);
DWORD WINAPI newThread2(LPVOID lpParam);
int main(int argc, char* argv[])
{
HANDLE t1;
HANDLE t2;
mutex = CreateMutex(NULL, FALSE, NULL);
t1 = CreateThread(NULL, 0, newThread1, NULL, NULL, NULL);
t2 = CreateThread(NULL, 0, newThread2, NULL, NULL, NULL);
Sleep(4000);
CloseHandle(t1);
CloseHandle(t2);
ReleaseMutex(mutex);
return 0;
} DWORD WINAPI newThread1(LPVOID lpParam)
{
for (int i = 0; i < 5; i++)
{
WaitForSingleObject(mutex, INFINITE);
cout <<"thread one - "<<i<<"\n";
ReleaseMutex(mutex);
}
return 0;
} DWORD WINAPI newThread2(LPVOID lpParam)
{
for (int i = 0; i < 5; i++)
{
WaitForSingleObject(mutex, INFINITE);
cout <<"thread two - "<<i<<"\n";
ReleaseMutex(mutex);
}
return 0;
}
using namespace std;
int ticker = 100;
HANDLE mutex;
DWORD WINAPI newThread1(LPVOID lpParam);
DWORD WINAPI newThread2(LPVOID lpParam);
int main(int argc, char* argv[])
{
HANDLE t1;
HANDLE t2;
mutex = CreateMutex(NULL, FALSE, NULL);
t1 = CreateThread(NULL, 0, newThread1, NULL, NULL, NULL);
t2 = CreateThread(NULL, 0, newThread2, NULL, NULL, NULL);
Sleep(4000);
CloseHandle(t1);
CloseHandle(t2);
ReleaseMutex(mutex);
return 0;
} DWORD WINAPI newThread1(LPVOID lpParam)
{
WaitForSingleObject(mutex, INFINITE);
for (int i = 0; i < 5; i++)
{
cout <<"thread one - " <<i <<"\n";
Sleep(10);
}
ReleaseMutex(mutex);
return 0;
} DWORD WINAPI newThread2(LPVOID lpParam)
{
WaitForSingleObject(mutex, INFINITE);
for (int i = 0; i < 5; i++)
{
cout <<"thread two - " <<i <<"\n";
Sleep(10);
}
ReleaseMutex(mutex);
return 0;
} 这样才起到互斥的效果吧1拿到信号后执行完循环后,2才能执行循环,如果不create mutex,那就是1和2交替执行
2、多线程之间互斥,UP 21楼 和 23楼。