多线程

1.程序和进程：程序是计算机指令的集合，它以文件的形式存储在磁盘上。而进程通常被定义为一个正在运行的程序的实例，是一个程序在其自身的地址空间的一次执行活动。

一个程序可以对应多个进程（例如可以同时打开多个记事本）。进程是资源申请，调度和独立运行的单位，因此，它使用系统中的运行资源，而程序不能申请系统资源，不能被系统调度，也不能作为独立运行的单位，因此，它不占用系统的运行资源。

2.进程组成：进程由两个部分组成：

（1）操作系统用来管理进程的内核对象：内核对象也是系统用来存放关于进程的统计信息的地方。内核对象是操作系统内部分配的一个内存块，该内存块是一种数据结构，其成员负责维护该对象的各种信息。由于内核对象的数据结构只能被内核访问使用，因此应用程序在内存中无法找到该数据结构，并直接改变其内容，只能通过windows提供的一些函数来对内核对象进行操作。

（2）地址空间：包含所有可执行模块或DLL模块的代码和数据。也包含动态内存分配的空间，例如线程的栈和堆分配空间。进程从来不执行任何东西，它只是线程的容器，若要使进程完成某项操作，它必须拥有一个在它的环境中运行的线程。

3.线程组成：

（1）线程的内核的对象：操作系统用它来对线程实施管理。内核对象也是系统用来存放线程统计信息的地方。

（2）线程栈：它用于维护线程在执行代码时需要的所有函数参数和局部变量。

当创建线程时，系统创建一个线程内核对象。该线程内核对象不是线程本身，而是操作系统用来管理线程的较小的数据结构

4.线程互斥

（1）互斥量

#include <windows.h>
#include <iostream>
HANDLE hMutex;
int n = 100;
DWORD WINAPI Thread(LPVOID lpParam)
{
    
    while(1)
    {
        WaitForSingleObject(hMutex,INFINITE);
        if(n>0)
        {
            std::cout<<"Thread sell "<<n<<std::endl;
            n--;
        }
        ReleaseMutex(hMutex);
    }
    return 0;
}
DWORD WINAPI Thread1(LPVOID lpParam)
{
    
    while(1)
    {
        WaitForSingleObject(hMutex,INFINITE);
        if(n>0)
        {
            std::cout<<"Thread1 sell "<<n<<std::endl;
            n--;
        }
        ReleaseMutex(hMutex);
    }
    return 0;
}


int main()
{
    HANDLE hThread;
    HANDLE hThread1;
    hMutex = CreateMutex(NULL,false,NULL);//创建互斥量

    hThread = CreateThread(NULL,0,Thread,NULL,0,NULL);//创建线程1 
    CloseHandle(hThread); 
    hThread1 = CreateThread(NULL,0,Thread1,NULL,0,NULL);//创建线程2
    CloseHandle(hThread1); 
    getchar(); 
    return 0;
}

（2）事件

#include <windows.h>
#include <iostream>
using namespace std;
int n = 100;
HANDLE hEvent;
DWORD WINAPI Thread(LPVOID lpParam)
{
	while(true)
	{
		WaitForSingleObject(hEvent,INFINITE);
		ResetEvent(hEvent);
		if(n>0)
		{
			cout<<"Thread sell "<<n<<endl;
			n--;
			SetEvent(hEvent);
		}
		else
			break;
	}
	return 0;
}

DWORD WINAPI Thread1(LPVOID lpParam)
{
	while(true)
	{
		WaitForSingleObject(hEvent,INFINITE);
		ResetEvent(hEvent);
		if(n>0)
		{
			cout<<"Thread1 sell "<<n<<endl;
			n--;
			SetEvent(hEvent);
		}
		else
			break;
	}
	return 0;
}

int main()
{
	hEvent = CreateEvent(NULL,FALSE,FALSE,NULL);
	SetEvent(hEvent);
	HANDLE handle = CreateThread(NULL,0,Thread,NULL,0,NULL);
	HANDLE handle1 = CreateThread(NULL,0,Thread1,NULL,0,NULL);
	CloseHandle(handle);
	CloseHandle(handle1);
	getchar();
	return 0;
}

（3）临界区

#include <windows.h>
#include <iostream>
using namespace std;
int n = 100;
CRITICAL_SECTION g_cs;//定义临界区
DWORD WINAPI Thread(LPVOID lpParam)
{
	while(true)
	{
		EnterCriticalSection(&g_cs);//进入临界区
		if(n>0)
		{
			
			cout<<"Thread sell "<<n<<endl;
			n--;
			LeaveCriticalSection(&g_cs);//离开临界区
		}
		else
		{
			LeaveCriticalSection(&g_cs);
			break;
		}
	}
	return 0;
}

