c/c++语言开发共享详解C语言编程之thread多线程

目录

• 线程创建与结束
• 线程的创建方式：
• 线程的结束方式：
• join()
• detach()
• 互斥锁
• <mutex> 头文件介绍
• std::mutex 介绍
• std::lock_guard
• std::unique_lock
• 示例：
• 原子变量
• 线程同步通信
• 线程死锁
• 死锁概述
• 死锁产生的条件
• 示例：
• 总结

  #include <iostream>  #include <utility>  #include <thread>  #include <chrono>  #include <functional>  #include <atomic>  void f1(int n)  {    for (int i = 0; i < 5; ++i) {      std::cout << "thread " << n << " executingn";      std::this_thread::sleep_for(std::chrono::milliseconds(1000));    }  }  void f2(int& n)  {    std::cout << "thread-id:" << std::this_thread::get_id() << "n";    for (int i = 0; i < 5; ++i) {      std::cout << "thread 2 executing:" << n << "n";      ++n;      std::this_thread::sleep_for(std::chrono::milliseconds(1000));    }  }  int main()  {    int n = 0;    std::thread t1; // t1 is not a thread t1 不是一个线程    std::thread t2(f1, n + 1); // pass by value 传值    std::thread t3(f2, std::ref(n)); // pass by reference  传引用    std::this_thread::sleep_for(std::chrono::milliseconds(2000));    std::cout << "nthread 4 create :n";    std::thread t4(std::move(t3)); // t4 is now running f2(). t3 is no longer a thread 这时候t3将不是线程,t4接替t3继续运行f2    t2.join();    t4.join();    std::cout << "final value of n is " << n << 'n';  }

  #include <iostream>  #include <thread>  using namespace std;  void threadhandle1(int time)  {  	//让子线程睡眠time秒  	std::this_thread::sleep_for(std::chrono::seconds(time));  	cout << "hello thread1!" << endl;  }  void threadhandle2(int time)  {  	//让子线程睡眠time秒ace this_thread是namespace   	std::this_thread::sleep_for(std::chrono::seconds(time));  	cout << "hello thread2!" << endl;  }  int main()  {  	//创建了一个线程对象,传入一个线程函数(作为线程入口函数),  	//新线程就开始运行了，没有先后顺序，随着cpu的调度算法执行   	std::thread t1(threadhandle1, 2);  	std::thread t2(threadhandle2, 3);  	//主线程(main)运行到这里，等待子线程结束，主线程才继续往下运行  	t1.join();  	t2.join();  	//把子线程设置为分离线程，子线程和主线程就毫无关系了  	//主线程结束的时候查看其他线程  	//但是这个子线程运行完还是没运行完都和这个主线程没关系了  	//这个子线程就从这个main分离出去了  	//运行程序时也看不到这个子线程的任何输出打印了      //t1.detach();  	cout << "main thread done!" << endl;  	//主线程运行完成，查看如果当前进程还有未运行完成的子线程  	//进程就会异常终止  	return 0;  }

  		// class template lock_guard  template<class _mutex>  	class lock_guard  	{	// class with destructor that unlocks a mutex  public:  	using mutex_type = _mutex;  	explicit lock_guard(_mutex& _mtx)  		: _mymutex(_mtx)  		{	// construct and lock  		_mymutex.lock();  		}  	lock_guard(_mutex& _mtx, adopt_lock_t)  		: _mymutex(_mtx)  		{	// construct but don't lock  		}  	~lock_guard() noexcept  		{	// unlock  		_mymutex.unlock();  		}  	lock_guard(const lock_guard&) = delete;  	lock_guard& operator=(const lock_guard&) = delete;  private:  	_mutex& _mymutex;  	};

  template<class _mutex>  	class unique_lock  	{	// whizzy class with destructor that unlocks mutex  public:  	typedef _mutex mutex_type;  	// construct, assign, and destroy  	unique_lock() noexcept  		: _pmtx(nullptr), _owns(false)  		{	// default construct  		}  	explicit unique_lock(_mutex& _mtx)  		: _pmtx(_std addressof(_mtx)), _owns(false)  		{	// construct and lock  		_pmtx->lock();  		_owns = true;  		}  	unique_lock(_mutex& _mtx, adopt_lock_t)  		: _pmtx(_std addressof(_mtx)), _owns(true)  		{	// construct and assume already locked  		}  	unique_lock(_mutex& _mtx, defer_lock_t) noexcept  		: _pmtx(_std addressof(_mtx)), _owns(false)  		{	// construct but don't lock  		}  	unique_lock(_mutex& _mtx, try_to_lock_t)  		: _pmtx(_std addressof(_mtx)), _owns(_pmtx->try_lock())  		{	// construct and try to lock  		}  	template<class _rep,  		class _period>  		unique_lock(_mutex& _mtx,  			const chrono::duration<_rep, _period>& _rel_time)  		: _pmtx(_std addressof(_mtx)), _owns(_pmtx->try_lock_for(_rel_time))  		{	// construct and lock with timeout  		}  	template<class _clock,  		class _duration>  		unique_lock(_mutex& _mtx,  			const chrono::time_point<_clock, _duration>& _abs_time)  		: _pmtx(_std addressof(_mtx)), _owns(_pmtx->try_lock_until(_abs_time))  		{	// construct and lock with timeout  		}  	unique_lock(_mutex& _mtx, const xtime *_abs_time)  		: _pmtx(_std addressof(_mtx)), _owns(false)  		{	// try to lock until _abs_time  		_owns = _pmtx->try_lock_until(_abs_time);  		}  	unique_lock(unique_lock&& _other) noexcept  		: _pmtx(_other._pmtx), _owns(_other._owns)  		{	// destructive copy  		_other._pmtx = nullptr;  		_other._owns = false;  		}  	unique_lock& operator=(unique_lock&& _other)  		{	// destructive copy  		if (this != _std addressof(_other))  			{	// different, move contents  			if (_owns)  				_pmtx->unlock();  			_pmtx = _other._pmtx;  			_owns = _other._owns;  			_other._pmtx = nullptr;  			_other._owns = false;  			}  		return (*this);  		}  	~unique_lock() noexcept  		{	// clean up  		if (_owns)  			_pmtx->unlock();  		}  	unique_lock(const unique_lock&) = delete;  	unique_lock& operator=(const unique_lock&) = delete;  	void lock()  		{	// lock the mutex  		_validate();  		_pmtx->lock();  		_owns = true;  		}  	_nodiscard bool try_lock()  		{	// try to lock the mutex  		_validate();  		_owns = _pmtx->try_lock();  		return (_owns);  		}  	template<class _rep,  		class _period>  		_nodiscard bool try_lock_for(const chrono::duration<_rep, _period>& _rel_time)  		{	// try to lock mutex for _rel_time  		_validate();  		_owns = _pmtx->try_lock_for(_rel_time);  		return (_owns);  		}  	template<class _clock,  		class _duration>  		_nodiscard bool try_lock_until(const chrono::time_point<_clock, _duration>& _abs_time)  		{	// try to lock mutex until _abs_time  		_validate();  		_owns = _pmtx->try_lock_until(_abs_time);  		return (_owns);  		}  	_nodiscard bool try_lock_until(const xtime *_abs_time)  		{	// try to lock the mutex until _abs_time  		_validate();  		_owns = _pmtx->try_lock_until(_abs_time);  		return (_owns);  		}  	void unlock()  		{	// try to unlock the mutex  		if (!_pmtx || !_owns)  			_throw(system_error(  				_std make_error_code(errc::operation_not_permitted)));  		_pmtx->unlock();  		_owns = false;  		}  	void swap(unique_lock& _other) noexcept  		{	// swap with _other  		_std swap(_pmtx, _other._pmtx);  		_std swap(_owns, _other._owns);  		}  	_mutex *release() noexcept  		{	// disconnect  		_mutex *_res = _pmtx;  		_pmtx = nullptr;  		_owns = false;  		return (_res);  		}  	_nodiscard bool owns_lock() const noexcept  		{	// return true if this object owns the lock  		return (_owns);  		}  	explicit operator bool() const noexcept  		{	// return true if this object owns the lock  		return (_owns);  		}  	_nodiscard _mutex *mutex() const noexcept  		{	// return pointer to managed mutex  		return (_pmtx);  		}  private:  	_mutex *_pmtx;  	bool _owns;  	void _validate() const  		{	// check if the mutex can be locked  		if (!_pmtx)  			_throw(system_error(  				_std make_error_code(errc::operation_not_permitted)));  		if (_owns)  			_throw(system_error(  				_std make_error_code(errc::resource_deadlock_would_occur)));  		}  	};

  ​  #include <iostream>  #include <atomic>//c++11线程库提供的原子类  #include <thread>//c++线程类库的头文件  #include <vector>  int count = 0;  //线程函数  void sumtask()  {    //每个线程给count加10次    for (int i = 0; i < 10; ++i)    {      count++;      std::this_thread::sleep_for(std::chrono::milliseconds(10));    }  }  int main()  {    //创建10个线程放在容器当中    std::vector<std::thread> vec;    for (int i = 0; i < 10; ++i)    {      vec.push_back(std::thread(sumtask));    }    //等待线程执行完成    for (unsigned int i = 0; i < vec.size(); ++i)    {      vec[i].join();    }    //所有子线程运行结束    std::cout << "count : " << count << std::endl;    return 0;  }  ​

  #include <iostream>  #include <atomic>//c++11线程库提供的原子类  #include <thread>//c++线程类库的头文件  #include <mutex>  #include <vector>  int count = 0;  std::mutex mutex;  //线程函数  void sumtask()  {    //每个线程给count加10次    for (int i = 0; i < 10; ++i)    {      {        std::lock_guard<std::mutex> lock(mutex);        count++;      }  ;      std::this_thread::sleep_for(std::chrono::milliseconds(10));    }  }  int main()  {    //创建10个线程放在容器当中    std::vector<std::thread> vec;    for (int i = 0; i < 10; ++i)    {      vec.push_back(std::thread(sumtask));    }    //等待线程执行完成    for (unsigned int i = 0; i < vec.size(); ++i)    {      vec[i].join();    }    //所有子线程运行结束，count的结果每次运行应该都是10000    std::cout << "count : " << count << std::endl;    return 0;  }

  #include <iostream>  #include <atomic>//c++11线程库提供的原子类  #include <thread>//c++线程类库的头文件  #include <vector>  //原子整型，cas操作保证给count自增自减的原子操作  std::atomic_int count = 0;  //线程函数  void sumtask()  {    //每个线程给count加10次    for (int i = 0; i < 10; ++i)    {      count++;    }  }  int main()  {    //创建10个线程放在容器当中    std::vector<std::thread> vec;    for (int i = 0; i < 10; ++i)    {      vec.push_back(std::thread(sumtask));    }    //等待线程执行完成    for (unsigned int i = 0; i < vec.size(); ++i)    {      vec[i].join();    }    //所有子线程运行结束，count的结果每次运行应该都是10000    std::cout << "count : " << count << std::endl;    return 0;  }

  #include <iostream>           //std::cout  #include <thread>             //std::thread  #include <mutex>              //std::mutex, std::unique_lock  #include <condition_variable> //std::condition_variable  #include <vector>  //定义互斥锁(条件变量需要和互斥锁一起使用)  std::mutex mtx;  //定义条件变量(用来做线程间的同步通信)  std::condition_variable cv;  //定义vector容器，作为生产者和消费者共享的容器  std::vector<int> vec;  //生产者线程函数  void producer()  {    //生产者每生产一个，就通知消费者消费一个    for (int i = 1; i <= 10; ++i)    {      //获取mtx互斥锁资源      std::unique_lock<std::mutex> lock(mtx);      //如果容器不为空，代表还有产品未消费，等待消费者线程消费完，再生产      while (!vec.empty())      {        //判断容器不为空，进入等待条件变量的状态，释放mtx锁，        //让消费者线程抢到锁能够去消费产品        cv.wait(lock);      }      vec.push_back(i); // 表示生产者生产的产品序号i      std::cout << "producer生产产品:" << i << std::endl;      /*      生产者线程生产完产品，通知等待在cv条件变量上的消费者线程，      可以开始消费产品了，然后释放锁mtx      */      cv.notify_all();      //生产一个产品，睡眠100ms      std::this_thread::sleep_for(std::chrono::milliseconds(100));    }  }  //消费者线程函数  void consumer()  {    //消费者每消费一个，就通知生产者生产一个    for (int i = 1; i <= 10; ++i)    {      //获取mtx互斥锁资源      std::unique_lock<std::mutex> lock(mtx);      //如果容器为空，代表还有没有产品可消费，等待生产者生产，再消费      while (vec.empty())      {        //判断容器为空，进入等待条件变量的状态，释放mtx锁，        //让生产者线程抢到锁能够去生产产品        cv.wait(lock);      }      int data = vec.back(); // 表示消费者消费的产品序号i      vec.pop_back();      std::cout << "consumer消费产品:" << data << std::endl;      /*      消费者消费完产品，通知等待在cv条件变量上的生产者线程，      可以开始生产产品了，然后释放锁mtx      */      cv.notify_all();      //消费一个产品，睡眠100ms      std::this_thread::sleep_for(std::chrono::milliseconds(100));    }  }  int main()  {    //创建生产者和消费者线程    std::thread t1(producer);    std::thread t2(consumer);    //main主线程等待所有子线程执行完    t1.join();    t2.join();    return 0;  }

  #include <iostream>           //std::cout  #include <thread>             //std::thread  #include <mutex>              //std::mutex, std::unique_lock  #include <condition_variable> //std::condition_variable  #include <vector>  //锁资源1  std::mutex mtx1;  //锁资源2  std::mutex mtx2;  //线程a的函数  void taska()  {    //保证线程a先获取锁1    std::lock_guard<std::mutex> locka(mtx1);    std::cout << "线程a获取锁1" << std::endl;    //线程a睡眠2s再获取锁2，保证锁2先被线程b获取，模拟死锁问题的发生    std::this_thread::sleep_for(std::chrono::seconds(2));    //线程a先获取锁2    std::lock_guard<std::mutex> lockb(mtx2);    std::cout << "线程a获取锁2" << std::endl;    std::cout << "线程a释放所有锁资源，结束运行！" << std::endl;  }  //线程b的函数  void taskb()  {    //线程b先睡眠1s保证线程a先获取锁1    std::this_thread::sleep_for(std::chrono::seconds(1));    std::lock_guard<std::mutex> lockb(mtx2);    std::cout << "线程b获取锁2" << std::endl;    //线程b尝试获取锁1    std::lock_guard<std::mutex> locka(mtx1);    std::cout << "线程b获取锁1" << std::endl;    std::cout << "线程b释放所有锁资源，结束运行！" << std::endl;  }  int main()  {    //创建生产者和消费者线程    std::thread t1(taska);    std::thread t2(taskb);    //main主线程等待所有子线程执行完    t1.join();    t2.join();    return 0;  }

  #include <iostream>           //std::cout  #include <thread>             //std::thread  #include <mutex>              //std::mutex, std::unique_lock  #include <condition_variable> //std::condition_variable  #include <vector>  //锁资源1  std::mutex mtx1;  //锁资源2  std::mutex mtx2;  //线程a的函数  void taska()  {    //保证线程a先获取锁1    std::lock_guard<std::mutex> locka(mtx1);    std::cout << "线程a获取锁1" << std::endl;    //线程a睡眠2s再获取锁2，保证锁2先被线程b获取，模拟死锁问题的发生    std::this_thread::sleep_for(std::chrono::seconds(2));    //线程a先获取锁2    std::lock_guard<std::mutex> lockb(mtx2);    std::cout << "线程a获取锁2" << std::endl;    std::cout << "线程a释放所有锁资源，结束运行！" << std::endl;  }  //线程b的函数  void taskb()  {    while (true)    {    }  }  int main()  {    //创建生产者和消费者线程    std::thread t1(taska);    std::thread t2(taskb);    //main主线程等待所有子线程执行完    t1.join();    t2.join();    return 0;  }