deque源码有这么复杂吗

最新推荐文章于 2022-03-15 22:35:22 发布

lusic01

最新推荐文章于 2022-03-15 22:35:22 发布

阅读量208

点赞数

C++编程 –安全并发访问容器元素

2014年09月24日 18:06:12 flyfish1986 阅读数：7472

C++ 安全并发访问容器元素

2014-9-24 flyfish
标准库STL的vector, deque, list等等不是线程安全的
例如线程1正在使用迭代器（iterator）读vector
线程2正在对该vector进行插入操作，使vector重新分配内存，这样就造成线程1中的迭代器失效

STL的容器
多个线程读是安全的，在读的过程中，不能对容器有任何写入操作
多个线程可以同时对不同的容器做写入操作。
不能指望任何STL实现来解决线程难题，必须手动做同步控制.

方案1 对vector进行加锁处理

effective STL给出的Lock框架

template<typename Container> //一个为容器获取和释放互斥体的模板
class Lock
{ //框架；其中的很多细节被省略了
public:
Lock(const Container& container) :c(container)
{
getMutexFor(c);
//在构造函数中获取互斥体
}
~Lock()
{
releaseMutexFor(c);
//在析构函数中释放它
}
private: const Container& c;
};

如果需要实现工业强度，需要做更多的工作。

方案2 微软的Parallel Patterns Library (PPL)

看MSDN
PPL 提供的功能

1 Task Parallelism: a mechanism to execute several work items (tasks) in parallel
任务并行：一种并行执行若干工作项（任务）的机制

2 Parallel algorithms: generic algorithms that act on collections of data in parallel
并行算法：并行作用于数据集合的泛型算法

3 Parallel containers and objects: generic container types that provide safe concurrent access to their elements
并行容器和对象：提供对其元素的安全并发访问的泛型容器类型

示例是对斐波那契数列（Fibonacci）的顺序计算和并行计算的比较

顺序计算是
使用 STL std::for_each 算法
结果存储在 std::vector 对象中。

并行计算是
使用 PPL Concurrency::parallel_for_each 算法
结果存储在 Concurrency::concurrent_vector 对象中。

// parallel-fibonacci.cpp
// compile with: /EHsc
#include <windows.h>
#include <ppl.h>
#include <concurrent_vector.h>
#include <array>
#include <vector>
#include <tuple>
#include <algorithm>
#include <iostream>
using namespace Concurrency;
using namespace std;
// Calls the provided work function and returns the number of milliseconds
// that it takes to call that function.
template <class Function>
__int64 time_call(Function&& f)
{
__int64 begin = GetTickCount();
f();
return GetTickCount() - begin;
}
// Computes the nth Fibonacci number.
int fibonacci(int n)
{
if(n < 2)
return n;
return fibonacci(n-1) + fibonacci(n-2);
}
int wmain()
{
__int64 elapsed;
// An array of Fibonacci numbers to compute.
array<int, 4> a = { 24, 26, 41, 42 };
// The results of the serial computation.
vector<tuple<int,int>> results1;
// The results of the parallel computation.
concurrent_vector<tuple<int,int>> results2;
// Use the for_each algorithm to compute the results serially.
elapsed = time_call([&]
{
for_each (a.begin(), a.end(), [&](int n) {
results1.push_back(make_tuple(n, fibonacci(n)));
});
});
wcout << L"serial time: " << elapsed << L" ms" << endl;
// Use the parallel_for_each algorithm to perform the same task.
elapsed = time_call([&]
{
parallel_for_each (a.begin(), a.end(), [&](int n) {
results2.push_back(make_tuple(n, fibonacci(n)));
});
// Because parallel_for_each acts concurrently, the results do not
// have a pre-determined order. Sort the concurrent_vector object
// so that the results match the serial version.
sort(results2.begin(), results2.end());
});
wcout << L"parallel time: " << elapsed << L" ms" << endl << endl;
// Print the results.
for_each (results2.begin(), results2.end(), [](tuple<int,int>& pair) {
wcout << L"fib(" << get<0>(pair) << L"): " << get<1>(pair) << endl;
});
}

命名空间Concurrency首字母大写，一般命名空间全是小写。

贴一个简单的示例代码
使用parallel_for_each 算法计算std::array 对象中每个元素的平方
参数分别是lambda 函数、函数对象和函数指针。

