> These are timings:
> (java openjdk 1.7)
> bmaxa@maxa:~/examples$ time java consprod

> real    0m13.411s
> user    0m19.853s
> sys     0m0.960s

> (c++ gcc 4.6.3)
> bmaxa@maxa:~/examples$ time ./consprod

> real    0m28.726s
> user    0m34.518s
> sys     0m6.800s

> Example programs follow (I think implementations of
> blocking queues are similar):
> // java
> import java.util.concurrent.*;
> import java.util.Random;

> class Vars{
> public final static int nitems = 100000000;
> public final static Random rnd = new Random(12345);
> public final static int size = 10000;

> }

> class Producer implements Runnable {
>    private final BlockingQueue<Integer> queue;
>    Producer(BlockingQueue<Integer> q) { queue = q; }
>    public void run() {
>      try {
>        int i = Vars.nitems;
>        while(i-- > 0) { queue.put(produce(i)); }
>      } catch (InterruptedException ex)
>      {

>      }
>    }
>    Integer produce(int i) { return new Integer(i); }
>  }

>  class Consumer implements Runnable {
>    private final BlockingQueue<Integer> queue;
>    Consumer(BlockingQueue<Integer> q)
>    {
>     queue = q;
>    }
>    public void run() {
>      try {
>        Integer[] arr = new Integer[10000];
>        int i = Vars.nitems;
>        while(i-- > 0) { consume(queue.take(),arr); }
>      } catch (InterruptedException ex)
>      {
>      }
>    }
>    void consume(Integer x, Integer[] arr)
>    {
>     arr[Vars.rnd.nextInt(Vars.size)] = x;
>    }
>  }

>  public class consprod {
>    public static void main(String [] args) {
>    try{
>      BlockingQueue<Integer> q = new ArrayBlockingQueue<Integer>(100000);
>      Producer p = new Producer(q);
>      Consumer c = new Consumer(q);
>      new Thread(p).start();
>      new Thread(c).start();
>      } catch(Exception e)
>      {
>       e.printStackTrace();
>      }
>    }
>  }
> //-----------------------------------------
> // c++
> #include <condition_variable>
> #include <mutex>
> #include <thread>
> #include <deque>
> #include <cstdlib>

> template <class T>
> class BlockingQueue{
> public:
>     BlockingQueue(unsigned cap):capacity_(cap)
>     {
>     }
>     void put(T t)
>     {
>         std::unique_lock<std::mutex> lock(m_);
>         while(queue_.size() >= capacity_)c_full_.wait(lock);
>         queue_.push_back(std::move(t));
>         c_empty_.notify_one();
>     }
>     T take()
>     {
>         std::unique_lock<std::mutex> lock(m_);
>         while(queue_.empty())c_empty_.wait(lock);
>         T tmp = std::move(queue_.front());
>         queue_.pop_front();
>         c_full_.notify_one();
>         return std::move(tmp);
>     }
>     bool empty()
>     {
>         std::unique_lock<std::mutex> lock(m_);
>         return queue_.empty();
>     }
> private:
>     std::mutex m_;
>     std::condition_variable c_empty_,c_full_;
>     std::deque<T> queue_;
>     unsigned capacity_;

> };

> int main()
> {
>     BlockingQueue<std::unique_ptr<int>> produced(100000);
>     const int nitems = 100000000;
>     std::srand(12345);

>     std::function<void()> f_prod = [&]() {
>         int i = nitems;
>         while(i-- > 0){
>             produced.put(std::unique_ptr<int>(new int(i)));
>         }
>     };

>     std::thread producer1(f_prod);

>     std::function<void()> f_cons = [&]() {
>         const int size = 10000;
>         std::unique_ptr<int> arr[size];
>         int i = nitems;
>         while(i-- > 0)
>         {
>             arr[std::rand()%size] = produced.take();
>         }
>     };

>     std::thread consumer1(f_cons);

>     producer1.join();
>     consumer1.join();}

> What g++ optimization options did you use? If you didn't compile with
> proper optimization flags (e.g. at least -O2), then the numbers you
> have are meaningless.

> Also, you might be testing the difference between std::rand() and
> Java's Random.

> Also, why did you use dynamic allocation in the C++ code for an int?

