C++11线程、互斥量以及条件变量示例详解

//创建线程需要引入头文件thread
#include<thread>  
#include<iostream>

void ThreadMain()
{
	cout << "begin thread main" << endl;
}

int main()
{
	//创建新线程t并启动
	thread t(ThreadMain);
	//主线程(main线程)等待t执行完毕
	if (t.joinable()) //必不可少
	{
		//等待子线程退出
		t.join();	//必不可少
	}
	return 0;
}

void ThreadMain()
{
	cout << "线程" << this_thread::get_id()<< ":begin thread main" << endl;
}

int main()
{
	//创建新线程t并启动
	thread t(ThreadMain);
	//主线程(main线程)等待t执行完毕
	if (t.joinable()) //必不可少
	{
		//等待子线程退出
		cout << "线程" << this_thread::get_id() << ":正在等待" << endl;
		t.join();	//必不可少
	}
	return 0;
}

void func()
{
	cout << "do func" << endl;
}

int main()
{
	thread t(func);
	return 0;
}

void func()
{
	while (true)
	{
		cout << "do work" << endl;
		this_thread::sleep_for(std::chrono::seconds(1));//当前线程睡眠1秒
	}
}

int main()
{
	thread t(func);
	if (t.joinable())
	{
		t.join();//main线程阻塞
	}
	return 0;
}

void func()
{
	int count = 0;
	while (count < 3)
	{
		cout << "do work" << endl;
		count++;
		this_thread::sleep_for(std::chrono::seconds(1));//当前线程睡眠1秒
	}
}

int main()
{
	thread t(func);
	t.detach();
	this_thread::sleep_for(std::chrono::seconds(1));//当前线程睡眠1秒
	cout << "线程t分离成功" << endl;
	return 0;
}

void func()
{
	cout << "hello world" << endl;
}

int main()
{
	thread t(func);
	if (t.joinable())
	{
		t.join();
	}
	return 0;
}

class ThreadMain
{
public:
	ThreadMain() {}
	virtual ~ThreadMain(){}
	void SayHello(std::string name)
	{
		cout << "hello " << name << endl;
	}
};

int main()
{
	ThreadMain obj;
	thread t(&ThreadMain::SayHello, obj, "fl");
	thread t1(&ThreadMain::SayHello, &obj, "fl");
	t.join();
	t1.join();
	return 0;
}

class ThreadMain
{
public:
	ThreadMain() {}
	virtual ~ThreadMain(){}
	void SayHello(std::string name)
	{
		cout << "hello " << name << endl;
	}
	void asycSayHello(std::string name)
	{
		thread t(&ThreadMain::SayHello, this, name);
		if (t.joinable())
		{
			t.join();
		}
	}
};

int main()
{
	ThreadMain obj;
	obj.asycSayHello("fl");
	return 0;
}

int main()
{
	thread t([](int i){
		cout << "test lambda i = " << i << endl;
	}, 123);
	if (t.joinable())
	{
		t.join();
	}
	return 0;
}

class TestLmadba
{
public:
	void Start()
	{
		thread t([this](){
			cout << "name is " << this->name << endl;
		});
		if (t.joinable())
		{
			t.join();
		}
	}

private:
	std::string name = "fl";
};

int main()
{
	TestLmadba test;
	test.Start();
	return 0;
}

class Mybusiness
{
public:
	Mybusiness(){}
	virtual ~Mybusiness(){}

	void operator()(void)
	{
		cout << "Mybusiness thread id is " << this_thread::get_id() << endl;
	}

	void operator()(string name)
	{
		cout << "name is " << name << endl;
	}
};

int main()
{
	Mybusiness mb;
	thread t(mb);
	if (t.joinable())
	{
		t.join();
	}
	thread t1(mb, "fl");
	if (t1.joinable())
	{
		t1.join();
	}
	return 0;
}

void func()
{
	cout << "thread id is " << this_thread::get_id() << endl;
}

void add(int a, int b)
{
	cout << a << "+" << b << "=" << a + b << endl;
}

int main()
{	
	//采用C++11扩展的using来定义函数指针类型
	using FuncPtr = void(*)();
	using FuncPtr1 = void(*)(int, int);
	//使用FuncPtr来定义函数指针变量
	FuncPtr ptr = &func;
	thread t(ptr);
	if (t.joinable())
	{
		t.join();
	}

	FuncPtr1 ptr1 = add;
	thread t1(ptr1, 1, 10);
	if (t1.joinable())
	{
		t1.join();
	}
	return 0;
}

void func(string name)
{
	cout << this_thread::get_id() << ":name is " << name << endl;
}

int main()
{
	function<void(string)> f(func);
	thread t(f, "fl");
	if (t.joinable())
	{
		t.join();
	}
	thread t1(bind(func, "fl"));
	if (t1.joinable())
	{
		t1.join();
	}
	return 0;
}

//赋值操作
void func(string name)
{
	cout << this_thread::get_id() << ":name is " << name << endl;
}

int main()
{
	thread t1(func, "fl");
	thread t2 = t1;
	thread t3(t1);
	return 0;
}

//移动操作
void func(string name)
{
	cout << this_thread::get_id() << ":name is " << name << endl;
}

int main()
{
	thread t1(func, "fl");
	thread t2(std::move(t1));
	if (t1.joinable())
	{
		t1.join();
	}
	if (t2.joinable())
	{
		t2.join();
	}
	return 0;
}

