# tbb::deprecated::concurrent_queue<T,Alloc> Template Class

## Summary

Template class for queue with concurrent operations. This is the `concurrent_queue` supported in Intel® Threading Building Blocks (Intel® TBB) 2.1 and prior. New code should use the Intel® TBB 2.2 unbounded `concurrent_queue` or `concurrent_bounded_queue`.

## Syntax

    template<typename T, typename Alloc=cache_aligned_allocator<T> > class concurrent_queue;

## Header

    #include "tbb/concurrent_queue.h"

## Description

A `tbb::deprecated::concurrent_queue` is a bounded first-in first-out data structure that permits multiple threads to concurrently push and pop items. The default bounds are large enough to make the queue practically unbounded, subject to memory limitations on the target machine.

### Tip

Compile with `TBB_DEPRECATED=1` to inject `tbb::deprecated::concurrent_queue` into namespace `tbb`. Consider eventually migrating to the new queue classes.

- Use the new `tbb::concurrent_queue` if you need only the non-blocking operations (`push` and `try_pop`) for modifying the queue.

- Otherwise use the new `tbb::concurrent_bounded_queue`. It supports both blocking operations (`push` and `try_pop`) and non-blocking operations.

In both cases, use the new method names in the following table

Method Name Changes for Concurrent Queues
Method in tbb::deprecated::concurrent_queue | Equivalent method in tbb::concurrent_queue or tbb::concurrent_bounded_queue
--- | ---
`pop_if_present` | `try_pop`
`push_if_not_full` | `try_push` (not available in `tbb::concurrent_queue)`
`begin` | `unsafe_begin`
`end` | `unsafe_end`

## Members

    namespace tbb {
     namespace deprecated {
     template<typename T,
     typename Alloc=cache_aligned_allocator<T> >
     class concurrent_queue {
     public:
     // types
     typedef T value_type;
     typedef T& reference;
     typedef const T& const_reference;
     typedef std::ptrdiff_t size_type;
     typedef std::ptrdiff_t difference_type;
     concurrent_queue(const Alloc& a = Alloc());
     concurrent_queue(const concurrent_queue& src,
     const Alloc& a = Alloc());
     template<typename InputIterator>
     concurrent_queue(InputIterator first, InputIterator last,
     const Alloc& a = Alloc());
     ~concurrent_queue();
     void push(const T& source);
     bool push_if_not_full(const T& source);
     void pop(T& destination);
     bool pop_if_present(T& destination);
     void clear();
     size_type size() const;
     bool empty() const;
     size_t capacity() const;
     void set_capacity(size_type capacity);
     Alloc get_allocator() const;
     typedef implementation-defined iterator;
     typedef implementation-defined const_iterator;
     // iterators (these are slow and intended only for debugging)
     iterator begin();
     iterator end();
     const_iterator begin() const;
     const_iterator end() const;
     };
     }
     #if TBB_DEPRECATED
     using deprecated::concurrent_queue;
     #else
     using strict_ppl::concurrent_queue;
     #endif
     }

Parent topic: Compatibility Features