用互斥对象(Mutex)来完成两个子程序的互斥。

楼主，你的程序也太乱了吧。

Mutex的用法也很简单，在main函数里创建一个Mutex，在线程里乎唯进入一段代码前用WaitForSIngleObject，退出代码后用ReleaseMutex就行了。

下面是岁如培橡扮从static int count=5开始的程序，前面的不用改。

static int count=5

static HANDLE h1

static HANDLE h2

HANDLE g_hMutex

void func1()

void func2()

int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])

{

int nRetCode = 0

DWORD dwThreadID1,dwThreadID2

g_hMutex = CreateMutex(NULL, FALSE, NULL)

h1=CreateThread((LPSECURITY_ATTRIBUTES)NULL,

0,

(LPTHREAD_START_ROUTINE)func1,

(LPVOID)NULL,

0,&dwThreadID1)

if(h1==NULL)

printf("Thread1 create Fail!\n")

else

printf("Thread1 create Success!\n")

h2=CreateThread((LPSECURITY_ATTRIBUTES)NULL,

0,

(LPTHREAD_START_ROUTINE)func2,

(LPVOID)NULL,

0,&dwThreadID2)

if(h1==NULL)

printf("Thread2 create Fail!\n")

else

printf("Thread2 create Success!\n")

Sleep(1000)

CloseHandle(h1)

CloseHandle(h2)

ExitThread(0)

return nRetCode

}

void func2()

{

int r2

WaitForSingleObject(g_hMutex, INFINITE)

r2=count

_sleep(100)

r2=r2+1

count=r2

printf("count in func2=%d\n",count)

ReleaseMutex(g_hMutex)

}

void func1()

{

int r1

WaitForSingleObject(g_hMutex, INFINITE)

r1=count

_sleep(500)

r1=r1+1

count=r1

printf("count in func1=%d\n",count)

ReleaseMutex(g_hMutex)

}

循环等待其实是这样的：检查条芹洞件满不满足，不满足就解锁，然后等，等到了要检测的时候，又上锁，然后检查，不满足就解锁。

也就是说，进了pthread_cond_wait函数以后，它就释放了lock，然后在has_product上等待，等到has_product被触发了，就再上锁，然后出函数。你的消费者线程调用了pthread_cond_wait以后，就释放了锁，然后这个函数不返回（这个函数不返回你的代码就不会运行下去），等到has_product触发了嫌乎枯，这个函数就获取锁，然后返回。

再解释一下，就是调用这个函数之前，你这个线程是拿顷悔到锁的；出了这个函数，你的线程也还是拿到锁的；但是进了这个函数还没出来的过程中，你的线程会释放锁。

是。

锁的类型如果正尺不是PTHREAD_MUTEX_RECURSIVE，那么就算是同一基清谈个线程，也只能获取一次。

锁的类型如果不是PTHREAD_MUTEX_ERRORCHECK或PTHREAD_MUTEX_RECURSIVE，那么就算是同一个线程，再次获取锁的时候也会卡在那边等待，而不会返回错误搏碰或成功

---