#include "boost\thread.hpp"int main()
{boost::mutex mu;try{mu.lock();cout << "Need to be protected" << endl; //io流是个共享资源，多线程内使用的话需要同步
        mu.unlock();}catch (...){mu.unlock();}return 0;
}

#include "boost\thread.hpp"int main()
{boost::mutex mu;boost::mutex::scoped_lock lock(mu);cout << "Need to be protected" << endl; //io流是个共享资源，多线程内使用的话需要同步return 0;
}

#include "boost\thread.hpp"template<typename T>
class atom_increase
{
public:atom_increase(T x = 0): n(x){} //转换构造函数，实现T类型到atom_increase类型的隐式转换
T operator++() //重载前++运算符
    {boost::mutex::scoped_lock lock(mu);return ++n;}operator T() { return n; } //类型转换函数，实现atom_increase类型到T类型的隐式转换private:T n;boost::mutex mu;
};int main()
{    atom_increase<int> n = 0; //隐式转换：int -> atom_increase++n; //原子前++int i = 5 + n; //隐式转换：atom_increase ->intreturn 0;
}

    boost::shared_mutex rw_mu;//read thread
    {boost::shared_lock<boost::shared_mutex> sl(rw_mu); //读锁定//......
    }//write thread
    {boost::unique_lock<boost::shared_mutex> ul(rw_mu); //写锁定//......}

#include "boost\thread.hpp"boost::condition_variable_any g_cd;
boost::mutex g_mu;
bool g_bConditionFlag = false;void Thread1Proc()
{boost::mutex::scoped_lock lock(g_mu);while (!g_bConditionFlag){boost::this_thread::sleep(boost::posix_time::seconds(1));g_cd.wait(g_mu);}printf("thread1 exit\n");
}int main()
{boost::thread t(Thread1Proc);t.detach();boost::this_thread::sleep(boost::posix_time::milliseconds(100));g_mu.lock();g_bConditionFlag = true;g_cd.notify_one();g_mu.unlock();printf("here\n");getchar();return 0;
}

#include <iostream>       // std::cout
#include <thread>         // std::thread
#include <mutex>          // std::mutex, std::lock

std::mutex foo, bar;void task_a()
{// foo.lock(); // bar.lock();std::lock(foo, bar);std::cout << "task a\n";foo.unlock();bar.unlock();
}void task_b()
{// bar.lock(); // foo.lock();std::lock(bar, foo);std::cout << "task b\n";bar.unlock();foo.unlock();
}int main()
{std::thread th1(task_a);std::thread th2(task_b);// th1.detach();// th2.detach();
    th1.join();th2.join();return 0;
}

class CTask
{
public:void operator()(){int a = 0;}
};//std::thread th1(CTask()); //直接传入临时对象会出错
CTask task;
std::thread th1(task);
th1.join();

    void task(int& a, string str){}int iNum = 0;char* pStr = new char[100];strcpy(pStr, "test");//std::thread th(task, 5, std::ref(iNum), pStr); //不应该直接传入pStrstd::thread th(task, std::ref(iNum), string(pStr)); //应该传入对应类型delete[] pStr;th.join();

std::mutex g_mu;void fun1()
{{std::lock_guard<std::mutex> guard(g_mu);//do something 1
    }//do something 2
    {std::lock_guard<std::mutex> guard(g_mu);// do something 3
    }
}void fun2()
{std::unique_lock<std::mutex> guard(g_mu);//do something 1
    guard.unlock();//do something 2
guard.lock();// do something 3
}