七、C++锁的使用

1. 互斥锁
2. 条件变量
3. 原子操作

一、互斥锁

1.互斥锁（std::mutex）

使用std::lock_guard、std::unique_lock方便对线程进行加锁解锁，对std::mutex进行维护使用，不用再手动进行上锁加锁。

2.std::lock_guard

C++11提出，维护mutex的模板，自动管理互斥锁，构造函数内对锁进行加锁，析构时进行解锁，避免出现死锁、资源泄漏的情况。

3.std::unique_lock

在std::lock_guard基础上，可以手动对锁进行操作,std::unique_lock比std::lock_guard灵活，但是效率低，占用内存多点

#include "QT_mutex.h"
#include <QDebug>
#include <thread>
#include <string>
#include <iostream>
QT_mutex::QT_mutex(QWidget *parent)
    : QMainWindow(parent)
{
    ui.setupUi(this);
	std::thread thread1[3];
	for (int i = 0; i < 3; i++)
	{
		thread1[i] = std::thread(&QT_mutex::func1,this);
	}
	

	std::thread thread2[3];
	for (int i = 0; i < 3; i++)
	{
		thread2[i] = std::thread(&QT_mutex::func2, this);
	}
	
	
	std::thread thread3[3];
	for (int i = 0; i < 3; i++)
	{
		thread3[i] = std::thread(&QT_mutex::func3, this);
	}
	for (std::thread& th : thread3)
	{
		th.join();
	}
	for (std::thread& th : thread1)
	{
		th.join();
	}
	for (std::thread& th : thread2)
	{
		th.join();
	}
	qDebug() << "10 threads end";
}

void QT_mutex::func1()
{
	for (int i = 0; i < 100; ++i)
	{
		mutex1.lock();
		++j;
		std::thread::id id = std::this_thread::get_id();
		std::cout <<"func1" << " " <<id << " " << j << endl;
		mutex1.unlock();
	}
}

void QT_mutex::func2()
{
	for (int i = 0; i < 100; ++i)
	{
		std::lock_guard<std::mutex> lock(mutex2);
		++j2;
		std::thread::id id = std::this_thread::get_id();
		std::cout << "func2" << " " << id << " " << j2 << endl;
	}
}

void QT_mutex::func3()
{
	for (int i = 0; i < 100; ++i)
	{
		std::unique_lock<std::mutex> lock(mutex3);
		/*
		lock.unlock();//解锁
		//
		lock.lock();//加锁
		//
		++j3;
		if (lock.try_lock())//尝试加锁
		{
			//加锁成功
		}*/
		std::thread::id id = std::this_thread::get_id();
		std::cout << "func3" <<" "<< id << " " << j3 << endl;
	}
}

QT_mutex::~QT_mutex()
{}

#pragma once

#include <QtWidgets/QMainWindow>
#include "ui_QT_mutex.h"
#include <mutex>
using namespace std;

class QT_mutex : public QMainWindow
{
    Q_OBJECT

public:
    QT_mutex(QWidget *parent = nullptr);
	void func1();
	void func2();
	void func3();

    ~QT_mutex();

private:
    Ui::QT_mutexClass ui;
	std::mutex mutex1, mutex2, mutex3;
	int j = 0,j2 = 0,j3 = 0;

};

二.条件变量

condition_variable

1.condition_variable.wait(std::unique_lock<std::mutex>& lock)

当前线程的执行会被阻塞，直到收到 notify 为止

template<class Predicate>

condition_variable.wait(std::unique_lock<std::mutex>& lock，Predicate pred)

pred=false时导致当前线程阻塞并循环直到未true，pred=true时唤醒

2.condition_variable.notify_all()通知所有

condition_variable.notify_one()通知一个

int main()
{
    std::thread thread1[3];
	for (int i = 0; i < 3; i++)
	{
		thread1[i] = std::thread(&QT_mutex::threadfunc,this, i);

	}
	std::this_thread::sleep_for(std::chrono::seconds(2));
	// 修改共享状态，通知等待的线程
	//std::lock_guard<std::mutex> lock(mutex4);
	THREAD_FLAG = true;
	std::cout << "Notifying all threads...\n";
	cv.notify_all();  // 通知所有等待的线程
	for (int i = 0; i < 3; i++)
	{
		thread1[i].join();

	}
}

void QT_mutex::threadfunc(int i)
{
	std::unique_lock<std::mutex> lock(mutex4);
	if (!THREAD_FLAG)
	{
		cout <<i<< " wait cv" << endl;
		cv.wait(lock);
	}
	cout<<i << " threadfunc" << endl;
}

三.原子操作(atomic)

std::atomic<int> m_count(0);
void main()
{
    std::thread t1(&QT_mutex::threadatomic,this);
	std::thread t2(&QT_mutex::threadatomic,this);
	t1.join();
	t2.join();
	std::cout << "Counter value: " << m_count << std::endl;//20000
}

void QT_mutex::threadatomic()
{
	for (int i = 0; i < 10000; ++i) {
		m_count++; // 原子递增操作
	}
}