C++——多线程

1.多进程和多线程：进程是一个总任务，一个进程可能包含多个线程。

2.并行和并发：

　　并发的关键是你有处理多个任务的能力，不一定要同时。

　　并行的关键是你有同时处理多个任务的能力。

3.共享数据的管理和线程间的通信

1.同步

所谓同步，是指在不同进程之间的若干程序片断，它们的运行必须严格按照规定的某种先后次序来运行，这种先后次序依赖于要完成的特定的任务。

如果用对资源的访问来定义的话，同步是指在互斥的基础上（大多数情况），通过其它机制实现访问者对资源的有序访问。在大多数情况下，同步已经实现了互斥，特别是所有写入资源的情况必定是互斥的。少数情况是指可以允许多个访问者同时访问资源。

2.互斥

所谓互斥，是指散布在不同进程之间的若干程序片断，当某个进程运行其中一个程序片段时，其它进程就不能运行它们之中的任一程序片段，只能等到该进程运行完这个程序片段后才可以运行。

如果用对资源的访问来定义的话，互斥某一资源同时只允许一个访问者对其进行访问，具有唯一性和排它性。但互斥无法限制访问者对资源的访问顺序，即访问是无序的。

3.互锁机制解决多线程的同步问题：只允许一个线程拥有对共享资源的独占

参考：http://www.jizhuomi.com/software/287.html?utm_source=tuicool

在WIN32中，同步机制主要有以下几种： 
（1）事件(Event); 
（2）信号量(semaphore); 
（3）互斥量(mutex); 
（4）临界区(Critical section)。

InitializeCriticalSection(&Critical);           　　　　//初始化临界区对象
hEvent = CreateEvent(NULL, FALSE, TRUE, "event");
hSemaphore = CreateSemaphore(NULL, , , "sema");
hMutex = CreateMutex(NULL, false, "mutex");             //创建互斥对象

1、临界区:通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。

2、互斥量:为协调共同对一个共享资源的单独访问而设计的。

3、信号量:为控制一个具有有限数量用户资源而设计。

4、事 件:用来通知线程有一些事件已发生，从而启动后继任务的开始。

1． 互斥量与临界区的作用非常相似，但互斥量是可以命名的，也就是说它可以跨越进程使用。所以创建互斥量需要的资源更多，所以如果只为了在进程内部是用的话使 用临界区会带来速度上的优势并能够减少资源占用量。因为互斥量是跨进程的互斥量一旦被创建，就可以通过名字打开它。

2． 互斥量（Mutex），信号灯（Semaphore），事件（Event）都可以被跨越进程使用来进行同步数据操作，而其他的对象与数据同步操作无关，但 对于进程和线程来讲，如果进程和线程在运行状态则为无信号状态，在退出后为有信号状态。所以可以使用WaitForSingleObject来等待进程和 线程退出。

3． 通过互斥量可以指定资源被独占的方式使用，但如果有下面一种情况通过互斥量就无法处理，比如现在一位用户购买了一份三个并发访问许可的数据库系统，可以根 据用户购买的访问许可数量来决定有多少个线程/进程能同时进行数据库操作，这时候如果利用互斥量就没有办法完成这个要求，信号灯对象可以说是一种资源计数 器。

1.临界区和互斥量可是视为相同的类型，区别是临界区只能用于进程内，而互斥量可用于不同进程中不不同线程。两个都是将线程串行化，面对高并发和长代码，效率低。

2.信号量：线程并行化。

1. CRITICAL_SECTION（临界区）: 公厕管理人员每次允许一个人进入，直到他出去了，下一个人才可以进入。
2. Event（事件）: 他告诉你公厕里面当前的状态。但是，你可以闯进去。他不会管你。要干什么取决于你。
3. Semaphore（信号量）: 他允许公厕里面有N个人同时用，再多的人就必须排队。
4. mutex（互斥量）: 厕所是属于他的。他用的时候，别人决不能进去。他不用的时候，得到他的允许，别人才能进去。他也可以选择让厕所空着。

原文：https://blog.csdn.net/liangtianmeng/article/details/81282486

应用：

一、并行方式的信号量在访问相同的一组资源时是最好的方法，因为它最大限度减少了系统调度线程的成本。

二、临界区和互斥量只应用于访问串行资源（例如使用全局计数器，系统参数访问和修改）。同一进程下的线程串行化时，只应该使用临界区。

三、按指定的规则进行线程协调时使用事件。

1.临界区（Critical Section）

临界区（Critical Section）是一段独占对某些共享资源访问的代码，在任意时刻只允许一个线程对共享资源进行访问。

#include "stdafx.h"
#include<windows.h>
#include<iostream>
using namespace std;

int number = ; //定义全局变量
CRITICAL_SECTION Critical;      //定义临界区句柄

unsigned long __stdcall ThreadProc1(void* lp)
{
    while (number < )
    {
        EnterCriticalSection(&Critical);//标识一个临界区。
        cout << "thread 1 :"<<number << endl;
        ++number;
        _sleep();
        LeaveCriticalSection(&Critical);//释放一个临界区
    }

    return ;
}

unsigned long __stdcall ThreadProc2(void* lp)
{
    while (number < )
    {
        EnterCriticalSection(&Critical);
        cout << "thread 2 :"<<number << endl;
        ++number;
        _sleep();
        LeaveCriticalSection(&Critical);
    }

    return ;
}

