无锁链表的几种实现及其性能对比

18 }

可以看着112行，在要push一个成份的时候，首先行看再一一个chunk，也就是back_chunk的back_pos是不是该chunk的再一一个成份，如果是，则重新近重新近分配一个chunk，将这个chunk纳到chunk堆栈的下一个终端。

这个逻辑比较简单来真是还是非常直观的。唯一所需关注的，就是

102 chunk_t *sc = spare_chunk.xchg(NULL)

这即刻，这个spare_chunk是怎么来的？

154 // Removes an element from the front end of the queue.155 inline void pop156 {157 if (++begin_pos == N) // 删除满一个chunk才回收chunk158 {159 chunk_t *o = begin_chunk160 begin_chunk = begin_chunk-Pricegtnext161 begin_chunk-Pricegtprev = NULL162 begin_pos = 0163164 // PriceaposoPriceapos has been more recently used than spare_chunk,165 // so for cache reasons wePriceaposll get rid of the spare and166 // use PriceaposoPriceapos as the spare.167 chunk_t *cs = spare_chunk.xchg(o) //由于一般说来原理，总是存留最重新近休息块而拘押先行前的休息更慢168 free(cs)169 }170 }

当pop的时候，如果删除一个chunk底下不用成份了，这个时候才会所需将这个chunk所建起的室内空间拘押掉，但是这里常用了一个技巧即：将这个chunk先行不拘押，先行放到spare_chunk底下，等到而会所需建起重新近室内空间的时候再把这个spare_chunk拿来用。

我们再来看ypipe

3.1.2 ypipe——yqueue的嵌补

yqueue负责管理成份闪存的重新近分配与拘押，补队以及造出资料流；ypipe负责管理yqueue读过写下操作符的变化。

ypipe是在yqueue_t的基础上再相结合一个单读过单写下的无针资料流

这里有三个操作符：

T* w:对准第一个未曾刷重新近成份，只被写下多线程常用 T* r:对准第一个不用被先行为分离出来的成份，只被读过多线程常用 T*f:对准下一轮要被刷重新近一批成份的第一个

ypipe的概念：

37 // Initialises the pipe. 38 inline ypipe_t 49 // The destructor doesnPriceapost have to be virtual. It is mad virtual 50 // just to keep ICC and code checking tools from complaining. 51 inline virtual ~ypipe_t 52 { 53 } 67 // 写下补资料，incomplete匹配表示写下补前提还不用顺利先行取行，在不用顺利先行取行的时候不才会修改flush操作符，即这部分资料不才会让读过多线程看着。 68 inline void write(const T Priceampvalue_, bool incomplete_) 92 inline bool unwrite(T *value_)104 // 新近纪录所有并未曾顺利先行取行的资料到管道，调回false也就是说读过多线程在母体，在这种状况下命令行者所需醒觉读过多线程。105 // 大批量刷重新近前提， 写下补大批量后醒觉读过多线程；106 // 惹怒前提 unwrite107 inline bool flush 136 // Check whether item is available for reading.137 // 这底下有两个点，一个是检测前提有资料；也过，一个是先行为取138 inline bool check_read163 // Reads an item from the pipe. Returns false if there is no value.164 // available.165 inline bool read(T *value_)178 // Applies the function fn to the first elemenent in the pipe179 // and returns the value returned by the fn.180 // The pipe mustnPriceapost be empty or the function crashes.181 inline bool probe(bool (*fn)(T Price))189 protected:190 // Allocation-efficient queue to store pipe items.191 // Front of the queue points to the first prefetched item, back of192 // the pipe points to last un-flushed item. Front is used only by193 // reader thread, while back is used only by writer thread.194 yqueue_tPriceltT, N> queue195 196 // Points to the first un-flushed item. This variable is used197 // exclusively by writer thread.198 T *w //对准第一个未曾刷重新近成份,只被写下多线程常用199 200 // Points to the first un-prefetched item. This variable is used201 // exclusively by reader thread.202 T *r //对准第一个还不用先行为分离出来的成份，只被读过多线程常用203 204 // Points to the first item to be flushed in the future.205 T *f //对准下一轮要被刷重新近一批成份当中的第一个206 207 // The single point of contention between writer and reader thread.208 // Points past the last flushed item. If it is NULL,209 // reader is asleep. This pointer should be always accessed using210 // atomic operations.211 atomic_ptr_tPriceltT> c //读过写下多线程共享的操作符，对准每一轮刷重新近起点（看code的时候才会详细真是）。当c为空时，表示读过多线程痉挛（只才会在读过多线程当中被设为为空）212 213 // Disable copying of ypipe object.214 ypipe_t(const ypipe_t Price)215 const ypipe_t Priceampoperator=(const ypipe_t Price)

