C++ 11 多线程学习笔记2 --数据竞争和互斥 LogFile

落日映苍穹つ 2023-07-05 11:51 8阅读 0赞

[**https://www.bilibili.com/video/av39161756?p=3**][https_www.bilibili.com_video_av39161756_p_3]

**1.lock和unlock**

#include <iostream>
    #include <thread>
    #include <future>
    #include <mutex>
    #include <string>
    
    std::mutex mu;
    
    using namespace std;
    
    
    void share_print(string msg,int id)
    { 
    	mu.lock();//加锁
    	cout << msg<< id << endl;
    	//如果cout抛出异常，那么mu将会被永远锁住
    	mu.unlock();//解锁
    }
    
    
    void fountion1() { 
    	for (int i = 0; i > -100; i--) { 
    		share_print( "from t1: ", i);
    	}
    }
    
    
    int main()
    { 
    	thread t1(fountion1);
    
    	for (int i = 0; i < 100; i++) { 
    		share_print("from main: ",i);
    	}
    	//如果上面的代码抛出异常，t在join之前就会被销毁，这个时候代码就报错了
    	t1.join();
    
    	return 0;
    }

--------------------

**2.lock\_guard**

void share_print(string msg,int id)
    { 
    	lock_guard<mutex> guard(mu);
    
    	cout << msg<< id << endl;
    	//在guard析构的时候，mu就会被释放
    
    }

--------------------

**3.使用LogFile类保护ofstream**

#include <iostream>
    #include <thread>
    #include <future>
    #include <mutex>
    #include <string>
    #include <fstream>
    
    std::mutex mu;
    
    using namespace std;
    
    class LofFile { 
    public:
    	LofFile() { 
    		f.open("log.txt");
    	}
    
    	void share_print(string id, int val) { 
    		lock_guard<mutex> locker(m_mutex);
    		f << "from " << id << ":" << val << endl;
    	}
    protected:
    private:
    	mutex m_mutex;
    	ofstream f;
    	/************** |*这样的话 f 就在LofFile类的保护下了， |*不使用这个这个类，就无法使用 f |*不要写成员函数返回 f 的引用，如果这样写就把f暴露在外了 |* |* 除此之外，下面这样写也是不安全的 |* void pocessf(void fun(ofstream &) ){ |* fun(f); |* } |* */
    };
    
    void fountion1(LofFile & log) { 
    	for (int i = 0; i > -100; i--) { 
    		log.share_print( "from t1: ", i);
    	}
    }
    
    
    int main()
    { 
    	LofFile log;
    	thread t1(fountion1,ref(log));
    
    	for (int i = 0; i < 100; i++) { 
    		log.share_print("from main: ",i);
    	}
    	//如果上面的代码抛出异常，t在join之前就会被销毁，这个时候代码就报错了
    	t1.join();
    
    	return 0;
    }

--------------------

**4.unique\_lock可以锁住想要的部分**

class LofFile { 
    public:
    	LofFile() { 
    		f.open("log.txt");
    	}
    
    	void share_print(string id, int val) { 
    		std::unique_lock<std::mutex> locker(m_mutex);
    		cout << "from " << id << ":" << val << endl;
    		locker.unlock();
    		//...这里是不需要被锁着的代码
    	}
    	void share_print2(string id, int val) { 
    		std::lock(m_mutex, m_mutex2);
    		lock_guard<mutex> locker2(m_mutex2,std::adopt_lock);
    		lock_guard<mutex> locker(m_mutex, std::adopt_lock);
    		cout << "from " << id << ":" << val << endl;
    	}
    protected:
    private:
    	mutex m_mutex;
    	mutex m_mutex2;
    	ofstream f;
    };

**5.unique\_lock与lock\_guard的比较**

class LofFile { 
    public:
    	LofFile() { 
    		f.open("log.txt");
    	}
    
    	void share_print(string id, int val) { 
    		std::unique_lock<std::mutex> locker(m_mutex,std::defer_lock);
    		//加上std::defer_lock参数...这里是不需要被锁着的代码
    		locker.lock();
    		cout << "from " << id << ":" << val << endl;
    		locker.unlock();
    		//...这里是不需要被锁着的代码
    
    		//也可以字啊解锁之后，再次加锁
    		locker.lock();
    		//...这里是需要锁着的code
    
    		//unique_lock 可以被移动，不可以被复制
    		//lock_guard 不可以被移动，不可以被复制
    
    		std::unique_lock<mutex> locker2 = std::move(locker);
    
    		//unique这个弹性的操作有开销，
    		//一般使用lock_guard能满足要求首先选择lock_guard
    	}
    protected:
    private:
    	mutex m_mutex;
    	mutex m_mutex2;
    	ofstream f;
    };

--------------------

**5.f.open只打开一次**

class LofFile { 
    public:
    	LofFile() { 
    		f.open("log.txt");
    	}
    
    	void share_print(string id, int val) { 
    		//每次打印的时候都要进行判断，消耗了资源
    		{ 
    			std::unique_lock<std::mutex> locker2(m_mutex_open, std::defer_lock);
    			if (!f.is_open()) { 
    				f.open("log.txt");
    			}
    		}
    		std::unique_lock<std::mutex> locker(m_mutex,std::defer_lock);
    		//加上std::defer_lock参数...这里是不需要被锁着的代码
    		locker.lock();
    		cout << "from " << id << ":" << val << endl;
    		locker.unlock();
    	}
    protected:
    private:
    	mutex m_mutex;
    	mutex m_mutex_open;
    	//std::once_flag m_flag;
    	ofstream f;
    };

--------------------

**使用call\_once可以确保被一个线程调用一次**

class LofFile { 
    public:
    	LofFile() { 
    		f.open("log.txt");
    	}
    
    	void share_print(string id, int val) { 
    		/*{ std::unique_lock<std::mutex> locker2(m_mutex_open, std::defer_lock); if (!f.is_open()) { f.open("log.txt"); } }*/
    		//可以确保这个代码只被一个线程调用一次，比上面的代码更加高效
    		std::call_once(m_flag, [&]() { f.open("log.txt"); });
    		std::unique_lock<std::mutex> locker(m_mutex,std::defer_lock);
    		//加上std::defer_lock参数...这里是不需要被锁着的代码
    		locker.lock();
    		cout << "from " << id << ":" << val << endl;
    		locker.unlock();
    	}
    protected:
    private:
    	mutex m_mutex;
    	//mutex m_mutex_open;
    	std::once_flag m_flag;
    	ofstream f;
    };

--------------------

[https_www.bilibili.com_video_av39161756_p_3]: https://www.bilibili.com/video/av39161756?p=3