DWORD WINAPI Thread1(LPVOID lpParam)
{
	while(true)
	{	
		EnterCriticalSection(&g_cs);
		if(n>0)
		{
			cout<<"Thread1 sell "<<n<<endl;
			n--;
			LeaveCriticalSection(&g_cs);
		}
		else
		{
			LeaveCriticalSection(&g_cs);
			break;
		}
	}
	return 0;
}

int main()
{
	InitializeCriticalSection(&g_cs);//初始化临界区
	HANDLE handle = CreateThread(NULL,0,Thread,NULL,0,NULL);
	HANDLE handle1 = CreateThread(NULL,0,Thread1,NULL,0,NULL);
	CloseHandle(handle);
	CloseHandle(handle1);
	getchar();
	DeleteCriticalSection(&g_cs);//释放临界区
	return 0;
}

（4）信号量

#include <windows.h>
#include <iostream>
using namespace std;
int n = 100;
HANDLE hThreadParameter;
DWORD WINAPI Thread(LPVOID lpParam)
{
	while(true)
	{
		WaitForSingleObject(hThreadParameter,INFINITE);
		if(n>0)
		{
			cout<<"Thread sell "<<n<<endl;
			n--;
			ReleaseSemaphore(hThreadParameter,1,NULL);
		}
		else
		{
			break;
		}
	}
	return 0;
}

DWORD WINAPI Thread1(LPVOID lpParam)
{
	while(true)
	{	
		WaitForSingleObject(hThreadParameter,INFINITE);
		if(n>0)
		{
			cout<<"Thread1 sell "<<n<<endl;
			n--;
			ReleaseSemaphore(hThreadParameter,1,NULL);
		}
		else
		{
			break;
		}
	}
	return 0;
}

int main()
{
	hThreadParameter = CreateSemaphore(NULL,0,1,NULL);//第一个参数表示安全控制，一般直接传入NULL。第二个参数表示初始资源数量。第三个参数表示最大并发数量。第四个参数表示信号量的名称，传入NULL表示匿名信号量。
	HANDLE handle = CreateThread(NULL,0,Thread,NULL,0,NULL);
	HANDLE handle1 = CreateThread(NULL,0,Thread1,NULL,0,NULL);
	ReleaseSemaphore(hThreadParameter,1,NULL);
	CloseHandle(handle);
	CloseHandle(handle1);
	getchar();
	CloseHandle(hThreadParameter);
	return 0;
}

5.线程同步

（1）事件

#include <windows.h>
#include <iostream>
using namespace std;
int n = 100;
HANDLE hEvent;
DWORD WINAPI Thread(LPVOID lpParam)
{
	int * i = (int *)lpParam;
	cout<<"Thread "<<*i<<" sell "<<n<<endl;
	n--;
	SetEvent(hEvent);
	return 0;
}

int main()
{
	hEvent = CreateEvent(NULL,FALSE,FALSE,NULL);
	SetEvent(hEvent);
	for(int i=0;i<100;i++)
	{
		WaitForSingleObject(hEvent,INFINITE);
		ResetEvent(hEvent);
		HANDLE handle = CreateThread(NULL,0,Thread,&i,0,NULL);
		CloseHandle(handle);
	}
	getchar();
	CloseHandle(hEvent);
	return 0;
}

（2）信号量

#include <windows.h>
#include <iostream>
using namespace std;
int n = 100;
HANDLE hThreadParameter;
DWORD WINAPI Thread(LPVOID lpParam)
{
	int * i = (int *)lpParam;
	cout<<"Thread "<<*i<<" sell "<<n<<endl;
	n--;
	ReleaseSemaphore(hThreadParameter,1,NULL);
	return 0;
}

int main()
{
	hThreadParameter = CreateSemaphore(NULL,0,1,NULL);//第一个参数表示安全控制，一般直接传入NULL。第二个参数表示初始资源数量。第三个参数表示最大并发数量。第四个参数表示信号量的名称，传入NULL表示匿名信号量。
	ReleaseSemaphore(hThreadParameter,1,NULL);
	for(int i=0;i<100;i++)
	{
		WaitForSingleObject(hThreadParameter,INFINITE);
		HANDLE handle = CreateThread(NULL,0,Thread,&i,0,NULL);
		CloseHandle(handle);
	}
	getchar();
	CloseHandle(hThreadParameter);
	return 0;
}