windows线程状态

线程状态

就绪态

可以被调度执行，微内核分流器跟踪所有就绪进程，并按优先级顺序进行调度。

备用态

备用线程已经被选择下一次在一个特定的处理器上运行。该线程在这个状态等待，直到那个处理器可用，如果备用线程的优先级足够高，正在那个处理器上运行的线程可能被这个备用线程抢占。否则，该备用线程要等到正在运行的线程被阻塞或结束其时间片。

运行态

一旦微内核处理线程或进程切换，备用线程将进入运行状态并开始执行，执行过程一直持续到被抢占、时间片期满、被阻塞或终止。在两种情况下，它将回到就绪态。

等待态

• 当线程被一个事件（如I/O)阻塞、
• 为了同步自愿等待
• 一个环境子系统指引它把自身挂起时，该进程进入等待状态。当等待的条件满足时，如果它的所有资源都可用，则线程转到就绪态。

转换态

一个线程在等待后，如果准备好运行但资源不可用时，进入该状态。例如，一个线程的栈被换出存储器。当该资源可用时，线程进入就绪态。

终止态

一个线程可以被自己或者被另一个线程终止，或者当它的父进程终止时终止。一旦完成了清理工作，该线程从系统中移出，或者被执行体保留，供以后重新初始化。

线程关系

线程同步

同步是指线程之间所具有的一种制约关系，一个线程的执行依赖另一个线程的消息，当它没有得到另一个线程的消息时应等待，直到消息到达时才被唤醒，即他们之间有先后关系。

线程互斥

对于共享的进程系统资源，在各单个线程访问时的排它性。当有若干个线程都要使用某一共享资源时，任何时刻最多只允许一个线程去使用，其它要使用该资源的线程必须等待，直到占用资源者释放该资源

实现同步与互斥方法

分为两种：用户模式和内核模式。内核模式就是指利用系统内核对象的单一性来进行同步，使用时需要切换内核态与用户态，而用户模式就是不需要切换到内核态，只在用户态完成操作。
用户模式下的方法有：原子操作、临界区
内核模式下的方法有：互斥量、信号量、事件

	模式	线程所有权属性	不同进程的线程同步	线程异常退出是否会释放
临界区	用户	Y	N	N
互斥量	内核	Y	Y	Y
事件	内核	N	Y	N
信号量	内核	N	Y	N

线程同步实例

未同步状态

创建两个线程threadpro1与threadpro2并运行

#include "pch.h"
#include 
#include  

using namespace std;
int num = 1;//定义全局变量

unsigned long __stdcall threadpro1(void * lp)
{
	while (num<100)
	{
		cout << "thread1:" << num << endl;
		++num;
		Sleep(100);
		
	}
	return 0;
}

unsigned long __stdcall threadpro2(void * lp)
{
	while (num < 100)
	{
		cout << "thread2:" << num << endl;
		++num;
		Sleep(100);

	}
	return 0;
}
int main()
{
    
	CreateThread(NULL, 0, threadpro1, NULL, NULL, NULL);
	CreateThread(NULL, 0, threadpro2, NULL, NULL, NULL);

	Sleep(10 * 1000);
	system("pause");
	return 0;
}

两个线程之间存在竞争：

使用临界区实现同步

临界区（Critical Section）是一段独占对某些共享资源访问的代码，在任意时刻只允许一个线程对共享资源进行访问。如果有多个线程试图同时访问临界区，那么在有一个线程进入后其他所有试图访问此临界区的线程将被挂起，并一直持续到进入临界区的线程离开。临界区在被释放后，其他线程可以继续抢占，并以此达到用原子方式操作共享资源的目的。

临界区在使用时以CRITICAL_SECTION结构对象保护共享资源，并分别用EnterCriticalSection（）和LeaveCriticalSection（）函数去标识和释放一个临界区。所用到的CRITICAL_SECTION结构对象必须经过InitializeCriticalSection（）的初始化后才能使用，而且必须确保所有线程中的任何试图访问此共享资源的代码都处在此临界区的保护之下。否则临界区将不会起到应有的作用，共享资源依然有被破坏的可能。使用流程：
初始化临界区–>标识临界区–>释放临界区

// critical_section.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include "pch.h"
#include 
#include  