#include "stdafx.h"
#include <ppl.h>
#include <array>
#include <iostream>
using namespace Concurrency;
using namespace std;
using namespace std::tr1;
// Function object (functor) class that computes the square of its input.
template<class Ty>
class SquareFunctor
{
public:
void operator()(Ty& n) const
{
n *= n;
}
};
// Function that computes the square of its input.
template<class Ty>
void square_function(Ty& n)
{
n *= n;
}
int _tmain(int argc, _TCHAR* argv[])
{
// Create an array object that contains 5 values.
array<int, 5> values = { 1, 2, 3, 4, 5 };
// Use a lambda function, a function object, and a function pointer to
// compute the square of each element of the array in parallel.
// Use a lambda function to square each element.
parallel_for_each(values.begin(), values.end(), [](int& n){n *= n;});
// Use a function object (functor) to square each element.
parallel_for_each(values.begin(), values.end(), SquareFunctor<int>());
// Use a function pointer to square each element.
parallel_for_each(values.begin(), values.end(), &square_function<int>);
// Print each element of the array to the console.
for_each(values.begin(), values.end(), [](int& n) {
wcout << n << endl;
});
return 0;
}

在微软的concurrent_vector.h文件中有这样一句
Microsoft would like to acknowledge that this concurrency data structure implementation
is based on Intel implementation in its Threading Building Blocks ("Intel Material").
也就是微软的concurrent_vector是在Intel 的Threading Building Blocks基础上实现的。

方案3 Intel TBB(Threading Building Blocks)
Intel TBB 提供的功能
1 直接使用的线程安全容器，比如 concurrent_vector 和 concurrent_queue。
2 通用的并行算法，如 parallel_for 和 parallel_reduce。
3 模板类 atomic 中提供了无锁（Lock-free或者mutex-free）并发编程支持。

方案4 无锁数据结构支持库Concurrent Data Structures (libcds).
地址 http://sourceforge.net/projects/libcds/
下载以后里面直接有从VC2008到VC2013的编译环境，依赖于boost库

方案5 Boost 使用boost.lockfree

boost.lockfree实现了三种无锁数据结构：

1 boost::lockfree::queue
2 boost::lockfree::stack
3 boost::lockfree::spsc_queue

生产者-消费者
下面的代码实现的是
实现了一个多写生成，多消费队列。
产生整数，并被4个线程消费

#include <boost/thread/thread.hpp>
#include <boost/lockfree/queue.hpp>
#include <iostream>
#include <boost/atomic.hpp>
boost::atomic_int producer_count(0);
boost::atomic_int consumer_count(0);
boost::lockfree::queue<int> queue(128);
const int iterations = 10000000;
const int producer_thread_count = 4;
const int consumer_thread_count = 4;
void producer(void)
{
for (int i = 0; i != iterations; ++i) {
int value = ++producer_count;
while (!queue.push(value))
;
}
}
boost::atomic<bool> done (false);
void consumer(void)
{
int value;
while (!done) {
while (queue.pop(value))
++consumer_count;
}
while (queue.pop(value))
++consumer_count;
}
int main(int argc, char* argv[])
{
using namespace std;
cout << "boost::lockfree::queue is ";
if (!queue.is_lock_free())
cout << "not ";
cout << "lockfree" << endl;
boost::thread_group producer_threads, consumer_threads;
for (int i = 0; i != producer_thread_count; ++i)
producer_threads.create_thread(producer);
for (int i = 0; i != consumer_thread_count; ++i)
consumer_threads.create_thread(consumer);
producer_threads.join_all();
done = true;
consumer_threads.join_all();
cout << "produced " << producer_count << " objects." << endl;
cout << "consumed " << consumer_count << " objects." << endl;
}

====================================================================================================================================================================================================================================================================================================================================

STL之deque源码剖析

2017年06月17日 16:53:22 hj605635529 阅读数：275

在介绍STL的deque的容器之前，我们先来总结一下vector和list的优缺点。vector在内存中是分配一段连续的内存空间进行存储，其迭代器采用原生指针即可，因此其支持随机访问和存储，支持下标操作符，节省空间。但是其在分配的内存不够的情况下，需要对容器整体进行重新分配、拷贝和释放等操作，而且在vector中间插入或删除元素效率很低。

而list是以节点形式来存放数据，使用的是非连续的内存空间来存放数据，因此，在其内部插入和删除元素的时间复杂度都是O(1),但是其不支持随机访问和存取，不支持下标，而且比vector占用的内存要多。

