Hello All! I`d like to ask for your kind advice regarding boost::mutex behaviour. I dont see what i`m doing wrong here. The issue is that at some point a mutex used to syncronize access to std::queue becomes locked on it's own, despite being explicitly unlocked before. I can repeat this more or less consistently. I triple checked the logic behind code and it seems correct to me. Here is the code and some explanations (i build and test under windows): Class itself: #pragma once #include <queue> // simple std::queue based boost::mutex syncronized queue template <typename T> class SyncedQueue : boost::noncopyable { private: std::queue<T> queue; // this is intended to be locked when queue is empty boost::mutex emptyIndicator; //this is intended to be locked when queue is being modified boost::mutex accessGuard; public: SyncedQueue(const SyncedQueue<T> &) { //no copy constructor since we got mutexes } SyncedQueue() { // Queue is empty at start emptyIndicator.lock(); } bool push ( T object ) { accessGuard.lock(); queue.push(object); // if someone has been waiting for data to become available in queue - let them go on emptyIndicator.unlock(); accessGuard.unlock(); return true; } bool pop ( T& object ) { // See if data is available, wait to aquire lock otherwise emptyIndicator.lock(); // OK, somethings in the queue now, we can go on accessGuard.lock(); object = queue.front(); queue.pop(); // If there is anything left in the queue - release emptyIndicator to notify other poppers that they can go on if (queue.size() > 0) { emptyIndicator.unlock(); } accessGuard.unlock(); return true; } }; Here is the test Code: #include "stdafx.h" #include <string> #include <iostream> #include <boost/thread.hpp> #include <boost/shared_ptr.hpp> #include <include/threadpool.hpp> #include "SyncedQueue.h" // global variable for the queue SyncedQueue< boost::shared_ptr < std::string > > syncedQueue; void testWriteQueue() { for (int i = 0; i < 100; i++) { char szBuff[128]; boost::shared_ptr< std::string > msgPtr; std::string tmpString = "Message"; tmpString += itoa(i,szBuff, 10); msgPtr.reset(new std::string(tmpString)); syncedQueue.push(msgPtr); std::cout << "Sent " << msgPtr->c_str() << std::endl; } // After this thread completes, reader thread sometimes deadlocks! std::cout << "Sent all" << std::endl; } void testReadQueue() { int recievedmessnum = 0; while(recievedmessnum != 100) { boost::shared_ptr< std::string > recievedMsgPtr; // After this writer thread completes, it sometimes sometimes deadlocks trying to aqurie emptyIndicator! syncedQueue.pop(recievedMsgPtr); std::cout << "Recieved " << recievedMsgPtr->c_str() << std::endl; recievedmessnum++; } std::cout << "Recieved all" << std::endl; } int main(int argc, char** argv) { using namespace boost::threadpool; pool tp(2); tp.schedule(&testWriteQueue); tp.schedule(&testReadQueue); tp.wait(); std::cout << "Test complete" << std::endl; } Thanks in advance, Ilya.