> Also,
> >         std::unique_ptr<int> arr[size];
> ...
> >             arr[std::rand()%size] = produced.take();
> I wonder if it's possible to optimize that into a simple assignment,
> or whether there will be a call to delete() - or at least a branch to
> test if the internal member pointer is null.

> A lock-free "BlockingQueue" would probably be more efficient.
> You can also try to implement your Queue with std::array instead of
> std::deque and see how it performs.

> In the C++ version change:

>    while (queue_.size() >= capacity_)c_full_.wait(lock);
> with
>    c_full_.wait(lock, [this]{return queue_.size() < capacity_;});

> and
>    while (queue_.empty())c_empty_.wait(lock);
> with
>    c_empty_.wait(lock, [this]{return !queue_.empty();});

> Also use a std::lock_guard in empty() instead of std::unique_lock.
> The former is faster.

> (On a side note, the C++ version you have given does not have the
> best possible interface for a thread-safe queue)

> If two C++ programs are otherwise identical, except that one uses
> 'new int' and the other just uses the ints by value, and the former
> is faster than the latter, then there's something horribly wrong in
> the way you are measuring, or something else.

> >        std::unique_lock<std::mutex> lock(m_);

> >            produced.put(std::unique_ptr<int>(new int(i)));

> >            arr[std::rand()%size] = produced.take();

> I don't know what's the cause of the slowness in your program, but
> I quoted above the three possible culprits I would first investigate
> (which happen to be in order of likeliness).

> Locks are slow. They are probably slower than 'new'.

> 'new' is slow, especially when compared to java's.

> std::rand() is slow, although probably does not account for that much
> slowness, but could be a minor contributing factor.

> That's because new is very fast and don;t take much time of program
> in this example.

> In this example new takes very little time.

> That sentence doesn't make any kind of sense.

> > I don't think it's
> >> physically possible for 'new int' to be faster than using ints by
> >> value under any possible circumstance, even if we assumed a highly
> >> optimized version of 'new' that does magic under the hood to be 10
> >> times faster than the regular 'new'.

> > That's because new is very fast and don;t take much time of program
> > in this example.

> 'new' is a very slow operation in C++, and even if it weren't, it just
> can't be faster than using an integer by value. It's physically
> impossible. (The pointer that points to the allocated int is also an
> integral value at the low level, so by allocating something
> dynamically you are only adding to the amount of values being
> handled, and the overall complexity of the program.)

> Can you give any scenario where handling pointers would be faster than
> handling ints?

> >> 'new' is slow, especially when compared to java's.

> > In this example new takes very little time.

> You are executing tens of thousands of 'new's. That is slow.

> My take on this:

> I guess the Java BlockingQueue is a lock-free implementation
> of the blocking circular-buffer concept. Your implementation
> uses a global, single lock around operations, the _m mutex,
> which essentially serializes your code (plus the synchronization
> overhead). Your code might be executed concurrently, but not in
> parallel for sure.

> - look up a lock-free, single producer / single consumer
> circular-buffer implementation

> The most important part: profile your code to find out
> where you spend your time, whether you have some kind of
> contention etc. Performance optimization is a tricky business,
> especially in a multi-threaded environment, naive
> implementations usually produce catastrophic results (see above).

> These are timings:
> (java openjdk 1.7)
> bmaxa@maxa:~/examples$ time java consprod

> real       0m13.411s
> user       0m19.853s
> sys        0m0.960s

> (c++ gcc 4.6.3)
> bmaxa@maxa:~/examples$ time ./consprod

> real       0m28.726s
> user       0m34.518s
> sys        0m6.800s

> Example programs follow (I think implementations of
> blocking queues are similar):
> // java
> import java.util.concurrent.*;
> import java.util.Random;

> class Vars{
> public final static int nitems = 100000000;
> public final static Random rnd = new Random(12345);
> public final static int size = 10000;
> }

> class Producer implements Runnable {
>     private final BlockingQueue<Integer> queue;
>     Producer(BlockingQueue<Integer> q) { queue = q; }
>     public void run() {
>       try {
>         int i = Vars.nitems;
>         while(i-- > 0) { queue.put(produce(i)); }
>       } catch (InterruptedException ex)
>       {

>       }
>     }
>     Integer produce(int i) { return new Integer(i); }
>   }