3.1.3 ypipe的设计的终究目标

为了大批量读过写下，即浏览器可以先决条件的决定写下了多少资料以后带入读过

那因为有了产造出和生产者，就才会牵涉到到该系统的疑虑，ypipe这里次测试发掘出，用针和先决条件函数精度最佳。

我们来分两种状况看一下读过写下的具体步骤。第一种状况：大批量写下，第一轮写下

在这个时候才能开始读过资料

第二种手段：先决条件函数+多线程针

flush变数

101 // Flush all the completed items into the pipe. Returns false if102 // the reader thread is sleeping. In that case, caller is obliged to103 // wake the reader up before using the pipe again.104 // 新近纪录所有并未曾顺利先行取行的资料到管道，调回false也就是说读过多线程在母体，在这种状况下命令行者所需醒觉读过多线程。105 // 大批量刷重新近前提， 写下补大批量后醒觉读过多线程；106 // 惹怒前提 unwrite107 inline bool flush108 {109 // If there are no un-flushed items, do nothing.110 if (w == f) // 不所需新近纪录，即是还不用新近成份转补111 return true112 113 // Try to set PriceaposcPriceapos to PriceaposfPriceapos.114 // read时如果不用资料可以读过取则c的系数才会被置为NULL115 if (c.cas(w, f) != w) // 想法将c设为为f，即是正要备份w的后方116 {117 118 // Compare-and-swap was unseccessful because PriceaposcPriceapos is NULL.119 // This means that the reader is asleep. Therefore we donPriceapost120 // care about thread-safeness and update c in non-atomic121 // manner. WePriceaposll return false to let the caller know122 // that reader is sleeping.123 c.set(f) // 备份为重新近f后方124 w = f125 return false //多线程看着flush调回false以后才会发送一个第一时间给读过多线程，这所需写下业务去做处理事件126 }127 else // 读过端还有资料；也过取128 {129 // Reader is alive. Nothing special to do now. Just move130 // the Priceaposfirst un-flushed itemPriceapos pointer to PriceaposfPriceapos.131 w = f // 备份f的后方132 return true133 }134 }

flush的终究目标就是将相反w的系数，同时相反c的系数

这里有两种状况：

1、c的系数与w的系数几乎一致

真是明资料流的w系数不用备份，不对资料流的资料先行取行读过取

这起因在flush第一次起因的时候以及w的系数还未曾备份时，此时调回true，表示资料流不；也过。

2、c的系数与w的系数不几乎一致

这起因在c在w后方前面，此时备份c与w的系数，并调回false，表示资料流；也过

write变数

write变数比较简单直观

64 // Write an item to the pipe. DonPriceapost flush it yet. If incomplete is 65 // set to true the item is assumed to be continued by items 66 // subsequently written to the pipe. Incomplete items are neverflushed down the stream. 67 // 写下补资料，incomplete匹配表示写下补前提还不用顺利先行取行，在不用顺利先行取行的时候不才会修改flush操作符，即这部分资料不才会让读过多线程看着。 68 inline void write(const T Priceampvalue_, bool incomplete_) 69 { 70 // Place the value to the queue, add new terminator element. 71 queue.back = value_ 72 queue.push 73 74 // Move the Pricequotflush up to here" poiter. 75 if (!incomplete_) 76 { 77 f = Priceampqueue.back // 记录要刷重新近后方 78 // printf(Pricequot1 f:%p, w:%p", f, w) 79 } 80 else 81 { 82 // printf(Pricequot0 f:%p, w:%p", f, w) 83 } 84 }

write只备份f的后方。write并没法决定该资料流前提能读过，因为write并没法相反w操作符，如果要资料流能读过，所需w操作符相反后方才行。

从write和flush可以看造出，在备份w和f的时候并不用多线程的保护，所以该无针资料流的的设计并不适合多多线程情景。

read变数

