C++11 多线程

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

//线程测试一
void Test1(void);

//线程测试二
void Test2(void);

//线程测试三
void Test3(void);

//线程测试四
void Test4(void);

int main()
{
//Test1();
//Test2();
//Test3();
Test4();
return 0;
}

void hello()
{
std::cout << "Hello from thread " << std::endl;
return;
}

//线程测试一
void Test1(void)
{
//通过thread 类直接申明一个线程t1,参数是这个线程执行的回调函数的地址，通过jion()方法阻塞主线程，直到t1线程执行结束为止。
std::thread t1(hello);
t1.join();
std::cout << "Main Thread" << std::endl;
return;
/*
Hello from thread
Main Thread
请按任意键继续. . .
*/
}

//线程测试二
void Test2(void)
{

std::vector<std::thread> threads;
for (int i = 0; i < 5; ++i)
{
threads.push_back(std::thread([](){std::cout << "Hello from lamda thread " << std::this_thread::get_id() << std::endl; }));
}

for (auto& thread : threads)
{
thread.join();
}
std::cout << "Main Thread" << "\t" << std::this_thread::get_id() << std::endl;
return;

/*
Hello from lamda thread 1208
Hello from lamda thread 3032
Hello from lamda thread 1184
Hello from lamda thread 4872
Hello from lamda thread 4648
Main Thread     2072
请按任意键继续. . .
*/
}

//线程测试三
void Test3(void)
{
std::mutex m;
std::thread t1([&m]()
{

std::this_thread::sleep_for(std::chrono::seconds(10));
for (int i = 0; i < 10; i++)
{
m.lock();
std::cout << "In t1 ThreadID : " << std::this_thread::get_id() << ":" << i << std::endl;
m.unlock();
}

}
);

std::thread t2([&m]()
{

std::this_thread::sleep_for(std::chrono::seconds(1));

for (int i = 0; i < 10; i++)
{
m.lock();
std::cout << "In t2 ThreadID : " << std::this_thread::get_id() << ":" << i << std::endl;
m.unlock();
}

}
);

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

std::cout << "Main Thread" << std::endl;
return;
/*
In t2 ThreadID : 1864:0
In t2 ThreadID : 1864:1
In t2 ThreadID : 1864:2
In t2 ThreadID : 1864:3
In t2 ThreadID : 1864:4
In t2 ThreadID : 1864:5
In t2 ThreadID : 1864:6
In t2 ThreadID : 1864:7
In t2 ThreadID : 1864:8
In t2 ThreadID : 1864:9
In t1 ThreadID : 1848:0
In t1 ThreadID : 1848:1
In t1 ThreadID : 1848:2
In t1 ThreadID : 1848:3
In t1 ThreadID : 1848:4
In t1 ThreadID : 1848:5
In t1 ThreadID : 1848:6
In t1 ThreadID : 1848:7
In t1 ThreadID : 1848:8
In t1 ThreadID : 1848:9
Main Thread
请按任意键继续. . .
*/
}

struct Counter
{
std::mutex mutex;
int value;
Counter() : value(0) {}
void increment()
{
// mutex.lock();                【1】表示没有使用锁
++value;
// mutex.unlock();              【1】
}

void decrement()
{
mutex.lock();
--value;
mutex.unlock();
}
};
//线程测试四
void Test4(void)
{

Counter counter;
std::vector<std::thread> threads;

for (int i = 0; i < 5; ++i)
{

threads.push_back(std::thread([&]()
{
for (int i = 0; i < 10000; ++i)
{
//counter.increment();
counter.decrement();
}
}));
}

for (auto& thread : threads)
{
thread.join();
}

std::cout << counter.value << std::endl;
return;
/*
由于创建线程是使用lambda表达式，并使用引用的方式访问counter这个变量，
当没有使用lock来保护的时候（情况【1】），
执行的结果可能不像预期的5000（程序的意思是每个线程使counter中的value自加1000次，5个线程运行结束的时候应该是5000），
当没有使用锁的时候自加的操作可能被其他线程打断，因此结果可能会小于5000。
*/
}