>   class Consumer implements Runnable {
>     private final BlockingQueue<Integer> queue;
>     Consumer(BlockingQueue<Integer> q)
>     {
>      queue = q;
>     }
>     public void run() {
>       try {
>         Integer[] arr = new Integer[10000];
>         int i = Vars.nitems;
>         while(i-- > 0) { consume(queue.take(),arr); }
>       } catch (InterruptedException ex)
>       {
>       }
>     }
>     void consume(Integer x, Integer[] arr)
>     {
>      arr[Vars.rnd.nextInt(Vars.size)] = x;
>     }
>   }

>   public class consprod {
>     public static void main(String [] args) {
>     try{
>       BlockingQueue<Integer> q = new ArrayBlockingQueue<Integer>(100000);
>       Producer p = new Producer(q);
>       Consumer c = new Consumer(q);
>       new Thread(p).start();
>       new Thread(c).start();
>       } catch(Exception e)
>       {
>        e.printStackTrace();
>       }
>     }
>   }
> //-----------------------------------------
> // c++
> #include <condition_variable>
> #include <mutex>
> #include <thread>
> #include <deque>
> #include <cstdlib>

> template <class T>
> class BlockingQueue{
> public:
>      BlockingQueue(unsigned cap):capacity_(cap)
>      {
>      }
>      void put(T t)
>      {
>          std::unique_lock<std::mutex> lock(m_);
>          while(queue_.size() >= capacity_)c_full_.wait(lock);
>          queue_.push_back(std::move(t));
>          c_empty_.notify_one();
>      }
>      T take()
>      {
>          std::unique_lock<std::mutex> lock(m_);
>          while(queue_.empty())c_empty_.wait(lock);
>          T tmp = std::move(queue_.front());
>          queue_.pop_front();
>          c_full_.notify_one();
>          return std::move(tmp);
>      }
>      bool empty()
>      {
>          std::unique_lock<std::mutex> lock(m_);
>          return queue_.empty();
>      }
> private:
>      std::mutex m_;
>      std::condition_variable c_empty_,c_full_;
>      std::deque<T> queue_;
>      unsigned capacity_;
> };

> int main()
> {
>      BlockingQueue<std::unique_ptr<int>> produced(100000);
>      const int nitems = 100000000;
>      std::srand(12345);

>      std::function<void()> f_prod = [&]() {
>          int i = nitems;
>          while(i-- > 0){
>              produced.put(std::unique_ptr<int>(new int(i)));
>          }
>      };

>      std::thread producer1(f_prod);

>      std::function<void()> f_cons = [&]() {
>          const int size = 10000;
>          std::unique_ptr<int> arr[size];
>          int i = nitems;
>          while(i-- > 0)
>          {
>              arr[std::rand()%size] = produced.take();
>          }
>      };

>      std::thread consumer1(f_cons);

>      producer1.join();
>      consumer1.join();
> }
> // --------------------------------------

> On my system this sped the C++ solution up considerably (to about
> 13.7 seconds).  I didn't time the Java solution.

> I have just copied Java BlockingQueue interface, which is of course
> suited for Java. Don't know actually how ideal interface would look
> like.

> &gt; I made a few changes to your code:
> &gt;
> &gt;
> &gt; On my system this sped the C++ solution up considerably (to about
> &gt; 13.7 seconds).  I didn&#39;t time the Java solution.

> Yes, that&#39;s it, on my system:
> bmaxa@maxa:~/examples$ time ./consprod2

> real       0m9.478s
> user       0m10.797s
> sys        0m7.196s

> which is more than twice speed of original program!
> (and faster than java)

> > &gt; I made a few changes to your code:
> > &gt;
> > &gt;
> > &gt; On my system this sped the C++ solution up considerably (to
> > about &gt; 13.7 seconds).  I didn&#39;t time the Java solution.

> > Yes, that&#39;s it, on my system:
> > bmaxa@maxa:~/examples$ time ./consprod2

> > real  0m9.478s
> > user  0m10.797s
> > sys   0m7.196s

> > which is more than twice speed of original program!
> > (and faster than java)

> At second glance I wasn't that fond of my solution and tweaked it as
> below:

>     void put(T t)
>     {
>         std::unique_lock<std::mutex> lock(m_, std::try_to_lock);
>         while (!lock.owns_lock())
>         {
>             if (queue_.size() > capacity_/4)
>             {
>                 for (int i = 0; i < 3250; ++i)
>                     std::this_thread::yield();
>                 lock.try_lock();
>             }
>             else
>             {
>                 lock.lock();
>                 break;
>             }
>         }
>         while(queue_.size() >= capacity_)c_full_.wait(lock);
>         queue_.push_back(std::move(t));
>         if (queue_.size() == 1)
>             c_empty_.notify_one();
>     }
>     T take()
>     {
>         std::unique_lock<std::mutex> lock(m_, std::try_to_lock);
>         int retry = 0;
>         while (!lock.owns_lock())
>         {
>             if (queue_.size() < 3*capacity_/4)
>             {
>                 for (int i = 0; i < 3250; ++i)
>                     std::this_thread::yield();
>                 lock.try_lock();
>             }
>             else
>             {
>                 lock.lock();
>                 break;
>             }
>         }
>         while(queue_.empty())c_empty_.wait(lock);
>         T tmp = std::move(queue_.front());
>         queue_.pop_front();
>         if (queue_.size() == capacity_-1)
>             c_full_.notify_one();
>         return tmp;
>     }

> I am admittedly coding to the benchmark (which is not a really great
> idea).  But I got the time on my system down from 13.7 seconds to
> about 9.7 seconds (another 40%).

> It's an exception in C and C++ for main only. Running off the end of
> main is allowed, and is equivalent to return 0,

>1.  I only signal if the capacity becomes non-zero or non-full.
>2.  If the queue is the queue has got some items in it and the mutex is locked, the put thread yields to the take
>thread.  If the queue has some free space in it and the mutex is locked, the take thread yields to the put
>thread.

> >1.  I only signal if the capacity becomes non-zero or non-full.

> >2.  If the queue is the queue has got some items in it and the mutex
> >is locked, the put thread yields to the take thread.  If the queue
> >has some free space in it and the mutex is locked, the take thread
> >yields to the put thread.

> Are you sure about the usefulness of #2?  

> Doing a few tests myself, adding this in m queue seems to reduce
> performance by some 20%: while (!lock.owns_lock())
>         {
>             if (queue_.size() > capacity_/4)
>             {
>                 for (int i = 0; i < 3250; ++i)
>                     std::this_thread::yield();
>                 lock.try_lock();
>             }
>             else
>             {
>                 lock.lock();
>                 break;
>             }
>         }

>> I have just copied Java BlockingQueue interface, which is of course
>> suited for Java. Don't know actually how ideal interface would look
>> like.

> In C++11 the ideal interface for a generic thread-safe and
> exception-safe queue should at least provide std::shared_ptr<T> take()
> and/or void take(T&). T take() is limited to those types having no-throw
> copy constructors or move-constructors. This also means that you should
> check the type at compile-time by using type traits. However, in your
> test case you used move-semantic everywhere, so that is not problem.
> Also note that the term "pop" instead of "take" is more in the spirit of
> C++.

> > &gt; I made a few changes to your code:
> > &gt;
> > &gt;
> > &gt; On my system this sped the C++ solution up considerably (to
> > about &gt; 13.7 seconds).  I didn&#39;t time the Java solution.

> > Yes, that&#39;s it, on my system:
> > bmaxa@maxa:~/examples$ time ./consprod2

> > real  0m9.478s
> > user  0m10.797s
> > sys   0m7.196s

> > which is more than twice speed of original program!
> > (and faster than java)

> At second glance I wasn't that fond of my solution and tweaked it as
> below:

>     void put(T t)
>     {
>         std::unique_lock<std::mutex> lock(m_, std::try_to_lock);
>         while (!lock.owns_lock())
>         {
>             if (queue_.size() > capacity_/4)
>             {

> I am admittedly coding to the benchmark (which is not a really great
> idea).  But I got the time on my system down from 13.7 seconds to
> about 9.7 seconds (another 40%).

> Why do you need count_ to be an atomic type, it seems that all the
> updates to that variable are already protected by a mutex..