int num = 0;
std::mutex mtx;
void func()
{
	for (int i = 0; i < 100; ++i)
	{
		mtx.lock();
		num++;
		mtx.unlock();
	}
}

int main()
{
	thread t1(func);
	thread t2(func);
	if (t1.joinable())
	{
		t1.join();
	}
	if (t2.joinable())
	{
		t2.join();
	}
	cout << num << endl;
	return 0;
}

void func()
{
	for (int i = 0; i < 100; ++i)
	{
		lock_guard<mutex> lock(mtx);
		num++;
	}
}

class Complex
{
public:
	std::mutex mtx;
	void SayHello()
	{
		lock_guard<mutex> lock(mtx);
		cout << "Say Hello" << endl;
		SayHi();
	}

	void SayHi()
	{
		lock_guard<mutex> lock(mtx);
		cout << "say Hi" << endl;
	}
};

int main()
{
	Complex complex;
	complex.SayHello();
	return 0;
}

class Complex
{
public:
	std::recursive_mutex mtx;//同一线程可以多次获取同一互斥量，不会发生死锁
	void SayHello()
	{
		lock_guard<recursive_mutex> lock(mtx);
		cout << "Say Hello" << endl;
		SayHi();
	}

	void SayHi()
	{
		lock_guard<recursive_mutex> lock(mtx);
		cout << "say Hi" << endl;
	}
};

std::timed_mutex mtx;

void work()
{
	chrono::milliseconds timeout(100);
	while (true)
	{
		if (mtx.try_lock_for(timeout))
		{
			cout << this_thread::get_id() << ": do work with the mutex" << endl;
			this_thread::sleep_for(chrono::milliseconds(250));
			mtx.unlock();
		}
		else
		{
			cout << this_thread::get_id() << ": do work without the mutex" << endl;
			this_thread::sleep_for(chrono::milliseconds(100));
		}
	}
}

int main()
{
	thread t1(work);
	thread t2(work);
	if (t1.joinable())
	{
		t1.join();
	}
	if (t2.joinable())
	{
		t2.join();
	}
	return 0;
}

mutex mtx;
void func()
{
	//mtx.lock();//需要加锁，否则在lock的生命周期结束后，会自动解锁，则会导致程序崩溃
	unique_lock<mutex> lock(mtx, std::adopt_lock);
	cout << this_thread::get_id() << " do work" << endl;
}

int main()
{
	thread t(func);
	if (t.joinable())
	{
		t.join();
	}
	return 0;
}

mutex mtx;
void func()
{
	while (true)
	{
		unique_lock<mutex> lock(mtx, std::defer_lock);
		cout << "func thread id is " << this_thread::get_id() << endl;
		this_thread::sleep_for(chrono::milliseconds(500));
	}
}

int main()
{
	thread t1(func);
	thread t2(func);
	if (t1.joinable())
	{
		t1.join();
	}
	if (t2.joinable())
	{
		t2.join();
	}
	return 0;
}

void func()
{
	while (true)
	{
		unique_lock<mutex> lock(mtx, std::defer_lock);
		lock.lock();
		cout << "func thread id is " << this_thread::get_id() << endl;
		this_thread::sleep_for(chrono::milliseconds(500));
		//lock.unlock();  //可以加，也可以不加
		//因为内部有一个标准为，如果我们自己手动解锁了，由于标志位的改变，在调用lock的析构函数时，就不会进行解锁操作
	}
}

std::once_flag flag;

void do_once()
{
	std::call_once(flag, [](){
		cout << "call once" << endl;
	});
}

int main()
{
	const int ThreadSize = 5;
	vector<thread> threads;
	for (int i = 0; i < ThreadSize; ++i)
	{
		threads.emplace_back(do_once);
	}
	for (auto& t : threads)
	{
		if (t.joinable())
		{
			t.join();
		}
	}
	return 0;
}

mutex mtx;
condition_variable_any notEmpty;//没满的条件变量
condition_variable_any notFull;//不为空的条件变量
list<string> list_; //缓冲区
const int custom_threads_size = 3;//消费者的数量
const int produce_threads_size = 4;//生产者的数量
const int max_size = 10;

void produce(int i)
{
	while (true)
	{
		lock_guard<mutex> lock(mtx);
		notEmpty.wait(mtx, []{
			return list_.size() != max_size;
		});
		stringstream ss;
		ss << "生产者" << i << "生产的东西";
		list_.push_back(ss.str());
		notFull.notify_one();
	}
}

void custome(int i)
{
	while (true)
	{
		lock_guard<mutex> lock(mtx);
		notFull.wait(mtx, []{
			return !list_.empty();
		});
		cout << "消费者" << i << "消费了 " << list_.front() << endl;
		list_.pop_front();
		notEmpty.notify_one();
	}
}

int main()
{
	vector<std::thread> producer;
	vector<std::thread> customer;
	for (int i = 0; i < produce_threads_size; ++i)
	{
		producer.emplace_back(produce, i);
	}
	for (int i = 0; i < custom_threads_size; ++i)
	{
		customer.emplace_back(custome, i);
	}

	for (int i = 0; i < produce_threads_size; ++i)
	{
		producer[i].join();
	}
	for (int i = 0; i < custom_threads_size; ++i)
	{
		customer[i].join();
	}
	return 0;
}