C++多线程并发（一）：多线程并发的基本概念以及C++创建线程的基本方法

1.并发基本概念及实现，进程、线程基本概念

1.1并发、进程、线程的基本概念和综述

并发，进程，线程要求必须掌握

1.1.1 并发

两个或者更多的任务（独立的活动）同时发生（进行）：一个程序同时执行多个独立的任务；

• 以往计算机，单核cpu（中央处理器）：某个时刻只能执行一个任务：由操作系统调度，每秒钟进行多次所谓的“任务切换”，这时并发的假象（不是真正的并发），这种切换（上下文切换）是要有时间开销的，比如操作系统要保存你切换时的各种状态，执行进度等信息，都需要时间，一会切换回来的时候要复原这些信息。
• 随着硬件发展，出现了多处理器计算机：用于服务器和高性能计算领域。台式机：在一块芯片上有多核（多个）cpu：双核，4核，8核，10核…能够实现真正的并行执行多个任务（硬件并发）；
• 使用并发的原因：主要是就是同时可以干多个事，提高性能。

1.1.2 可执行程序

磁盘上一个文件，window下，一个扩展名为.exe的。linux,ls -al,rwxrwxrwx（x执行权限）；
进程，就是运行起来了的可执行程序；

1.1.3 进程

• 大家已经知道可执行文件是能够运行。
• window下，双击一个可执行程序来运行。linux ./文件名 ./a;
• 进程就是一个可执行文件运行起来了，就叫创建了一个进程；

1.1.4 线程

• 每个进程（执行起来的可执行程序），都有一个主线程，这个主线程是唯一的，也就是一个进程中只能有一个主线程。
• 当你执行可执行程序，产生了一个进程后，这个主线程就随着这个进程默默的启动起来了；
• ctrl+f5实际上运行这个程序的时候，实际上是进程的主线程执行（调用）这个main函数中的代码；
• 主线程与进程唇齿相依，有你必然有我，有我必然有你，没有我必然没有你；
• 线程：用来执行代码的
• 线程这个东西，理解成一条代码的执行通路（道路）；
• 除了主线程之外，我们可以通过自己写代码来创建其他线程，其他线程走的是别的道路，甚至去不同的地方
• 每创建一个新线程，我就可以在同一时刻，多干一个不同的事（多走一条不同的代码执行路径）；
• 多线程（并发）线程并不是越多越好，每个线程，都需要一个独立的堆栈空间（1M），线程之间的切换要保存很多中间状态；切换会耗费本该属于程序运行的时间；
• 总结线程
  • a)线程是用来执行代码的。
  • b)把线程这个东西理解成一条代码执行的通路（道路），一条新线程代表一条新的通路。
  • c)一个进程自动包含一个主线程，主线程随着进程默默的启动并运行，我们可以通过编码来创建多个其他线程（非主线程），但是创建的数量最大都不建议超过200-300个，至于到底多少个合适，大家在实际的项目中可以不断调整和优化，有的时候线程太多的时候效率反而会降低。
  • d)因为主线程是自动启动的，所以一个进程中最少也是有一个线程（主线程）。进程和主线程感觉是爹和儿子关系
  • e)说白了：多线程程序可以同时干多个事，所以运行效率高。但是到底有高，并不是一个很容易评估和量化的东西。
  • 大家仍旧需要在实际编程，实际项目中进行体会和调整优化；

1.1.5 学习心得

• 开发多线程程序：实力的体现。一个是商用的必须需求；
• 线程开发有一定难度。实现代码更复杂。理解上更难一些，需要一定的学习时间。
• c++线程会涉及很多新概念，对于c++道路上的成长特别关键，不要急于求成；
• 想拿高薪。网络通讯，网络服务器，网络方向。。。。。。多线程是绝对绕不开的必须得学；

1.2.并发的实现方法

两个或者更多的任务（独立的活动）同时发生（进行）
实现并发的手段：

• a)我们通过多个进程实现并发。
• b)在单独的进程中，我创建多个线程来实现并发；自己写代码来创建除了主线程之外的其他进程；

1.2.1 多进程并发

word启动后就是进程。ie浏览器启动后就是个进程。
帐号服务器，游戏逻辑服务器。服务器进行之间的通信。
进程之间通信（同一个电脑上：管道，文件，消息队列，共享内存）；
不同电脑上：socket通信技术；