综合上述的优缺点，我们貌似需要一个支持随机访问和存取，支持下标访问，而且插入和删除的效率高的容器。于是，STL的deque诞生了，下面就跟着我一起去看看deque的设计和源码实现吧！

Deque概述

vector是一个单向开口的容器，deque则是一个双向开口的容器，所谓双向开口就是再头尾两端均可以做元素的插入和删除操作。deque容器给我们的直观感觉大概是下面这样的(配图来自STL源码剖析)：

deque相比于vector最大的差异就在于支持常熟时间内对首尾两端进行插入和删除操作，而且deque没有容量的概念，其内部采用分段连续内存空间来存储元素，在插入元素的时候随时都可以重新增加一段新的空间并链接起来。

deque提供了Ramdon Access Iterator，同时也支持随机访问和存取，但是它也为此付出了昂贵的代价，其复杂度不能跟vector的原生指针迭代器相提并论。在下面的讲解中会一一为大家介绍STL是怎样”辛苦地”维持一个随机访问迭代器的。

deque的中控器

deque为了维持整体连续的假象，设计一个中控器，其用来记录deque内部每一段连续空间的地址。大体上可以理解为deque中的每一段连续空间分布在内存的不连续空间上，然后用一个所谓的map作为主控，记录每一段内存空间的入口，从而做到整体连续的假象。其布局大概如下(配图来自STL源码剖析)

看完图解，再来看看源码会很好理解的。

template <class T, class Alloc = alloc, size_t BufSiz = 0>
class deque {
public:
typedef T value_type;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
protected:
typedef pointer* map_pointer;
// 指向map, map是一个连续的空间, 其每个元素都是一个指向缓冲区的指针
map_pointer map;
size_type map_size; // map容量
}

抛弃型别定义，我们可以看到map实际上就是一个指向指针的指针(T**)，map所指向的是一个指针，该指针指向型别为T的一块内存空间。理解到这里，大概就清楚了deque的实现原理，不过，这些都不是重点！重点是deque的各种运算符的实现。做好心理准备，咱们继续往下看！！！

deque的迭代器

deque提供的是一个随机访问迭代器，由于是分段连续空间，其必须记录当前元素所在段的信息，从而在该段连续空间的边缘进行前进或者后退的时候能知道跳跃到的上一个或下一个缓冲区。deque必须完完全全地掌握和控制这些信息，以达到正确地跳跃！

/**
* 注意deque的迭代器没有重载STL的Iterator
*/
template <class T, class Ref, class Ptr, size_t BufSiz>
struct __deque_iterator {
typedef __deque_iterator<T, T&, T*, BufSiz> iterator;
typedef __deque_iterator<T, const T&, const T*, BufSiz> const_iterator;
// 以下为支持Iterator_traits而定义的一些类型
typedef random_access_iterator_tag iterator_category;
typedef T value_type;
typedef Ptr pointer;
typedef Ref reference;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef T** map_pointer;
typedef __deque_iterator self;
// 保存容器中的结点
T* cur; // 指向当前缓冲区中的元素
T* first; // 当前缓冲区的起点
T* last; // 当前缓冲区的终点
map_pointer node; // 指向管控中心
}
template <class T, class Ref, class Ptr, size_t BufSiz>
inline random_access_iterator_tag
iterator_category(const __deque_iterator<T, Ref, Ptr, BufSiz>&) {
return random_access_iterator_tag();
}
template <class T, class Ref, class Ptr, size_t BufSiz>
inline T* value_type(const __deque_iterator<T, Ref, Ptr, BufSiz>&) {
return 0;
}
template <class T, class Ref, class Ptr, size_t BufSiz>
inline ptrdiff_t* distance_type(const __deque_iterator<T, Ref, Ptr, BufSiz>&) {
return 0;
}

从源码中可以看出，deque的迭代器中有cur,first,last和node四个指针，前三个记录了迭代器与缓冲区的联系，最后一个记录了迭代器于中控器的关系。从下面这张图可以很好的看出其关系：

仅仅定义了迭代器结构还只是开始，迭代器是一个随机访问迭代器，所以其必须提供++，–，下标操作符等运算符。下面就来一一剖析吧！

buffer_size函数

