【C++】基础：多线程介绍与程序示例

多任务处理有两种形式，即：多进程和多线程。

1. 基于进程的多任务处理是程序的并发执行。多进程并发由于有操作系统的保护，因此代码相对安全，但资源消耗较大。
2. 基于线程的多任务处理是同一程序的片段的并发执行。多线程并发可以节省开销，但容易导致并发和死锁等问题。

下面主要了解多线程相关问题。

😏1. 多线程介绍

每一个进程（可执行程序）都有一个主线程，这个主线程是唯一的，自动创建的，即：一个进程中只有一个主线程，自己创建的线程一般称为子线程。

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

- thread：线程相关
- mutex：与互斥量相关的类，如加锁与解锁
- atomic
- condition_variable
- future

1. 死锁发生条件，如何避免
   死锁只有同时满足4个条件才发生：互斥条件、持有并等待条件、不可剥夺条件、环路等待条件。
   避免死锁只需破坏其中一个条件就行，最常见可行的是使用资源有序分配法。
2. 线程和进程区别
   本质区别：进程是操作系统资源分配的基本单位，线程是任务调度和执行的基本单位。
   稳定性：进程中某个线程崩溃，会导致整个进程崩溃。而进程中的子进程崩溃不会影响其他进程。
3. 线程切换为什么比进程切换快，节省了什么资源
   线程切换只需要切换堆栈和程序计数器等少量信息，而不需切换地址空间，避免了进程切换时需切换内存映射表等大量资源的开销，从而节省了时间和系统资源。

😊2. 多线程操作

join()：等待或者阻塞，阻塞主线程的执行，直到子线程调用结束，然后子线程与主线程汇合，继续向下走。

detach()：分离，启动的线程自主在后台运行，当前的代码继续往下执行，不等待新线程结束。一旦调用了detach()，就不能再用join()，否则系统会报错。这是由于detach()之后，两条线程的执行速度不一致导致的。

joinable()：判断是否可以成功使用join()或detach()的。

if (myThread.joinable()) foo.join();

lock()：使用互斥量进行共享内存保护的时候，一般情况是在所需要进行保护的代码段进行lock()操作，只有lock()成功时，代码才能继续执行，否则就会一直lock()不在向下执行，直到lock()成功。

unlock()：解锁资源

// 一个mutex变量控制同一个资源，因此会先打印完*再打印$
// 两个mutex变量则可能出现交替打印，因为不是修改统一资源
std::mutex mtx;  // mutex for critical section
void print_block (int n, char c) 
{
    mtx.lock();
    for (int i=0; i
    {
       std::cout << c; 
    }
    std::cout << '\n';
    mtx.unlock();
}
int main ()
{
    std::thread th1 (print_block,50,'*');//线程1：打印*
    std::thread th2 (print_block,50,'$');//线程2：打印$

    th1.join();
    th2.join();
    return 0;
}

trylock()：查看是否上锁

std::lock_guard()：即加锁，作用域结束后自动解锁，直接取代lock()与unlock()，用了lock_guard()之后，就不能在使用lock()与unlock()；创建lock_guard对象时，它将尝试获取提供给它的互斥锁的所有权。当控制流离开lock_guard对象的作用域时，lock_guard析构并释放互斥量。

unique_lock：是 lock_guard 的升级加强版，它具有 lock_guard 的所有功能，同时又具有其他很多方法，使用起来更加灵活方便，能够应对更复杂的锁定需要。

死锁：是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。

condition_variable

😆3. 多线程示例

Windows编写多线程C++程序需要包含头文件：#include <thread>

多线程实例：

#include <iostream>
#include <thread>

using namespace std;
void print();

void print()
{
	cout << "-----------thread test-------------" << endl;
}

class test {
public:
	// operator()() - 重载运算符+参数传递
	void operator()() {
		cout << "class subthread starting!!!" << endl;
		cout << "class subthread over!!!" << endl;
	}
	void operator()(int x,int y) {
		cout << "x+y=" << x+y << endl;
	}
};

int main()
{
	cout << "主线程id:" << this_thread::get_id() << endl;

	// 线程休眠 - 不同的时间表示
	std::this_thread::sleep_for(std::chrono::seconds(1));   //1秒 = 1000毫秒=10^6微秒
	cout << "1s\n";
#if 0
	std::this_thread::sleep_for(std::chrono::microseconds(2 * 1000000));  //微秒
	cout << "2s\n";
	std::this_thread::sleep_for(std::chrono::milliseconds(3000));  //毫秒
	cout << "3s\n";
	std::this_thread::sleep_for(std::chrono::minutes(1));
	cout << "1min\n";
	std::this_thread::sleep_for(std::chrono::hours(1));
	cout << "1hour\n";
#endif

	// 创建子线程
	cout << "\n子线程1!!!" << endl;
	thread v1(print);	//入口函数print
	v1.join();	//加入主线程
	// 是否可joinable()
	if (v1.joinable()) {
		cout << "可以调用join()或者detach()" << endl;
	}
	else {
		cout << "不可以调用join()或者detach()" << endl;
	}

	cout << "\n子线程2!!!" << endl;
	test v2;
	thread t2(v2);
	t2.join();

	cout << "\n子线程3!!!" << endl;
	test v3;
	thread t3(v3,2,4);
	t3.join();

	return 0;
}

运行结果如下：

以上。