1.2.2 多线程并发

单个进程中创建了多个线程。
线程：感觉像轻量级的进程。每个线程都有自己独立的运行路径，但是一个进程中的所有线程共享地址空间（共享内存）；
全局变量，指针，引用都可以在线程之间传递，所以：使用多线程开销远远小于多进程。
共享内存带来新问题，数据一致性问题；
多进程并发和多线程并发虽然可以混合使用，但建议，优先考虑多线程技术手段而不是多进程；
咱们在本章中，只讲多线程并发开发技术。后续谈到开发，都指的是多线程开发。

1.2.3 总结

和进程比，线程有如下优先：
(1)线程启动速度更快，更轻量级；
(2)系统资源开销更少，执行速度更快，比如共享内存这种通信方式比任何其他的通信方式都快；
缺点：
(1)使用有一定难度，要小心处理数据的一致性问题

1.3 C++11新标准线程库

以往：window:CreateThread(),_beginthred(),beginthredexe()创建线程

• linux:pthread_create();创建线程
• 临界区，互斥量；
• 以往的多线程代码不能跨平台；
• POSIX thread(pthread):跨平台；做一番配置，所以用起来也不是那么方便。
• 从c++11新标准，c++语言本身增加对多线程的支持，意味着可移植性（跨平台），这就大大减少开发人员工作量了；
• 即将讲解c++11新标准多线程程序的写法；

2. 线程启动、结束，创建线程多法、join,detach

2.1 范例演示线程运行的结束和开始

• 程序运行起来，生成一个进程，该进程所属的主线程开始自动运行；
• 实际上这个是主线程在执行，主线程从mian()函数返回，则整个进程执行完毕。
• 主线程从main()开始执行，那么我们自己创建的线程，也需要从一个函数开始运行（初始函数），一旦这个函数运行完毕，就代表着我们这个线程运行结束。
• 整个进程是否执行完毕的标志是主线程是否执行完，如果主线程执行完毕了，就代表了整个进程执行完毕了；
• 此时，一般情况下：如果其他子线程还没有执行完毕，那么这些子线程也会被操作系统强行终止。
• 所以，一般情况下，我们得到一个结论：如果大家想保持子线程（自己用代码创建的线程）的运行状态的话，那么大家要让主线程一直保持运行，不要让主线程运行完毕；（这条规律有例外，后续会解释这种例外）
• a)包含一个头文件thread要包含进来
• b)自己创建的线程也要从一个函数（初始函数）开始运行；
• c)main中开始写代码
• thread mytobj(myprint);
• mytobj.join();
• d)大家必须明确一点：有两个线程在跑，相当整个程序的执行有两条线在同时走，所以，可以同时干两个事，即使一条线被堵住了，另外一条线还是可以通行的。这就是多线程；

2.1.1 thread

• 是个标准库里的类
• myprint可调用对象。
• 创建了线程，线程执行起点（入口）myprint();
• myprint线程开始执行。

2.1.2 join()

• join()：加入/汇合，说白了就是阻塞，阻塞主线程，让主线程等待子线程执行完毕，然后子线程和主线程汇合。然后主线程在往下走
• 主线程阻塞到这里等到myprint()执行完，当子线程执行完毕，这个join()就执行完毕，主线程就继续往下走
• 阻塞主线程并等待myprint子线程执行完。
• 如果主线程执行完毕了，但子线程没执行完毕，这种程序员是不合适的，写出来的程序也是不稳定的；
• 一个书写良好的程序，应该是主线程等待子线程执行完毕后，自己才能最终退出；

2.1.3 detach()

• 传统多线程程序主线程要等待子线程执行完毕，然后自己再最后退出；
• detach:分离，也就是主线程不和子线程汇合了，你主线程执行你的，我子线程执行我的，你主线程也不必等我子线程运行结束，你可以先执行结束，这并不影响我子线程的执行。
• 为什么引入detach():我们创建了很多子线程，让主线程逐个等待子线程结束，这种编程方法不太好，所以引入了detach()
• 一旦detach()之后，与这个主线程关联的thread对象就会失去与这个主线程的关联，此时这个子线程就会驻留在后台运行（主线程跟该子线程失去联系），这个子线程就相当于被c++运行时库接管了，当这个子线程执行完成后，由运行时库负责清理该线程相关的资源（守护线程）

