1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#incldue <iostream>
#include <thread>
#include <mutex>
using namespace std;
static mutex mux;
void TestThread()
{
	mux.lock();
	cout << "===============================" << endl;
	cout << "test 001" << endl;
	cout << "test 002" << endl;
	cout << "test 003" << endl;
	cout << "===============================\n" << endl;
	mux.unlock();

}
int main(int argc, char* argv[])
{
	for (int i = 0; i < 10; i++)
	{
		thread th(TestThread);
		th.detach();
	}
	getchar();
	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

mutex mux;
void ThreadMainMux(int i)
{
    //不断的循环可能会导致某个线程独占锁
	for (;;)
	{
		mux.lock();
		cout << i << "[in]" << endl;
		this_thread::sleep_for(1000ms);
		mux.unlock();
        //通过让刚获取过锁的线程睡眠一会，防止独占
		this_thread::sleep_for(1ms);
	}
}
int main(int argc,char *argv[])
{
	for (int i = 0; i < 3; i++)
	{
		thread th(ThreadMainMux, i+1);
		th.detach();
	}
//....
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

timed_mutex tmux;
void ThreadMainTime(int i)
{
	for (;;)
	{
		if (!tmux.try_lock_for(milliseconds(1000)))
		{
			cout << i << "[try_lock_for] timeout" << endl;
			continue;
		}
		cout << i << "[in]" << endl;
		this_thread::sleep_for(2000ms);
		tmux.unlock();
		this_thread::sleep_for(1ms);
	}
}
int main(int argc,char *argv[])
{
	for (int i = 0; i < 3; i++)
	{
		thread th(ThreadMainTime, i);
		th.detach();
	}
// ...
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

recursive_mutex rmux;
void Task1()
{
	rmux.lock();
	// 组合业务 用到同一个锁
	cout << "task1 [in]" << endl;
	rmux.unlock();
}

void Task2()
{
	rmux.lock();
	// 组合业务 用到同一个锁
	cout << "task2 [in]" << endl;
	rmux.unlock();
}
void ThreadMainRec(int i)
{
	for (;;)
	{
		rmux.lock();
		// 组合业务 用到同一个锁
		Task1();
		Task2();
		cout << i << "[in]" << endl;
		this_thread::sleep_for(2000ms);
		rmux.unlock();
		this_thread::sleep_for(1ms);
	}
}
int main(int argc,char *argv[])
{
	for (int i = 0; i < 3; i++)
	{
		thread th(ThreadMainRec, i);
		th.detach();
	}
//....
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

//c++17
shared_mutex smux;
//c++ 14
shared_timed_mutex stmux;
void ThreadWrite(int i)
{
	for (;;)
	{
		stmux.lock_shared();
		//读数据
		stmux.unlock_shared();
		stmux.lock();
		cout << i << " Write" << endl;
		this_thread::sleep_for(100ms);
		stmux.unlock();
		this_thread::sleep_for(3000ms);
	}
}
void ThreadRead(int i)
{
	for(;;)
	{
		stmux.lock_shared();
		cout << i << " Read" << endl;
		this_thread::sleep_for(500ms);
		stmux.unlock_shared();
		this_thread::sleep_for(50ms);
	}

}

int main(int argc,char *argv[])
{
	for (int i = 0; i < 3; i++)
	{
		thread th(ThreadWrite, i + 1);
		th.detach();
	}
	this_thread::sleep_for(100ms);
	for (int i = 0; i < 3; i++)
	{
		thread th(ThreadRead, i + 1);
		th.detach();
	}
//...
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

class XMutex
{
	public:
	XMutex(mutex& mux):mux_(mux)
	{
		cout << "Lock" << endl;
		mux_.lock();
	}
	~XMutex()
	{
		cout << "UnLock" << endl;
		mux_.unlock();
	}
private:
	mutex &mux_;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

//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 {
		_MyMutex.unlock();
	}
	lock_guard(const lock_guard&) = delete;
	lock_guard& operator=(const lock_guard&) = delete;
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

#include <thread>
#include <iostream>
#include <string>
#include <mutex>
#include <shared_mutex>
//Linux -lpthread
using namespace std;
static mutex gmutex;
void TestLockGuard(int i)
{
    gmutex.lock();
    {
        //已经拥有锁，不lock
        lock_guard<mutex> lock(gmutex,adopt_lock);
        //结束释放锁
    }
    {
        lock_guard<mutex> lock(gmutex);
        cout << "begin thread " << i << endl;
    }
    for (;;)
    {
        {
            lock_guard<mutex> lock(gmutex);
            cout << "In " << i << endl;
        }
        this_thread::sleep_for(500ms);
    }
}

int main(int argc, char* argv[])
{
    for (int i = 0; i < 3; i++)
    {
        thread th(TestLockGuard, i + 1);
        th.detach();
    }
    getchar();
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

//延后拥有
#include <mutex>
#include <thread>
#include <iostream>

std::mutex mtx;

void func()
{
    std::unique_lock<std::mutex> lck(mtx, std::defer_lock);
    // ... some other operations
    lck.lock(); // 程序执行到此处时才会锁定互斥量
    // ... critical section
}

int main()
{
    std::thread t1(func);
    std::thread t2(func);
    t1.join();
    t2.join();
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

#include <iostream>
#include <thread>
#include <mutex>

int main() {
    std::mutex mtx;

    std::unique_lock<std::mutex> lck(mtx, std::try_to_lock);

    if (lck.owns_lock()) {
        std::cout << "Mutex locked by this thread" << std::endl;
    }
    else {
        std::cout << "Mutex not available" << std::endl;
    }

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#include <iostream>
#include <thread>
#include <shared_mutex>

std::shared_mutex mutex;
int shared_data = 0;

void read_thread() {
    std::shared_lock<std::shared_mutex> lock(mutex);
    std::cout << "Reading shared_data: " << shared_data << std::endl;
}

void write_thread() {
	//组合使用，也可以和lock_guard组合使用
    std::unique_lock<std::shared_mutex> lock(mutex);
    shared_data++;
    std::cout << "Writing shared_data: " << shared_data << std::endl;
}

int main() {
    std::thread t1(read_thread);
    std::thread t2(read_thread);
    std::thread t3(write_thread);

    t1.join();
    t2.join();
    t3.join();
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#include <iostream>
#include <mutex>
#include <thread>

int counter = 0;
std::mutex m1, m2;

void increment_both()
{
    std::scoped_lock lock(m1, m2);
    ++counter;
}

int main()
{
    std::thread t1(increment_both);
    std::thread t2(increment_both);

    t1.join();
    t2.join();

    std::cout << "Counter value: " << counter << std::endl;

    return 0;
}

1

std::condition_variable cv;

1

unique_lock lock(mux);

1

msgs_.push_back(data);

1
2
3

lock.unlock();
cv.notify_one(); //通知一个等待信号线程
cv.notify_all(); //通知所有等待信号线程

1

unique_lock lock(mux);

1
2
3
4
5
6

//解锁lock,并阻塞等待 notify_one notify_all 通知
cv.wait(lock);
//接收到通知会再次获取锁标注，也就是说如果此时mux资源被占用，wait函数会阻塞
msgs_.front();
//处理数据
msgs_.pop_front();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

void wait(unique_lock<mutex>& _Lck) { 
// wait for signal
// Nothing to do to comply with LWG‐2135 because std::mutex lock/unlock are nothrow
	_Check_C_return(_Cnd_wait(_Mycnd(), _Lck.mutex()->_Mymtx()));
}
	template <class _Predicate>
	void wait(unique_lock<mutex>& _Lck, _Predicate _Pred) { 
	 // wait for signal and test predicate
	while (!_Pred())
	{ 
		 wait(_Lck);
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

void TestFuture(promise<string> p)
{
	//假装有业务1
	//一设置，主线成中get就结束阻塞
	ps.set_value("TestFuture value"); 
	//继续线程业务
	//假装有业务2
}
int main()
{
	//这段代码创建了一个 promise 对象 p，并通过 get_future() 成员函数获取了一个与该 promise 对象相关联的 future 对象。通过这个 future 对象，我们可以在异步任务完成后获取其返回值。在这个例子中，promise 对象和 future 对象之间建立了一条双向通道，通过该通道，异步任务产生的结果可以传递给等待其完成的线程。
	//使用 `move(p)` 的原因是要将 `p` 对象转移到新线程中。由于 `promise` 对象不可复制，因此将其作为参数传递给新线程需要使用 `move` 将其所有权转移到新线程中，否则编译器会报错。如果直接传递 `p`，编译器会尝试进行拷贝，但由于 `promise` 对象不可复制，编译器会报错。另外，`move(p)` 的语义是将 `p` 对象的状态转移到新的对象中，并使 `p` 对象的状态处于一个无效但可销毁的状态。因此，在将 `p` 对象转移给另一个对象之后，就不能再次使用 `p` 对象了，因为其状态已经无效。
	promise<string> p;
	auto fu = p.get_future(); //std::future<string>

	auto re = std::thread(TestFuture,move(p));
	//get方法只要线程一设置了value就立刻停止阻塞，而不需要等待线程结束
	cout << "fu = " << fu.get() << endl;;
	cout << "end std::async" << endl;
	re.join();
	return 0;
}
//始终都是一个线程在活动

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

string TestPack(int index)
{
    cout << "begin Test Pack " << index << endl;
    this_thread::sleep_for(2s);
    return "Test Pack return";
}

int main(int argc, char* argv[])
{
    packaged_task< string(int) > task(TestPack);
    auto result = task.get_future();
    //task(100);
	//⭐我在这里调用
	//使用`move`将`task`转移给新线程中的`packaged_task`对象，以确保在将任务与新线程关联之后，不会再有其他线程对该任务进行修改。如果不使用`move`，则可能会导致多个线程同时访问同一个`packaged_task`对象，从而导致不可预知的行为。
    thread th(move(task),101);
    cout << "begin result get" << endl;
    //测试是否超时
	//⭐我在这里取返回值
    for (int i = 0; i < 30; i++)
    {
        if (result.wait_for(100ms) != future_status::ready)
        {
            continue;
        }
    }
    if (result.wait_for(100ms) == future_status::timeout)
    {
        cout << "wait result timeout" << endl;
    }
    else
        cout << "result get " << result.get() << endl;
    th.join();
    getchar();
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

string TestAsync(int index)
{
    cout << index<<" begin in TestAsync " << this_thread::get_id() << endl;
    this_thread::sleep_for(2s);
    return "TestAsync string return";
}
int main(int argc, char* argv[])
{
   //创建异步线程
    cout << "main thread id " << this_thread::get_id() << endl;
    //不创建线程启动异步任务
	//result.get来请求结果，那么这个异步任务就运行在执行这条 get 语句所在的线程上.，而不创建新线程
    auto future = async(launch::deferred, TestAsync,100);
    this_thread::sleep_for(100ms);
    cout << "begin future get " << endl;
    cout << "future.get() = " << future.get() << endl;
    cout << "end future get" << endl;
    //创建异步线程
    cout << "=====创建异步线程====" << endl;
    auto future2 = async(TestAsync, 101);
    this_thread::sleep_for(100ms);
    cout << "begin future2 get " << endl;
    cout << "future2.get() = " << future2.get() << endl;
    cout << "end future2 get" << endl;

    getchar();
    return 0;
}