/**
* 返回deque的buffer_size大小
*/
static size_t buffer_size() {
return __deque_buf_size(BufSiz, sizeof(T));
}
/**
* 如果n不为0，传回n，表示buffer size由用户自己定义
* 如果n为0，表示buffer_size采用默认值，
* 那么如果sz(元素大小)小于512，传回512/sz
* 如果sz不小于512，传回1
*/
inline size_t __deque_buf_size(size_t n, size_t sz)
{
return n != 0 ? n : (sz < 512 ? size_t(512 / sz) : size_t(1));
}

set_node函数

当迭代器处在当前缓冲区的边缘时，一旦前进或者后退，就要考虑超过当前缓冲区的情况，此时需要跳转到下一个缓冲区，这时候set_node就派上用场了。

void set_node(map_pointer new_node)
{
node = new_node; // 跳转到相应缓冲区
first = *new_node; // 更新跳转后缓冲区first信息
last = first + difference_type(buffer_size()); // 更新跳转后缓冲区last的信息
}

各种运算子

以下源码都是deque迭代器重载的运算子，以满足随机访问迭代器的要求。

reference operator*() const { return *cur; }
pointer operator->() const { return &(operator*()); }
/**
* 判断两个迭代器之间的距离，重载了‘-’运算子
*/
difference_type operator-(const self& x) const
{
return difference_type(buffer_size()) * (node - x.node - 1) +
(cur - first) + (x.last - x.cur);
}
/**
* 前缀自增，注意前缀自增返回自身引用
*/
self& operator++()
{
++cur; // 先自增当前元素的指针
if (cur == last) { // 判断是否为当前缓冲区最后一个
set_node(node + 1); // 如果为当前缓冲区最后一个，则跳转到下一个缓冲区
cur = first; // 更新为下一缓冲区的起始点
}
return *this;
}
/**
* 后缀自增
* 返回当前迭代器的一个副本, 并调用前缀自增运算符实现迭代器自身的自增
*/
self operator++(int) {
self tmp = *this;
++*this;
return tmp;
}
/**
* 前缀自减, 处理方式类似于前缀自增
* 如果当前迭代器指向元素是当前缓冲区的第一个元素
* 则将迭代器状态调整为前一个缓冲区的最后一个元素
*/
self& operator--()
{
if (cur == first) {
set_node(node - 1);
cur = last;
}
--cur;
return *this;
}
// 处理方法同后缀自增
self operator--(int)
{
self tmp = *this;
--*this;
return tmp;
}
/**
* 实现p+=n的功能
* 迭代器向前移动n个元素，其中n可能为负。实现步骤如下：
* 1、计算相对于该缓冲区起始位置的偏移量offset
* 2、如果offset没有超出缓冲区，则直接cur+=n
* 3、如果offset超过了缓冲区空间
* -- 如果offset大于0，计算向前移动多少个缓冲区，offset / difference_type(buffer_size())
* -- 如果offset小于0，计算向后移动多少个缓冲区,-difference_type((-offset - 1) / buffer_size()) - 1;
* 4、调整到移动后的位置。
*/
self& operator+=(difference_type n)
{
difference_type offset = n + (cur - first);
if (offset >= 0 && offset < difference_type(buffer_size()))
cur += n;
else {
difference_type node_offset =
offset > 0 ? offset / difference_type(buffer_size())
: -difference_type((-offset - 1) / buffer_size()) - 1;
set_node(node + node_offset);
cur = first + (offset - node_offset * difference_type(buffer_size()));
}
return *this;
}
/**
* 实现诸如p+n的功能
* 此函数中直接调用operator +=的函数
*/
self operator+(difference_type n) const
{
self tmp = *this;
// 这里调用了operator +=()可以自动调整指针状态
return tmp += n;
}
/**
* 实现p-=n的功能
* 此处直接利用operator += ，改变一下n的正负即可
*/
self& operator-=(difference_type n) { return *this += -n; }
/**
* 实现p-n的功能
* 直接调用operator -=的函数
*/
self operator-(difference_type n) const {
self tmp = *this;
return tmp -= n;
}
/**
* 下标运算子，支持随机存取的功能
*/
reference operator[](difference_type n) const { return *(*this + n); }
/**
* 下述都是一些判断运算的实现
*/
bool operator==(const self& x) const { return cur == x.cur; }
bool operator!=(const self& x) const { return !(*this == x); }
bool operator<(const self& x) const {
return (node == x.node) ? (cur < x.cur) : (node < x.node);
}