Thread safe deque implementation

[Tehniyat]

Im a newbie to c++.
I need to implement deque with two threads. One thread will push back the data for every 1 sec and other thread will pop out the data from deque for every 0.5 secs.these two threads run in infinite loop
Can anyone help me to solve this

[wolle]

One thread will push back the data for every 1 sec and other thread will pop out the data from deque for every 0.5 secs.

In a producer-consumer situation like this it's common to use a concurrent queue. Items are pushed into the queue (enqueued) at the back and they are popped (dequeued) at the front. This makes a queue a first-in-first-out (FIFO) data structure. The items leave the queue in the same order as they entered it. Somewhat confusingly, there's also a data structure called a deque. It's a double-ended queue meaning it allows for pushing and popping at both ends. From your problem description I take it that it is a queue you require.

C++ itself doesn't offer a concurrent queue at the moment but there are external libraries available that do, for example from Microsoft,

https://docs.microsoft.com/en-us/cpp...s?view=vs-2017

and from Intel,

https://software.intel.com/en-us/node/506200

I've tried both and they work fine of course but when C++ 11 arrived I went for a pure C++ implementation I found in a book. Here's my version of it,

#ifndef LOCK_QUEUE_ONCE
#define LOCK_QUEUE_ONCE

//
// Threadsafe queue
//
// (see C++ Concurrency in action by Anthony Williams page 154)
//

#include <queue>
#include <memory>
#include <condition_variable>
#include <mutex>

namespace maux {

	template<typename T>
	class Lockqueue {
		using Mutex = std::mutex;

	public:
		void push(T value) { // push
			std::lock_guard<Mutex> lock(mutex);
			queue.push(std::move(value));
			condition.notify_one();
		}

		bool try_pop(T& value) { // non-blocking pop
			std::lock_guard<Mutex> lock(mutex);
			if (queue.empty()) return false;
			value = std::move(queue.front());
			queue.pop();
			return true;
		}

		T wait_pop() { // blocking pop
			std::unique_lock<Mutex> lock(mutex);
			condition.wait(lock, [this]{return !queue.empty(); });
			T const value = std::move(queue.front());
			queue.pop();
			return value;
		}

		int size() const { // queue size
			std::lock_guard<Mutex> lock(mutex);
			return static_cast<int>(queue.size());
		}

	private:
		mutable Mutex mutex;
		std::queue<T> queue;
		std::condition_variable condition;
	};

}

#endif

It simply adds synchronization to the standard STL data structure std::queue.

To use maux::Lockqueue I suggest you allocate one object on the heap using new. The returned pointer is then passed to the two threads when they are started. The threads can use this pointer to access the same maux::Lockqueue object and thereby pass items from one to the other in a threadsafe manner.