safequeue | An smart queue module with timeout support | Runtime Evironment library

None of the above. A nonconcurrent (serial) queue is the best form of locking.

The problem is that safeQueue::size may return outdated result, as another thread may insert or remove an element as soon as safeQueue::size releases the internal lock. For your merge function, this means that by the time you check the while (que.size() >= 2) condition, the size of the queue might have already changed. In particular, merge may return when queue size is more than 1.

You need to lock the internal queue mutex and perform three actions without releasing it:

1. Test the queue size. Return if less than 2.
2. Dequeue the first element.
3. Dequeue the second element.

You may still end up with more than one element in the queue after merge if some other threads are adding new elements to the queue besides merge. If that is the case, you need to be prepared for that or block those other threads until merge completes and you process its result.

You can pass reference to pointer like:

It doesn't mean the program isn't thread safe. It doesn't mean it's ill-defined and can crash.

It just means your program's logic is not written to add the items to the queue in any particular order.

If you want those two items to be added in a specific order, push both from one thread.

Thread safety doesn't mean your application runs as if it only had one thread.

Your program is working fine.

All branches are compiled even if the control is false.

You are getting build breaks because for T=int, delete[] called on an int is not legal C++.

The way to fix your problem is to not store arrays of raw char*, but instead smart pointers like std::unique_ptr or std::unique_ptr in your queue.

You can do this with a type trait:

Remove your unnecessary constructors and destructors and change functions forEven_class and forOdd_class and your code will compile again.
Why removing constructors? Because compiler has rules how to generate default constructors. In your case you wanted move constructor generated, but by defining copy constructor and destructor, you prevented compiler from doing so. Your options are:

• properly define all constructors including move constructor
• remove copy constructor and destructor as I suggested since they doesn't do anything execpt debut output
• instruct compiler to generate default move constructor myclass(myclass &&obj) = default

See this SO on automatic generation of move operations I you want those debug messages, then you have to define those constructors properly. Including task they have to do other than your debug messages.

Regarding changes in functions forEven_class you can´t take the myclass by reference because it is not an lvalue. For more info on this google rvalue reference.