多线程基础

01 C++11 多线程基础

1.1 基本概念

• 进程：进程是正在运行的程序的实例，一个程序只有一个进程；

• 线程：一个进程中可以并发多个线程，每条线程并行执行不同的任务。

1.2 std::thread

1.2.1 创建线程

（1）一个线程可以用 thread 类的对象表示，初始化

std::thread t1(func，10, ref(a));  // func 为传入的函数名，后面是参数

创建了一个名为 t1 的线程，且该线程 立即开始执行。

（2）thread 在传递参数时，是以右值传递的。那么需要传递左值时，可以用 std::ref 包装按引用传递的值；用 std::cref 包装按 const 引用传递的值。

（3）当多个线程并发时，他们的执行顺序时无序的（也就是说并不是依次交替执行）。

1.2.1 常用成员函数

（1）void join() 函数

#include
#include
using namespace std;
void proc(int &a)
{
    cout << "我是子线程,传入参数为" << a << endl;
    cout << "子线程中显示子线程id为" << this_thread::get_id()<< endl;
}
int main()
{
    cout << "我是主线程" << endl;
    int a = 9;
    thread th2(proc,ref(a));//第一个参数为函数名，第二个参数为该函数的第一个参数，如果该函数接收多个参数就依次写在后面。此时线程开始执行。
    cout << "主线程中显示子线程id为" << th2.get_id() << endl;
    //此处省略多行，不要在创建完线程后马上join,应该在程序结束前join
    th2.join()；//此时主线程被阻塞直至子线程执行结束。
    return 0;
}

在程序结束前 join()，此时主函数被阻塞，无法继续向下执行，直至该线程结束。

注意不要在创建完线程后马上 join()，应该在程序结束前再 join()。

（2）void detach() 函数

1.3 std::mutex 和 std::atomic

多线程的执行是同时、无序的，那么当多个线程同时操作一个变量时，可能就会引发错误。这里采用 std::mutex 和 std::atomic 解决。

1.3.1 std::mutex

std::mutex 也是类，使用时需要实例化。当在某个线程中需要对某一变量进行操作时，先加锁，再进行操作，结束后再解锁。这样就避免了多个线程“争抢”。

std::mutex mutex;    // 初始化 mutex 对象
void print()
{
	mutex.lock();       // 加锁
	cout << "Hello world!";
	mutex.unlock();     // 解锁
}

1.3.1 std::atomic 原子类型

原子操作就是多线程程序中“最小的且不可并行化的”的操作，也就是说多个线程访问该资源时，有且仅有唯一一个线程在对这个资源进行操作。这样就省去了上面 mutex 加锁解锁的操作。

#include 
#include 
#include  

using namespace std;

atomic_llong total {0};    // 原子数据类型


void func(int)
{
	for(long long i = 0; i < 10000000LL; ++i)
		total += i;	
} 

int main()
{
	thread t1(func, 0);
	thread t2(func, 0);
	
	t1.join();
	t2.join();
	cout << total << endl;
	return 0;
}

相当于

#include 
#include 
#include  
#include 
using namespace std;

long long total {0};    // 原子数据类型
mutex m;

void func(int)
{
	m.lock();
	for(long long i = 0; i < 10000000LL; ++i)
		total += i;	
	m.unlock(); 
} 

int main()
{
	thread t1(func, 0);
	thread t2(func, 0);
	
	t1.join();
	t2.join();
	cout << total << endl;
	return 0;
}