int main()
{
    InitializeCriticalSection(&Critical);   //初始化临界区对象

    CreateThread(NULL, , ThreadProc1, NULL, , NULL);
    CreateThread(NULL, , ThreadProc2, NULL, , NULL);

    Sleep(*);

    system("pause");
    return ;
}

2.事件(Event)

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

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

#include "stdafx.h"
#include<windows.h>
#include<iostream>
using namespace std;

int number = ; //定义全局变量
HANDLE hEvent;  //定义事件句柄

unsigned long __stdcall ThreadProc1(void* lp)
{
    while (number < )
    {
        WaitForSingleObject(hEvent, INFINITE);  //等待对象为有信号状态
        cout << "thread 1 :"<<number << endl;
        ++number;
        _sleep();
        SetEvent(hEvent);//将事件对象置为有信号状态
    }

    return ;
}

unsigned long __stdcall ThreadProc2(void* lp)
{
    while (number < )
    {
        WaitForSingleObject(hEvent, INFINITE);  //等待对象为有信号状态
        cout << "thread 2 :"<<number << endl;
        ++number;
        _sleep();
        SetEvent(hEvent);//将事件对象置为有信号状态
    }

    return ;
}

int main()
{
    CreateThread(NULL, , ThreadProc1, NULL, , NULL);
    CreateThread(NULL, , ThreadProc2, NULL, , NULL);
    hEvent = CreateEvent(NULL, FALSE, TRUE, "event");

    Sleep(*);

    system("pause");
    return ;
}

3.信号量

信号量是维护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 "stdafx.h"
#include<windows.h>
#include<iostream>
using namespace std;

int number = ; //定义全局变量
HANDLE hSemaphore;  //定义信号量句柄

unsigned long __stdcall ThreadProc1(void* lp)
{
    long count;
    while (number < )
    {
        WaitForSingleObject(hSemaphore, INFINITE);  //等待信号量为有信号状态
        cout << "thread 1 :"<<number << endl;
        ++number;
        _sleep();
        ReleaseSemaphore(hSemaphore, , &count);
    }

    return ;
}

unsigned long __stdcall ThreadProc2(void* lp)
{
    long count;
    while (number < )
    {
        WaitForSingleObject(hSemaphore, INFINITE);  //等待信号量为有信号状态
        cout << "thread 2 :"<<number << endl;
        ++number;
        _sleep();
        ReleaseSemaphore(hSemaphore, , &count);
    }

    return ;
}

int main()
{
    hSemaphore = CreateSemaphore(NULL, , , "sema");

    CreateThread(NULL, , ThreadProc1, NULL, , NULL);
    CreateThread(NULL, , ThreadProc2, NULL, , NULL);

    Sleep(*);

    system("pause");
    return ;
}

4.互斥量/互锁

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

eg1:

#include "stdafx.h"
#include<windows.h>
#include<iostream>
using namespace std;

int number = ; //定义全局变量
HANDLE hMutex;  //定义互斥对象句柄

unsigned long __stdcall ThreadProc1(void* lp)
{
    while (number < )
    {
        WaitForSingleObject(hMutex, INFINITE);
        cout << "thread 1 :"<<number << endl;
        ++number;
        _sleep();
        ReleaseMutex(hMutex);
    }

    return ;
}

unsigned long __stdcall ThreadProc2(void* lp)
{
    while (number < )
    {
        WaitForSingleObject(hMutex, INFINITE);
        cout << "thread 2 :"<<number << endl;
        ++number;
        _sleep();
        ReleaseMutex(hMutex);
    }

    return ;
}

int main()
{
    hMutex = CreateMutex(NULL, false, "mutex");     //创建互斥对象

    CreateThread(NULL, , ThreadProc1, NULL, , NULL);
    CreateThread(NULL, , ThreadProc2, NULL, , NULL);

    Sleep(*);

    system("pause");
    return ;
}

eg2:

#include <iostream>
#include <windows.h>
using namespace std;

HANDLE hMutex;

DWORD WINAPI Fun(LPVOID lpParamter)//线程定义
{
    while () {
        WaitForSingleObject(hMutex, INFINITE);//申请得到该资源：hMutex指定所申请的资源的句柄，INFINITE，表示如果没有申请到资源就一直等待该资源
        cout << "Fun display!" << endl;
        Sleep();
        ReleaseMutex(hMutex);//该函数用于释放一个独占资源，进程一旦释放该资源，该资源就不再属于它了
    }
}

int main()
{
    HANDLE hThread = CreateThread(NULL, , Fun, NULL, , NULL);//开启线程
    hMutex = CreateMutex(NULL, FALSE, L"screen"); //创造了一个名为screen并且归属于创建它的进程的资源
    CloseHandle(hThread);
    while () {
        WaitForSingleObject(hMutex, INFINITE);//申请得到该资源：hMutex指定所申请的资源的句柄，INFINITE，表示如果没有申请到资源就一直等待该资源
        cout << "main display!" << endl;
        Sleep();
        ReleaseMutex(hMutex);//该函数用于释放一个独占资源，进程一旦释放该资源，该资源就不再属于它了
    }

    return ;
}

---------------------
作者：已不再少年
来源：CSDN
原文：https://blog.csdn.net/s_lisheng/article/details/74278765
版权声明：本文为博主原创文章，转载请附上博文链接！