138 inline bool check_read139 {140 // Was the value prefetched already? If so, return.141 if (Priceampqueue.front != r PricePrice r) //断定前提在前几次命令行read变数时并未曾先行为取资料了return true142 return true143 144 // TherePriceaposs no prefetched value, so let us prefetch more values.145 // Prefetching is to simply retrieve the146 // pointer from c in atomic fashion. If there are no147 // items to prefetch, set c to NULL (using compare-and-swap).148 // 两种状况149 // 1. 如果c系数和queue.front， 调回c系数并将c系数置为NULL，此时不用资料；也过150 // 2. 如果c系数和queue.front， 调回c系数，此时或许有资料度的去151 r = c.cas(Priceampqueue.front, NULL) //想法先行为取资料152 153 // If there are no elements prefetched, exit.154 // During pipePriceaposs lifetime r should never be NULL, however,155 // it can happen during pipe shutdown when items are being deallocated.156 if (Priceampqueue.front == r || !r) //断定前提顺利先行为取资料157 return false158 159 // There was at least one value prefetched.160 return true161 }162 163 // Reads an item from the pipe. Returns false if there is no value.164 // available.165 inline bool read(T *value_)166 {167 // Try to prefetch a value.168 if (!check_read)169 return false170 171 // There was at least one value prefetched.172 // Return it to the caller.173 *value_ = queue.front174 queue.pop175 return true176 }

这里也是有两种状况：

1、r不为空且r不等于Priceampqueue.front

真是明此时资料流当中曾；也过资料，直接读过取方能

2、r操作符对准队背脊成份(r==Priceampqueue.front)或者r为空

真是明资料流当中并不用；也过的资料，此时将r操作符备份成c的系数，这个过孺我们是从先行为取。先行为取的呼叫就是:

r=c

c在flush的时候才会被设为为w。而w与Priceampqueue.front中间都是有一段距离的。这更远当中间的资料就是先行为取资料，所以每次read都能取造出一段资料。

当Priceampqueue.front == c时，代表人资料被取完了，这时把c对准NULL，接着读过多线程才会痉挛，这也是给写下多线程检测读过多线程前提痉挛的标志。

我们可以次测试一下结果，对一个资料纳200万次，分别用外侧操作符、堆栈、多线程针、ypipe资料流分别是什么样的精度

通过次测试发今天一读过一写下的状况下，ypipe的绝对优势是并不大的。

那多读过多写下的情景呢？

四、多读过多写下的无针资料流借助

侧面我们介绍的是一读过一写下的情景，用ypipe的手段才会精度非常更慢，但是ypipe不适可用多读过多写下的情景，因为在读过的时候是不用对r操作符纳针，在写下的时候也不用对w操作符纳针。

多读过多写下的多线程合理资料流有以下几种借助手段：

1、多线程针

2、多线程针+先决条件函数：BlockQueue

3、闪存一道：SimpleLockFreeQueue

4、CAS原子操作方法：ArrayLockFreeQueue（也可以了解成RingBuffer）

其当中多线程针的精度是几种手段底下精度最低的，不用什么讲的合理，这里就不对比这种借助手段了。

4.1 RingBuffer(ArrayLockFreeQueue)

上头我们来看基于可逆操作符的无针资料流，也就是RingBuffer如何彻底解决多多线程相互竞争的疑虑。

首先行看下RingBuffer的资料结构如下：

14 template Pricelttypename ELEM_T, QUEUE_INT Q_SIZE = ARRAY_LOCK_FREE_Q_DEFAULT_SIZE> 15 class ArrayLockFreeQueue 16 { 17 public: 18 19 ArrayLockFreeQueue 20 virtual ~ArrayLockFreeQueue 21 22 QUEUE_INT size 23 24 bool enqueue(const ELEM_T Priceampa_data)//补资料流 25 26 bool dequeue(ELEM_T Priceampa_data)//造出资料流 27 28 bool try_dequeue(ELEM_T Priceampa_data) 29 30 private: 31 32 ELEM_T m_thequeue[Q_SIZE] 33 34 volatile QUEUE_INT m_count 35 volatile QUEUE_INT m_writeIndex 36 37 volatile QUEUE_INT m_readIndex 38 39 volatile QUEUE_INT m_maximumReadIndex 40 41 inline QUEUE_INT countToIndex(QUEUE_INT a_count) 42 }

m_count: // 资料流的成份个数

我们先行来看三种多种不同的斜线：

m_writeIndex: // 新近成份补资料流时贮藏后方在操作符当中的斜线 m_readIndex: // 下一个造出列的成份在操作符当中的斜线 m_maximumReadIndex: // 这个系数并不关键，表示再一一个并未曾顺利先行取行补资料流操作方法的成份在操作符当中的斜线。如果它的系数跟m_writeIndex不相一致，真是明了有写下劝真是尚未曾顺利先行取行。这也就是说，有写下劝真是顺利登记了室内空间但资料还不用几乎写下先行取资料流。所以如果有多线程要读过取，需要要等到写下多线程将资料几乎写下补到资料流以后。

以上三种多种不同的斜线都是需要的，因为资料流并不需要给定存量的产造出和生产者围绕着它工作。并未曾共存一种基于可逆操作符的无针资料流，使得唯一的产造出和唯一的生产者可以不错的工作。它的借助较为简洁并不系数得写作过。该孺序常用gcc内置的originallysync_bool_compare_and_swap，但重新近做了祥概念嵌补。

#define CAS(a_ptr, a_oldVal, a_newVal) originallysync_bool_compare_and_swap(a_ptr, a_oldVal, a_newVal)

资料流已满断定：

(m_writeIndex+1) % Q_SIZE == m_readIndex

相异code：

countToIndex(currentWriteIndex + 1) == countToIndex(currentReadIndex)

资料流为空断定：

m_readIndex == m_maximumReadIndex

该RingBuffer的着重主要是以下四个之外的疑虑：

1、多多线程写下补的时候，m_writeIndex如何备份?

2、m_maximumReadIndex这个函数为什么才会所需？它有什么依赖性？

3、多多线程读过的恶时候，m_readIndex如何备份？

4、m_maximumReadIndex在什么时候相反？

** **

4.2 enqueue补资料流 42 template Pricelttypename ELEM_T, QUEUE_INT Q_SIZE> 43 bool ArrayLockFreeQueuePriceltELEM_T, Q_SIZE>::enqueue(const ELEM_T Priceampa_data) 44 { 45 QUEUE_INT currentWriteIndex // 提供写下操作符的后方 46 QUEUE_INT currentReadIndex 47 // 1. 提供可写下补的后方 48 do 49 { 50 currentWriteIndex = m_writeIndex 51 currentReadIndex = m_readIndex 52 if(countToIndex(currentWriteIndex + 1) == 53 countToIndex(currentReadIndex)) 54 { 55 return false // 资料流并未曾满了 56 } 57 // 终究目标是为了提供一个能写下补的后方 58 } while(!CAS(Priceampm_writeIndex, currentWriteIndex, (currentWriteIndex+1))) 59 // 提供写下补后方后 currentWriteIndex 是一个临时函数，存留我们写下补的后方 60 // We know now that this index is reserved for us. Use it to save the data 61 m_thequeue[countToIndex(currentWriteIndex)] = a_data // 把资料备份到相异的后方 62 63 // 2. 备份；也过的后方，按着m_maximumReadIndex+1的操作方法 64 // update the maximum read index after saving the data. It wouldnPriceapost fail if there is only one thread 65 // inserting in the queue. It might fail if there are more than 1 producer threads because this 66 // operation has to be done in the same order as the previous CAS 67 while(!CAS(Priceampm_maximumReadIndex, currentWriteIndex, (currentWriteIndex + 1))) 68 { 69 // this is a good place to yield the thread in case there are more 70 // software threads than hardware processors and you have more 71 // than 1 producer thread 72 // have a look at sched_yield (POSIX.1b) 73 sched_yield // 当多线程高达cpu核数的时候如果马上与cpu造成了一直可逆在此。 74 } 75 76 AtomicAdd(Priceampm_count, 1) 77 78 return true 79 80 }

图示（并不重要）：

以下版画展现了对资料流拒绝执行操作方法时各个斜线时如何变化的。如果一个后方被标记为X，表示这个后方底下贮藏了资料。空白表示后方是空的。对于下图的状况，资料流当中贮藏了两个成份。WriteIndex命令的后方是新近成份将才会被跳到的后方。ReadIndex对准的后方当中的成份将才会在下一次pop操作方法当中被弹造出。

当产造出正要将资料跳到到资料流当中时，它首先行通过降低WriteIndex的系数来登记室内空间。MaximumReadIndex对准再一一个贮藏有效资料的后方（也就是具体的读过的资料流尾）。

一旦室内空间的登记顺利先行取行，产造出就可以将资料大批量到刚刚登记的后方当中。顺利先行取行以后降低MaximumReadIndex使得它与WriteIndex相一致。

今天资料流当中曾3个成份，接着又有一个产造出想法向资料流当中跳到成份。

在第一个产造出顺利先行取行资料大批量以后，又有另外一个产造出登记了一个重新近室内空间正要大批量成份。今天有两个产造出同时向资料流跳到资料。

今天产造出开始大批量资料，在顺利先行取行大批量以后，对MaximumReadIndex的纳减操作方法需要规范遵循一个次序：第一个产造出多线程首先行纳减MaximumReadIndex，接着才轮到第二个产造出。这个次序需要被规范遵守的原因是，我们需要保证资料被几乎大批量到资料流以后才并不需要生产者多线程将其造出列。

while(!CAS(Priceampm_maximumReadIndex, currentWriteIndex, (currentWriteIndex + 1)){sched_yield // 当多线程高达cpu核数的时候如果马上与cpu造成了一直可逆在此。}

第一个产造出顺利先行取行了资料大批量，并对MaximumReadIndex顺利先行取行了纳减，今天第二个产造出可以纳减MaximumReadIndex了。

第二个产造出顺利先行取行了对MaximumReadIndex的纳减，今天资料流当中曾5个成份。

4.3 dequeue造出资料流 88 template Pricelttypename ELEM_T, QUEUE_INT Q_SIZE> 89 bool ArrayLockFreeQueuePriceltELEM_T, Q_SIZE>::dequeue(ELEM_T Priceampa_data) 90 { 91 QUEUE_INT currentMaximumReadIndex 92 QUEUE_INT currentReadIndex 93 94 do 95 { 96 // to ensure thread-safety when there is more than 1 producer thread 97 // a second index is defined (m_maximumReadIndex) 98 currentReadIndex = m_readIndex 99 currentMaximumReadIndex = m_maximumReadIndex100 101 if(countToIndex(currentReadIndex) ==102 countToIndex(currentMaximumReadIndex)) // 如果不为空，提供到读过索引的后方103 {104 // the queue is empty or105 // a producer thread has allocate space in the queue but is 106 // waiting to commit the data into it107 return false108 }109 // retrieve the data from the queue110 a_data = m_thequeue[countToIndex(currentReadIndex)] // 从临时后方读过取的111 112 // try to perfrom now the CAS operation on the read index. If we succeed113 // a_data already contains what m_readIndex pointed to before we 114 // increased it115 if(CAS(Priceampm_readIndex, currentReadIndex, (currentReadIndex + 1)))116 {117 AtomicSub(Priceampm_count, 1) // 真正读过取到了资料，成份-1118 return true119 }120 } while(true)121 122 assert(0)123 // Add this return statement to avoid compiler warnings124 return false125 126 }

以下跳到展现了成份造出列的时候各种斜线是如何变化的，资料流当中初始有2个成份。WriteIndex命令的后方是新近成份将才会被跳到的后方。ReadIndex对准的后方当中的成份将才会在下一次pop操作方法当中被弹造出。

生产者多线程大批量操作符ReadIndex后方的成份，然后想法CAS操作方法将ReadIndex纳1.如果操作方法顺利生产者顺利地将资料造出列。因为CAS操作方法是原子的，所以只有唯一的多线程可以在同一每一次备份ReadIndex的系数。

如果操作方法失利，读过取重新近ReadIndex的系数，移位以上操作方法(copy资料，CAS)。

今天又有一个生产者将成份造出列，资料流变成空。

今天有一个产造出正在向资料流当中掺补成份。它并未曾顺利的登记了室内空间，但尚未曾顺利先行取行资料大批量。任何其他企图从资料流当中移除成份的生产者都才会发掘出资料流非空(因为writeIndex不等于readIndex)。但它没法读过取readIndex所对准后方当中的资料，因为readIndex与MaximumReadIndex几乎一致。这个时候读过资料失利，所需等到产造出顺利先行取行资料大批量降低MaximumReadIndex的系数才可以读过。

当产造出顺利先行取行资料大批量，资料流的大小不一是1，生产者多线程就可以读过取这个资料了。

4.4 yielding处理事件器的合理性 67 while(!CAS(Priceampm_maximumReadIndex, currentWriteIndex, (currentWriteIndex + 1))) 68 { 69 // this is a good place to yield the thread in case there are more 70 // software threads than hardware processors and you have more 71 // than 1 producer thread 72 // have a look at sched_yield (POSIX.1b) 73 sched_yield // 当多线程高达cpu核数的时候如果马上与cpu造成了一直可逆在此。 74 }

在enqueue的第二个CAS底下有一个sched_yield来主动让与处理事件器的操作方法，对于一个确信无针的插值而言，这个命令行看来有点儿奇怪。多多线程环境下因素精度的其当中一个因素就是Cache毁损。而诱发Cache毁损的一种状况就是一个多线程被守住，操作方法系统所需存留被守住多线程的字符串，然后被选当中作为下一个调度多线程的字符串载补。此时Cache当中多线程的资料都才会失效，因为它是被守住多线程的资料而不是新近多线程的资料。

无针插值和通过截断前提该系统的插值的一个主要区别在于无针插值不才会截断在多线程该系统上。那这里的让与CPU，与截断在多线程该系统上有啥区别？为什么不直接自旋？

首先行真是下sched_yield的合理性：sched_yield的命令行与有多少个产造出多线程在并发地往资料流当中贮藏资料有关：每个产造出多线程所拒绝执行的CAS操作方法都需要规范遵循FIFO以此类推,一个可用登记室内空间,另一个可用通知生产者资料并未曾写下补顺利先行取行可以被读过取了.如果我们的应用孺序只有唯一的产造出这个操作方法资料流，sched_yield将这世界不用机才会被命令行，因为enqueue的第二个CAS操作方法这世界不才会失利。因为一个产造出的状况下不用人能毁损产造出拒绝执行这两个CAS操作方法的FIFO次序。

而对于多个产造出多线程往资料流当中贮藏资料的时候，疑虑就造显现出了。概括来真是，一个产造出通过第1个CAS操作方法登记室内空间,然后将资料写下补到登记到的室内空间当中,然后拒绝执行第2个CAS操作方法通知生产者资料正要完毕可供读过取了.这第2个CAS操作方法需要遵循FIFO次序,也就是真是,如果A多线程第首先行拒绝执行完第一个CAS操作方法,那么它也要第1个拒绝执行完第2个CAS操作方法,如果A多线程在拒绝执行完第一个CAS操作方法以后停顿,然后B多线程拒绝执行完第1个CAS操作方法,那么B多线程将难以顺利先行取行第2个CAS操作方法,因为它要马上A先行顺利先行取行第2个CAS操作方法.而这就是疑虑诱发的因由.让我们回避如下情景,3个生产者多线程和1个生产者多线程:

多线程1,2,3按次序命令行第1个CAS操作方法登记了室内空间.那么它们顺利先行取行第2个CAS操作方法的次序也某种程度与这个次序相一致,1,2,3. 多线程2首先行想法拒绝执行第2个CAS,但它才会失利,因为多线程1还不用顺利先行取行它的第2此CAS操作方法呢.除此以外对于多线程3也是一样的. 多线程2和3将才会急剧的命令行它们的第2个CAS操作方法,直到多线程1顺利先行取行它的第2个CAS操作方法为止. 多线程1终究顺利先行取行了它的第2个CAS,今天多线程3需要等多线程2先行顺利先行取行它的第2个CAS. 多线程2也顺利先行取行了,终究多线程3也顺利先行取行.

在侧面的情景当中,产造出或许才会在第2个CAS操作方法上自旋一段马上时间,可用马上在在它拒绝执行第1个CAS操作方法的多线程顺利先行取行它的第2次CAS操作方法.在一个物理化学处理事件器存量大于操作方法资料流多线程存量的系统上,这不才会有毕竟严重的疑虑:因为每个多线程都可以重新近分配在自己的处理事件器上拒绝执行,它们终究都才会很更慢顺利先行取行各自的第2次CAS操作方法.虽然插值造成了多线程处理事件整天等状态,但这正是我们所盼望的,因为这使得操作方法更更慢的顺利先行取行.也就是真是在这种状况下我们是不所需sche_yield的,它几乎可以从code当中删除.

但是,在一个物理化学处理事件器存量少于多线程存量的系统上,sche_yield就越来越至关重要了.让我们再次就其侧面3个多线程的情景,当多线程3正要向资料流当中跳到资料:如果多线程1在拒绝执行完第1个CAS操作方法,在拒绝执行第2个CAS操作方法以后被守住,那么多线程2,3就才会一直在它们的第2个CAS操作方法上整天等(它们整天等,马上与处理事件器,多线程1也就不用机才会拒绝执行,它们就只能一直整天等),直到多线程1重新近被醒觉,顺利先行取行它的第2个CAS操作方法.这就是所需sche_yield的用语了,操作方法系统某种程度尽量避免让多线程2,3处于整天等状态.它们某种程度尽更慢的让与处理事件器让多线程1拒绝执行,使得多线程1可以把它的第2个CAS操作方法顺利先行取行.这样多线程2和3才能一直顺利先行取行它们的操作方法.

也就是真是，如果不一般来真是sched_yield，一直自旋，那么或许多个多线程同时截断在第二个CAS那儿。

4.5多读过多写下的RingBuffer共存的疑虑

1、可有一个产造出多线程精度大大提高不突造出

如果有可有一个的产造出多线程,那么将它们很或许花费大量的马上时间可用马上备份MaximumReadIndex(第2个CAS).这个资料流刚开始的的设计情景是满足单独生产者,所以不用怀疑在多产造出的情形下才会比单独产造出有随之的精度急剧下降.

另外如果你只打算将此资料流可用单独产造出的用语,那么第2个CAS操作方法可以去除.除此以外m_maximumReadIndex也可以随同被移除了,所有对m_maximumReadIndex的引用都改成m_writeIndex.所以,在这样的用语下push和pop可以被删掉下如下:

template Pricelttypename ELEM_T> bool ArrayLockFreeQueuePriceltELEM_T>::push(const ELEM_T Priceampa_data) { uint32_t currentReadIndex uint32_t currentWriteIndex currentWriteIndex = m_writeIndex currentReadIndex = m_readIndex if (countToIndex(currentWriteIndex + 1) == countToIndex(currentReadIndex)) { // the queue is full return false } // save the date into the q m_theQueue[countToIndex(currentWriteIndex)] = a_data // increment atomically write index. Now a consumer thread can read // the piece of data that was just stored AtomicAdd(Priceampm_writeIndex, 1) return true } template Pricelttypename ELEM_T> bool ArrayLockFreeQueuePriceltELEM_T>::pop(ELEM_T Priceampa_data) { uint32_t currentMaximumReadIndex uint32_t currentReadIndexdo { // m_maximumReadIndex doesnPriceapost exist when the queue is set up as // single-producer. The maximum read index is described by the current // write index currentReadIndex = m_readIndex currentMaximumReadIndex = m_writeIndex if (countToIndex(currentReadIndex) == countToIndex(currentMaximumReadIndex)) { // the queue is empty or // a producer thread has allocate space in the queue but is // waiting to commit the data into it return false } // retrieve the data from the queue a_data = m_theQueue[countToIndex(currentReadIndex)] // try to perfrom now the CAS operation on the read index. If we succeed // a_data already contains what m_readIndex pointed to before we // increased it if (CAS(Priceampm_readIndex, currentReadIndex, (currentReadIndex + 1))) { return true } // it failed retrieving the element off the queue. Someone else must // have read the element stored at countToIndex(currentReadIndex) // before we could perform the CAS operation } while(1) // keep looping to try again! // Something went wrong. it shouldnPriceapost be possible to reach here assert(0) // Add this return statement to avoid compiler warnings return false }

但是如果是单读过单写下的情景，不用合理用这个无针资料流，可以看以上单读过单写下的无针资料流。

2、与平板操作符独自常用，闪存难以得到拘押

如果你打算用这个资料流来贮藏平板操作符对象.所需提醒,将一个平板操作符提领资料流以后,如果它所占用的后方不用被另一个平板操作符遮盖,那么它所对准的闪存是难以被拘押的(因为它的引用计时器难以急剧下降为0).这对于一个操作方法不时的资料流来真是不用什么疑虑,但是孺序员所需提醒的是,一旦资料流被凿出过一次那么应用孺序所占用的闪存就不才会急剧下降,即使资料流被清空.除非自己做改动，每次pop手动delete。

3、计算造出来资料流的大小不一共存ABA疑虑

size变数或许才会调回一个不确实的系数,size的借助如下:

template Pricelttypename ELEM_T> inline uint32_t ArrayLockFreeQueuePriceltELEM_T>::size { uint32_t currentWriteIndex = m_writeIndex uint32_t currentReadIndex = m_readIndex if (currentWriteIndex>= currentReadIndex) { return (currentWriteIndex - currentReadIndex) } else { return (m_totalSize + currentWriteIndex - currentReadIndex) } }

上头的情景描绘了size为何才会调回一个不确实的系数:

当currentWriteIndex = m_writeIndex拒绝执行以后,m_writeIndex=3,m_readIndex = 2那么具体size是1 以后操作方法多线程被守住,且在它停顿开始运行的这段马上时间内,有2个成份被跳到和从资料流当中移除.所以m_writeIndex=5,m_readIndex = 4,而size还是1 今天被守住的多线程恢复拒绝执行,读过取m_readIndex系数,这个时候currentReadIndex=4,currentWriteIndex=3. currentReadIndex> currentWriteIndexPriceapos所以m_totalSize + currentWriteIndex - currentReadIndex人口为120人被调回,这个系数也就是说资料流差不多是满的,而其实资料流差不多是空的

其实也就是ABA的一个情景。

与本文独自完整版的code当中包含了处理事件这个疑虑的系统设计.

系统设计：掺补一个可用存留资料流当中成份存量的团员count.这个团员可以通过AtomicAdd/AtomicSub来借助原子的纳减和递减.

但所需提醒的是这降低了一定支出,因为原子纳减,递减操作方法非常昂贵也并不需要被编译器建模.

例如,在core 2 duo E6400 2.13 Ghz 的电脑上,单产造出单生产者,资料流操作符的初始大小不一是1000,次测试拒绝执行10,000k次的跳到,不用count团员的版全孺2.64秒,而维护了count团员的版全孺3.42秒.而对于2生产者,1产造出的状况,不用count团员的版全孺3.98秒,维护count的版全孺5.15秒.

这也就是为什么我把前提动工此团员函数的为了让交给具体的常用者.常用者可以根据自己的常用用语为了让前提承受额外的开始运行时支出. 在array_lock_free_queue.h当中曾一个名为ARRAY_LOCK_FREE_Q_KEEP_REAL_SIZE的祥函数,如果它被概念那么将动工count函数,否则将size变数将有或许调回不确实的系数.

4.6多读过多写下RingBuffer的精度

无针vs截断资料流

并发的跳到和移除100W成份所花费的马上时间(越小越好,资料流的操作符大小不一初始为16384).

在单产造出的状况下,无针资料流取胜了截断资料流.而随着产造出存量的降低,无针资料流的生产成本迅速急剧下降.

因为在多个产造出的状况下，第2个CAS将对精度诱发因素。

然后我们来看code当中的状况：

再来进去生产者多线程存量对精度的因素

1、一个产造出多线程

2、两个产造出

3、三个产造出

4.7 RingBuffer结论

1、CAS操作方法是原子的，多线程并行拒绝执行push/pop不才会造成了死针

2、多产造出同时向资料流push资料的时候不才会将资料写下补到同一个后方,诱发资料遮盖

3、多生产者同时拒绝执行pop不才会造成了一个成份被造出列可有1次

4、多线程没法将资料push先行取并未曾满的资料流当中,没法从空的资料流当中pop成份

5、push和pop都不用ABA疑虑

但是,虽然这个资料流是多线程合理的,但是在多产造出多线程的环境下它的精度还是不如截断资料流.因此,在符合都可先决条件的状况下可以回避常用这个资料流来代替截断资料流:

1、只有一个产造出多线程

2、只有一个不时操作方法资料流的产造出,但偶尔才会有其它产造出向资料流push资料

在reactor网路框架当中，如果只有一个reactor在处理事件client的话，用操作符借助的RingBuffer来存储器第一时间是非常适当的。

4.8 四种多线程合理资料流借助精度对比

多线程针资料流 vs 多线程针+先决条件函数资料流 vs 闪存一道堆栈 vs RingBuffer CAS借助

1、4写下1读过

2、4写下4读过

3、1写下4读过

可以发掘出RingBuffer的借助精度在几个情景当中都是非常好的，但是比较简单而言，在1写下4读过的情景下精度是最突造出的，差不多是闪存一道的3倍精度了。

为什么堆栈的手段精度比较简单BlockQueue不用很小的大大提高呢？

1、堆栈的手段所需急剧的登记和拘押成份。当然，用闪存水池可以适当优化这个因素，但是闪存水池在重新近分配闪存与拘押闪存的时候也才会牵涉到到多线程间的资料相互竞争，所以用堆栈的手段精度比较简单大大提高不多。

补队：

74 template Pricelttypename U> 75 inline bool enqueue(U PricePriceampitem) 76 { 77 idx_t nodeIdx = allocate_node_for(std::forwardPriceltU>(item)) 78 79 auto tail_ = tail.load(std::memory_order_relaxed) 80 while (!tail.compare_exchange_weak(tail_, nodeIdx, std::memory_order_release, std::memory_order_relaxed)) 81 continue 82 get_node_at(tail_)-Pricegtnext.store(nodeIdx, std::memory_order_release) 83 84 return true 85 }

造出队：

87 inline bool try_dequeue(T Priceampitem) {…….125 add_node_to_free_list(head_, headNode)}

2、堆栈所需急剧地去备份背脊终端和尾终端操作符的后方，在一个while可逆底下反复去拒绝执行

80 while (!tail.compare_exchange_weak(tail_, nodeIdx, std::memory_order_release, std::memory_order_relaxed))81 continue

。

济宁妇科医院哪家医院好
成都男科医院哪家正规
沈阳儿科医院电话
威海白癜风治疗费用是多少
武汉白癜风治疗费用多少钱