C++11各种锁的具体使用

目录

• Mutex（互斥锁）

• 什么是互斥量（锁）？

• condition_variable的wait

#include <iostream>
#include <mutex>
#include <thread>
#include <vector>
std::mutex g_mutex;
int g_count = 0;
void Counter() {
  g_mutex.lock();
  int i = ++g_count;
  std::cout << "count: " << i << std::endl;
  // 前面代码如有异常，unlock 就调不到了。
  g_mutex.unlock();
}
int main() {
  const std::size_t SIZE = 4;
  // 创建一组线程。
  std::vector<std::thread> v;
  v.reserve(SIZE);
  for (std::size_t i = 0; i < SIZE; ++i) {
    v.emplace_back(&Counter);
  }
  // 等待所有线程结束。
  for (std::thread& t : v) {
    t.join();
  }
  return 0;
}

#include <iostream>
#include <mutex>
#include <thread>
#include <vector>
std::mutex g_mutex;
int g_count = 0;
void Counter() {
  // lock_guard 在构造函数里加锁，在析构函数里解锁。
  std::lock_guard<std::mutex> lock(g_mutex);
  int i = ++g_count;
  std::cout << "count: " << i << std::endl;
}
int main() {
  const std::size_t SIZE = 4;
  std::vector<std::thread> v;
  v.reserve(SIZE);
  for (std::size_t i = 0; i < SIZE; ++i) {
    v.emplace_back(&Counter);
  }
  for (std::thread& t : v) {
    t.join();
  }
  return 0;
}

#include <iostream>
#include <mutex>
#include <thread>
#include <vector>
std::mutex g_mutex;
int g_count = 0;
void Counter() {
  std::unique_lock<std::mutex> lock(g_mutex);
  int i = ++g_count;
  std::cout << "count: " << i << std::endl;
}
int main() {
  const std::size_t SIZE = 4;
  std::vector<std::thread> v;
  v.reserve(SIZE);
  for (std::size_t i = 0; i < SIZE; ++i) {
    v.emplace_back(&Counter);
  }
  for (std::thread& t : v) {
    t.join();
  }
  return 0;
}

#include <iostream>
#include <thread>
#include <mutex> 
std::recursive_mutex mtx;           
void print_block (int n, char c) {
  mtx.lock();
  mtx.lock();
  mtx.lock();
  for (int i=0; i<n; ++i) { std::cout << c; }
  std::cout << '\n';
  mtx.unlock();
  mtx.unlock();
  mtx.unlock();
}
int main ()
{
  std::thread th1 (print_block,50,'*');
  std::thread th2 (print_block,50,'$');
  th1.join();
  th2.join();
  return 0;
}

//h文件
#pragma once
#include <thread>
#include <iostream>
#include <mutex>
#include <memory>
class Task
{
private:
	Task();
public:
	static Task* task;
	static Task* getInstance();
	void fun();
};
//cpp文件
Task* Task::task;
Task::Task()
{
	std::cout << "构造函数" << std::endl;
}
Task* Task::getInstance()
{
	static std::once_flag flag;
	std::call_once(flag, []
	{
		task = new Task();
	});
	return task;
}
void Task::fun()
{
	std::cout << "hello world!"<< std::endl;
}

void wait( std::unique_lock<std::mutex>& lock );                    (1)	(since C++11)
template< class Predicate >
void wait( std::unique_lock<std::mutex>& lock, Predicate pred );    (2)	(since C++11)

#include <iostream>
#include <thread>
#include <string>
#include <mutex>
#include <condition_variable>
#include <deque>
#include <chrono>
std::deque<int> q;
std::mutex mu;
std::condition_variable condi;
void function_1()
{
	int count = 10;
	while (count > 0)
	{
		std::unique_lock<std::mutex> locker(mu);
		q.push_back(count);
		locker.unlock();
		condi.notify_one();			//通知一个等待线程激活   condi.notify_all()激活所有线程
		count--;
		std::this_thread::sleep_for(std::chrono::seconds(1));
	}
}
void function_2()
{
	int data = 100;
	while (data > 1)
	{
		std::unique_lock<std::mutex> locker(mu);
		condi.wait(locker,			//解锁locker,并进入休眠  收到notify时又重新加锁
			[]() { return !q.empty(); });   //如果q不为空 线程才会被激活
		data = q.front();
		q.pop_front();
		locker.unlock();
		std::cout << data << std::endl;
	}
}
int main()
{
	std::thread t1(function_1);
	std::thread t2(function_2);
	t1.join();
	t2.join();
	return 0;
}

#include <iostream>
#include <mutex>  // For std::unique_lock
#include <shared_mutex>
#include <thread>
class ThreadSafeCounter {
 public:
  ThreadSafeCounter() = default;
  // Multiple threads/readers can read the counter's value at the same time.
  unsigned int get() const {
    std::shared_lock lock(mutex_);
    return value_;
  }
  // Only one thread/writer can increment/write the counter's value.
  void increment() {
    std::unique_lock lock(mutex_);
    value_++;
  }
  // Only one thread/writer can reset/write the counter's value.
  void reset() {
    std::unique_lock lock(mutex_);
    value_ = 0;
  }
 private:
  mutable std::shared_mutex mutex_;
  unsigned int value_ = 0;
};
int main() {
  ThreadSafeCounter counter;
  auto increment_and_print = [&counter]() {
    for (int i = 0; i < 3; i++) {
      counter.increment();
      std::cout << std::this_thread::get_id() << ' ' << counter.get() << '\n';
      // Note: Writing to std::cout actually needs to be synchronized as well
      // by another std::mutex. This has been omitted to keep the example small.
    }
  };
  std::thread thread1(increment_and_print);
  std::thread thread2(increment_and_print);
  thread1.join();
  thread2.join();
}

#include<atomic>
#include<thread>
#include<iostream>
using namespace std;
std::atomic_llong total{ 0 };//原子数据类型
void func(int)
{
    for (long long i = 0; i<100000000LL; ++i)
    {
        total += i;
    }
}
int main()
{
    thread t1(func, 0);
    thread t2(func, 0);
    t1.join();
    t2.join();
    cout<<total<<endl;//9999999900000000
    return 0;
}

template <class T> struct atomic
//example
#include<atomic>
void test()
{
    std::atomic_int nThreadData; // std::atomic_int  <----> std::atomic<int>
    nThreadData = 10;
    nThreadData.store(10);
    //TODO: use nThreadData here;
}