C++ - 多线程之初识多线程

1. 认识多线程

传统的C++（C++11之前）中并没有引入线程这个概念，在C++11出来之前，如果我们想要在C++中实现多线程，需要借助操作系统平台提供的API，比如Linux的<pthread.h>，或者windows下的<windows.h> 。

C++11提供了语言层面上的多线程，包含在头文件<thread>中。它解决了跨平台的问题，提供了管理线程、保护共享数据、线程间同步操作、原子操作等类。C++11 新标准中引入了5个头文件来支持多线程编程，如下图所示：

1.1 并发实现

多进程并发

使用多进程并发是将一个应用程序划分为多个独立的进程（每个进程只有一个线程），这些独立的进程间可以互相通信，共同完成任务。由于操作系统对进程提供了大量的保护机制，以避免一个进程修改了另一个进程的数据，使用多进程比多线程更容易写出安全的代码。但是这也造就了多进程并发的两个缺点：

在进程间的通信，无论是使用信号、套接字，还是文件、管道等方式，其使用要么比较复杂，要么就是速度较慢或者两者兼而有之。
运行多个线程的开销很大，操作系统要分配很多的资源来对这些进程进行管理。

由于多个进程并发完成同一个任务时，不可避免的是：操作同一个数据和进程间的相互通信，上述的两个缺点也就决定了多进程的并发不是一个好的选择。

多线程并发

多线程并发指的是在同一个进程中执行多个线程。

优点：

有操作系统相关知识的应该知道，线程是轻量级的进程，每个线程可以独立的运行不同的指令序列，但是线程不独立的拥有资源，依赖于创建它的进程而存在。也就是说，同一进程中的多个线程共享相同的地址空间，可以访问进程中的大部分数据，指针和引用可以在线程间进行传递。这样，同一进程内的多个线程能够很方便的进行数据共享以及通信，也就比进程更适用于并发操作。

缺点：

由于缺少操作系统提供的保护机制，在多线程共享数据及通信时，就需要程序员做更多的工作以保证对共享数据段的操作是以预想的操作顺序进行的，并且要极力的避免死锁(deadlock)。

1.2 多线程理解

单CPU内核的多个线程。

一个时间片运行一个线程的代码，并不是真正意义的并行计算。

多个cpu或者多个内核

可以做到真正的并行计算。

1.3 创建线程

创建线程很简单，只需要把函数添加到线程当中即可。这里介绍用普通函数去创建线程。

形式1：

std::thread myThread ( thread_fun); //函数形式为void thread_fun()
myThread.join();                    //同一个函数可以代码复用，创建多个线程

形式2：

std::thread myThread ( thread_fun(100)); //函数形式为void thread_fun(int x)
myThread.join();                         //同一个函数可以代码复用，创建多个线程

形式3：

std::thread (thread_fun,1).detach(); //直接创建线程，没有名字
                                     //函数形式为void thread_fun(int x)

代码举例

#include <iostream>
#include <thread>
using namespace std;

void thread_func1()
{
    cout << "子线程1" << endl;
}

void thread_func2(int x)
{
    cout << "子线程2 " << "x = " << x << endl;
}

int main()
{
    thread first(thread_func1);       //开启线程，调用：thread_func1()
    thread second(thread_func2, 666); //开启线程，调用：thread_func2(666)
    //thread third(thread_func2,3);   //开启第3个线程，共享thread_func2函数。
    cout << "主线程" << endl;
    
    first.join(); //必须说明添加线程的方式            
    second.join();
    cout << "子线程结束" << endl;//必须join完成
    return 0;
}

1.4 join与detach

线程分为主线程和子线程，对于线程的状态分为三种：主线程先运行结束，子线程先运行结束，主子线程同时结束。

在一些情况下需要在子线程结束后主线程才能结束，而一些情况则不需要等待，对于线程的处理方式有以下两种：

join()函数是一个等待线程完成函数，主线程需要等待子线程运行结束了才可以结束

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

void Main_Thread()//主线程
{
    cout << "主线程：干活..." << endl;
}

void Child_Thread()//子线程
{
    Sleep(5000);
    cout << "子线程：睡觉..." << endl;
}

int main()            
{
    thread t1(Child_Thread);
    t1.join();        //等待子线程结束后才进入主线程
    Main_Thread();

    return 0;
}

运行结果：

detach()函数称为分离线程函数，使用detach()函数会让线程在后台运行，即说明主线程不会等待子线程运行结束才结束通常称分离线程为守护线程(daemon threads)

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

void Main_Thread()//主线程
{
    cout << "主线程：干活..." << endl;
}

void Child_Thread()//子线程
{
    Sleep(5000);
    cout << "子线程：睡觉..." << endl;
}

int main()            
{
    thread t1(Child_Thread);
    t1.detach();        //分离线程，主线程不会等待子线程运行结束才结束
    Main_Thread();

    return 0;
}

运行结果：

2. 创建线程方式

下面会介绍多种创建线程的方式

2.1 普通函数

#include <iostream>
#include <thread>
using namespace std;

//No.1 普通函数充当线程处理函数
void print()
{
    cout << "线程处理函数启动......" << endl;
}
void test1()
{
    thread t1(print);
    t1.join();
}


int main()            
{
    test1();

    return 0;
}

2.2 Lambda表达式

#include <iostream>
#include <thread>
using namespace std;

//No.2 Lambda表达式充当线程处理函数
void test2()
{
    thread t1([]() {cout << "Lambda表达式充当线程处理函数......" << endl; });
    t1.join();
}


int main()            
{
    test2();

    return 0;
}

2.3 带参函数

#include <iostream>
#include <thread>
using namespace std;

//No.3 带参函数创建线程
//3.1 带参函数
void print(int num)
{
    cout << "id:" << num << endl;
}
void test3()
{
    int num = 1;
    thread t1(print, num);
    t1.join();
}

//3.2 带参函数（传引用）
void printReference(int& num)
{
    num = 1001;
    cout << "子线程:" << num << endl;
}
void test4()
{
    int num = 0;
    thread t1(printReference, ref(num));//需要传右值引用,使用ref（）包装为右值引用
    t1.join();
    cout << "主线程:" << num << endl;
}

//3.3 智能指针当做函数参数
void printPtr(unique_ptr<int> ptr)
{
    cout << "智能指针：" << *ptr.get() << endl;
}
void test5()
{
    unique_ptr<int> ptr(new int(100));
    thread t1(printPtr, move(ptr));
    t1.join();
    cout << "test5：" << ptr.get() << endl;
}


int main()            
{
    test4();
    test5();

    return 0;
}

2.4 成员函数

#include <iostream>
#include <thread>
using namespace std;

//No.4 通过类中成员函数去创建
//4.1 仿函数形式：类名方式调用
class Function
{
public:

    void operator()()
    {
        cout << "重载()" << endl;
    }
};

void test6()
{
    //对象
    Function fun;
    thread t1(fun);
    t1.join();
    //匿名对象
    thread t2((Function()));
    t2.join();
}

//4.2 类中的成员函数
class MM
{
public:
    void print(int& id)
    {
        cout << "id：" << id << endl;
    }

};
void test7()
{
    MM mm;
    int id = 1;
    thread t1(&MM::print, mm, ref(id));
    t1.join();
}


int main()            
{
    test6();
    test7();

    return 0;
}

————————————————

原文链接：https://blog.csdn.net/QLeelq/article/details/115747717

标签：多线程,函数,thread,C++,初识,线程,进程,include
From： https://www.cnblogs.com/zhuchunlin/p/17345878.html