using namespace std;
int num = 1;//定义全局变量

CRITICAL_SECTION Critical;//定义临界区句柄

unsigned long __stdcall threadpro1(void* lp)
{
	while (num < 100)
	{
		EnterCriticalSection(&Critical);//标识一个临界区
		cout << "thread1:" << num << endl;
		++num;
		Sleep(100);
		LeaveCriticalSection(&Critical);//释放一个临界区
	}
	return 0;
}
unsigned long __stdcall threadpro2(void* lp)
{
	while (num < 100)
	{
		EnterCriticalSection(&Critical);//标识一个临界区
		cout << "thread2:" << num << endl;
		++num;
		Sleep(100);
		LeaveCriticalSection(&Critical);//释放一个临界区
	}
	return 0;
}
int main()
{
	InitializeCriticalSection(&Critical);//初始化一个临界区
	CreateThread(NULL, 0, threadpro1, NULL, NULL, NULL);
	CreateThread(NULL, 0, threadpro2, NULL, NULL, NULL);

	Sleep(10 * 1000);
	system("pause");
	return 0;
}

结果有序输出，但不是依此调用两个线程的

使用事件实现同步

事件(Event)是WIN32提供的最灵活的线程间同步方式，事件可以处于激发状态(signaled or true)或未激发状态(unsignal or false)。根据状态变迁方式的不同，事件可分为两类：
（1）手动设置：这种对象只可能用程序手动设置，在需要该事件或者事件发生时，采用SetEvent及ResetEvent来进行设置。
（2）自动恢复：一旦事件发生并被处理后，自动恢复到没有事件状态，不需要再次设置。

使用”事件”机制应注意以下事项：
（1）如果跨进程访问事件，必须对事件命名，在对事件命名的时候，要注意不要与系统命名空间中的其它全局命名对象冲突；
（2）事件是否要自动恢复；
（3）事件的初始状态设置。

由于event对象属于内核对象，故进程B可以调用OpenEvent函数通过对象的名字获得进程A中event对象的句柄，然后将这个句柄用于ResetEvent、SetEvent和WaitForMultipleObjects等函数中。此法可以实现一个进程的线程控制另一进程中线程的运行，例如：

HANDLE hEvent = OpenEvent(EVENT_ALL,true,"MyEvent");
ResetEvent(hEvent);

函数原型

HANDLE CreateEvent(
  LPSECURITY_ATTRIBUTES lpEventAttributes, //安全级别相关，通常被被设置为NULL，以获得默认的安全级别
  BOOL bManualReset, //创建一个人工重置的事件（TRUE）还是创建一个自动重置的事件（ FALSE）
  BOOL bInitialState, //用于指明该事件是要初始化为已通知状态（TRUE）还是未通知状态（FALSE）
  LPTSTR lpName //一个字符串，用于标示这个事件的名字
); 

#include "pch.h"
#include 
#include  

using namespace std;
int num = 1;//定义全局变量
HANDLE hEvent;//定义时间句柄

unsigned long __stdcall threadpro1(void* lp)
{
	while (num < 100)
	{
		WaitForSingleObject(hEvent, INFINITE);//等待对象为有信号状态，并且无穷等待(容易造成死锁，真实情况下应避免)
		cout << "thread1:" << num << endl;
		++num;
		Sleep(100);
		SetEvent(hEvent);

	}
	return 0;
}
unsigned long __stdcall threadpro2(void* lp)
{
	while (num < 100)
	{
		WaitForSingleObject(hEvent, INFINITE);//等待对象为有信号状态，并且无穷等待
		cout << "thread2:" << num << endl;
		++num;
		Sleep(100);
		SetEvent(hEvent);

	}
	return 0;
}
int main()
{
	CreateThread(NULL, 0, threadpro1, NULL, NULL, NULL);
	CreateThread(NULL, 0, threadpro2, NULL, NULL, NULL);
	hEvent = CreateEvent(NULL, FALSE, TRUE,NULL);//创建事件为无信号状态，初始状态有信号

	Sleep(10 * 1000);
	system("pause");
	return 0;
}

使用事件的方式线程1与线程2是依此运行，不同于使用临界区的方式

信号量

