新手关于多线程的问题，搞不明白。。。。

Question

#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
不明白为什么，我已经设置为互斥的啊！

Answer 1

你只是create了一个互斥变量，没有控制两个线程啊。这种你就使用临界区嘛

Answer 2

WaitForSingleObject(mutex, INFINITE); 不是控制吗？不太明白，能不能稍微说清楚点？
谢谢啊！

Answer 3

WaitForSingleObject(mutex, INFINITE); 不知道lz用这个干啥。
你那个结果是正常的。
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,自然可以完成打印.

Answer 4

写错了一下重写.
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之间,可以完成打印.

Answer 5

#include "stdafx.h" 
#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; 
} 

Answer 6

你想要什么样的结果？
首先，CreateMutex要放在创建线程之前，不然线程执行到WaitForSingleObject的时候，可能Mutex还没有创建。
WaitForSingleObject获得Mutex之后，最后还要ReleaseMutex释放，否则其它线程无法获得。

Answer 7

我对于WaitForSingleObject可能有些理解错误，我以为调用WaitForSingleObject之后会像线程同步标志那样，停止其他线程运行呢。

Answer 8

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; 

Answer 9

WaitForSingleObject 就是一函数。函数返回程序就能继续进行。否则就等着。
其对具体同步信号的表现因不同的信号而议。
比如说自动event, waitfor...之后event会变成非激发态。
手动event, waitfor...之后仍然激发态。
互斥量，只在互斥量处于激发态之后才能返回，返回后调用ReleaseMutex来使互斥量处于激发态。

Answer 10

先创建互斥，CreateMutex 不然WaitForSingleObject  等待的时候互斥量都没有
然后一个线程使用完了 ReleaseMutex释放，让另一个线程得到互斥量，从而另一个线程开始工作

Answer 11

WaitForSingleObject是等待对象（mutex），如果对象没有被占用，则成功返回，否则一直等待，直到对象被释放，或者遇到超时等情况返回，根据返回值来判断是否成功。

Answer 12

那WaitForSingleObject是不是不会让mutex变成未激活状态，他的作用只是判断并且等待？？

Answer 13

有一个UCOSII操作系统;很简单的;建议有空看看;概念差不多;

Answer 14

除了判断和等待之外还会占有，mutex只能被一个线程占有。

Answer 15

试过你这段代码了，结果还是
aaaaaaa1 
aaaaaaa2没把这个问题说清楚。

Answer 16

I think the reply in 8th floor is right. In newThread2 (), the return value of WaitForSingleObject () is WAIT_ABANDONED
 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.

Answer 17

Lz, plese try my code which is based on yours as following several times, you may got different results -
#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; 
} 

Answer 18

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交替执行

Answer 19

floor 23: you're right. my code on floor 21 just show some result to lz, not using mutex to control these two threads. Actually we all don't know what lz wants to do.

Answer 20

newThread1获得控制权，打印出aaaaaaa1\n后线程就退出了，控制权转到newThread2，再打印出aaaaaaa2\n

Answer 21

1、两个线程选择执行其中一个，UP 22楼，用标志变量解决；
2、多线程之间互斥，UP 21楼 和 23楼。