最近学习C++，在写多线程的时候遇到个关于锁的问题，写出来问题定位过程记录下

先说下想实现的功能：创建个testlist，用多线程对testlist做操作，如下代码中举个例子，printListSize对testlist的长度进行输出（当然你可以理解为还有若干个线程在进行list增删的操作，但多线程操作不是本次讨论重点）。

#include <thread>
#include <mutex>
#include <list>
std::mutex lock;
std::list<int> testlist;
std::mutex getlock()
	return lock;
void printListSize()
    while(true)
	    getlock().lock();
    	std::cout << testlist.size() << std::endl;
	    getlock().unlock();
void start()
	std::thread t(&printListSize);
	t.detach();
这段代码编译的时候会报标题中写的 错误：error C2248: “std::mutex::mutex”: 无法访问 private 成员(在“std::mutex”类中声明)，从代码本身看这么写没有任何问题，那么问题的关键就在于后续两行报错：
 
d:\program files (x86)\microsoft visual studio 11.0\vc\include\mutex(116) : 参见“std::mutex::mutex”的声明
 d:\program files (x86)\microsoft vis
                    最近学习C++，在写多线程的时候遇到个关于锁的问题，写出来问题定位过程记录下先说下想实现的功能：创建个testlist，用多线程对testlist做操作，如下代码中举个例子，printListSize对testlist的长度进行输出（当然你可以理解为还有若干个线程在进行list增删的操作，但多线程操作不是本次讨论重点）。#include &lt;thread&gt;#include &...
三、lock_guard和unique_lock的使用和区别。
3.1、unique_lock和lock_guard的使用。
3.2、unique_lock和lock_guard的区别。
3.3、小结。
四、递归互斥量std::recursive_mutex。
五、带超时的互斥量std::timed_mutex和std::recursive_timed_mutex。
CStatic m_static1;
m_static1.Create(NULL,NULL,_T("文本")，WS_VISIBLE,CRect(0,0,100,100),this,IDC_M_STATIC1);
vector<CStatic> v_static;
v_s..
				
近期编程想用CList维护一个对象，来方便的实现增，删，改，查，里面要放多个元素，想实现这种，就要自己写结构体，或是类。类的话就让他派生自CObject吧，然后接下来会遇到两个问题，我在这里整理一下我在网上寻求的解决方法，文中所写是否是问题的标准解决办法，有待高手指教，我只是发此文章帮助和我一样遇到问题的人，和记录一下自己的学习历程。
    配套博客：http://blog.csdn.net/panshiqu/article/details/9698247
					
#include <vector> #include <queue> #include <thread> #include <mutex> #include <condition_variable> #include <functional> #include <future>   class ThreadPool { public:     ThreadPool(size_t threads) : stop(false) {         for (size_t i = 0; i < threads; ++i) {             workers.emplace_back([this] {                 for (;;) {                     std::function<void()> task;                     {                         std::unique_lock<std::mutex> lock(this->queue_mutex);                         this->condition.wait(lock, [this] { return this->stop || !this->tasks.empty(); });                         if (this->stop && this->tasks.empty()) return;                         task = std::move(this->tasks.front());                         this->tasks.pop();                     }                     task();                 }             });         }     }      ~ThreadPool() {         {             std::unique_lock<std::mutex> lock(queue_mutex);             stop = true;         }         condition.notify_all();         for (std::thread &worker : workers) worker.join();     }      template<class F, class... Args>     auto enqueue(F&& f, Args&&... args) -> std::future<typename std::result_of<F(Args...)>::type> {         using return_type = typename std::result_of<F(Args...)>::type;         auto task = std::make_shared<std::packaged_task<return_type()>>(std::bind(std::forward<F>(f), std::forward<Args>(args)...));         std::future<return_type> res = task->get_future();         {             std_lock<std::mutex> lock(queue_mutex);             if (stop)                 throw std::runtime_error("enqueue on stopped ThreadPool");             tasks.emplace([task] { (*task)(); });         }         condition.notify_one();         return res;     }  private:     std::vector<std::thread> workers;     std::queue<std::function<void()>> tasks;     std::mutex queue_mutex;     std::condition_variable condition;     bool stop; };