信号量是维护0到指定最大值之间的同步对象。信号量状态在其计数大于0时是有信号的，而其计数是0时是无信号的。信号量对象在控制上可以支持有限数量共享资源的访问。

信号量的特点和用途：
（1）如果当前资源的数量大于0，则信号量有效；
（2）如果当前资源数量是0，则信号量无效；
（3）系统决不允许当前资源的数量为负值；
（4）当前资源数量决不能大于最大资源数量。
函数原型
创建信号量：

HANDLE CreateSemaphore (
  　PSECURITY_ATTRIBUTE psa, //信号量的安全属性
　  LONG lInitialCount, //开始时可供使用的资源数
　  LONG lMaximumCount, //最大资源数
   PCTSTR pszName);     //信号量的名称

释放信号量：

BOOL WINAPI ReleaseSemaphore(
  　HANDLE hSemaphore,   //要增加的信号量句柄
  　LONG lReleaseCount, //信号量的当前资源数增加lReleaseCount
  　LPLONG lpPreviousCount  //增加前的数值返回
   );

打开信号量：

HANDLE OpenSemaphore (
  　DWORD fdwAccess,      //access
  　BOOL bInherithandle,  //如果允许子进程继承句柄，则设为TRUE
  　PCTSTR pszName  //指定要打开的对象的名字
  );

#include "pch.h"
#include 
#include  

using namespace std;
int num = 1;//定义全局变量
HANDLE hSemaphore; //定义信号量句柄
unsigned long __stdcall threadpro1(void* lp)
{
	long count;
	while (num < 100)
	{
		WaitForSingleObject(hSemaphore, INFINITE);//等待对象为有信号状态，并且无穷等待
		cout << "thread1:" << num << endl;
		++num;
		Sleep(100);
		ReleaseSemaphore(hSemaphore, 1, &count);
	}
	return 0;
}
unsigned long __stdcall threadpro2(void* lp)
{
	long count;
	while (num < 100)
	{
		WaitForSingleObject(hSemaphore, INFINITE);//等待对象为有信号状态，并且无穷等待
		cout << "thread2:" << num << endl;
		++num;
		Sleep(100);
		ReleaseSemaphore(hSemaphore, 1, &count);
	}
	return 0;
}

int main()
{
	hSemaphore = CreateSemaphore(NULL, 1, 100, NULL);//创建信号量
	CreateThread(NULL, 0, threadpro1, NULL, NULL, NULL);
	CreateThread(NULL, 0, threadpro2, NULL, NULL, NULL);

	Sleep(10 * 1000);
	system("pause");
	return 0;
}

使用互斥量使线程同步

采用互斥对象机制。 只有拥有互斥对象的线程才有访问公共资源的权限，因为互斥对象只有一个，所以能保证公共资源不会同时被多个线程访问。互斥不仅能实现同一应用程序的公共资源安全共享，还能实现不同应用程序的公共资源安全共享。
函数原型

HANDLE CreateMutex(
LPSECURITY_ATTRIBUTES lpMutexAttributes, // 指向安全属性的指针
BOOL bInitialOwner, // 初始化互斥对象的所有者
LPCTSTR lpName // 指向互斥对象名的指针
);

#include "pch.h"
#include 
#include  

using namespace std;
int num = 1;//定义全局变量
HANDLE hMutex; //定义互斥量句柄
unsigned long __stdcall threadpro1(void* lp)
{
	while (num < 100)
	{
		WaitForSingleObject(hMutex, INFINITE);//等待对象为有信号状态，并且无穷等待
		cout << "thread1:" << num << endl;
		++num;
		Sleep(100);
		ReleaseMutex(hMutex);

	}
	return 0;
}
unsigned long __stdcall threadpro2(void* lp)
{
	while (num < 100)
	{
		WaitForSingleObject(hMutex, INFINITE);//等待对象为有信号状态，并且无穷等待
		cout << "thread2:" << num << endl;
		++num;
		Sleep(100);
		ReleaseMutex(hMutex);

	}
	return 0;
}
int main()
{
	hMutex = CreateMutex(NULL, false, NULL);
	CreateThread(NULL, 0, threadpro1, NULL, NULL, NULL);
	CreateThread(NULL, 0, threadpro2, NULL, NULL, NULL);

	Sleep(10 * 1000);
	system("pause");
	return 0;
}

成功运行