2.1.4 joinable()

判断是否可以成功使用join()或者detach();返回true(可以join或者detach)或者false(不能join或者detach)
具体用法见下代码示例：

#include<iostream>
#include<unistd.h>
#include<thread>
using namespace std;
void one_func()
{
    cout<<"one   thread begin"<<endl;
    sleep(3);
    cout<<"one   thread end"<<endl;
}
int main()
{
    thread p1(one_func);
    if(p1.joinable()) {
        cout<<"p1 can exec join or detach"<<endl;
    } else {
        cout<<"p1 can not exec join or detach"<<endl;
    }
    p1.join();
    if(p1.joinable()) {
        cout<<"p1 can exec join or detach"<<endl;
    } else {
        cout<<"p1 can not exec join or detach"<<endl;
    }
    return 0;
}

2.2 其他创建线程的手法

2.2.1 用类，以及一个问题范例

2.2.1.1 用类创建一个线程

因为thread的构造函数可以传递一个可调用对象，在C++对象中，当一个类实现了operator()后，这个类就可以作为可调用对象类，具体用法见如下示例代码：

#include<iostream>
#include<unistd.h>
#include<thread>
using namespace std;

class TA
{
public:
    void operator()() 
    {
        cout<<"TA thread begin"<<endl;
        sleep(3);
        cout<<"TA thread end   "<<endl;
    }
};

int main()
{
    TA ta;
    thread p1(ta);
    p1.join();
    return 0;
}

2.2.1.2 关于主线程提前释放，可能引起的两个问题讨论

• 问题一：当用类创建一个可调用对象时候，在类的构造函数中含有引用，如果该类构造出来的线程，跑在了主线程回收之后，这样该引用可能会引用到一个无效值。
• 问题二：在主线程先执行完，释放掉资源的情况下，此后用类的构造出来的线程是否还能正常跑？答案是可以的，因为用于构造线程的类虽然被释放，但是在构造线程时候会调用类的构造复制函数进行类的复制，所以在类释放掉之后不会影响线程。
  验证过程见下示例代码：

#include<iostream>
#include<unistd.h>
#include<thread>
using namespace std;

class TA
{
public:
    TA(int &i):m_i(i){
        cout<<"TA 构造函数"<<endl;
    }
    TA(const TA& ta):m_i(ta.m_i){
        cout<<"TA(const &TA)"<<endl;
    }
    void operator()() 
    {
        cout<<"TA thread begin"<<endl;
        cout<<"m_i:"<<m_i<<endl;
        sleep(1);
        cout<<"m_i:"<<m_i<<endl;
        cout<<"TA thread end   "<<endl;
    }
    ~TA(){
        cout<<"析构函数被执行"<<endl;
    }

private:
    int &m_i;
};

int main()
{
    //大家可能还有一个疑问：一旦调用detach()，那我主线程执行结束了，我这里用的这个ta这个
    //对象还在吗？（对象不在了）因为这个对象实际上是被复制到线程中去，执行完主线程后，ta会被销毁，但是所复制的TA对象依旧存在。所以，只要你这个
    //TA类对象里没有引用，没有指针，那么就不会产生问题；

    int i = 8;
    TA ta(i);
    thread p1(ta);
    p1.detach();
    sleep(1);
    cout<<"main pthread end"<<endl;
    //在这种情况下，主线程和p1分离执行，如果在主线程先执行完的情况下，会释放掉线程资源，
    //i的引用就可能会引用到一个无效值，产生不可预料的结果
    return 0;
}

2.2.2 用lambda表达式

因为thread中构造函数可以接受一个可调用对象，而在C++表达式中lambda表达式也是一个可调用对象，故可以用lambda表达式来创建一个线程，具体用法见下示例代码：

#include<iostream>
#include<unistd.h>
#include<thread>
using namespace std;
int main()
{
    cout<<"main   thread begin"<<endl;
    auto func = []{
        cout<<"lambda thread begin"<<endl;
        cout<<"lambda thread end  "<<endl;
    };

    thread p1(func);
    p1.join();

    cout<<"main   thread end  "<<endl;

    return 0;
}

本文中代码位置:点击进入