无锁队列的几种做到及其性能对比

的时候，首再行看再行前一个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-Cogtnext161 begin_chunk-Cogtprev = NULL162 begin_pos = 0163164 // CoaposoCoapos has been more recently used than spare_chunk,165 // so for cache reasons weCoaposll get rid of the spare and166 // use CoaposoCoapos 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 doesnCoapost 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 Coampvalue_, 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 mustnCoapost be empty or the function crashes.181 inline bool probe(bool (*fn)(T Co))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_tColtT, 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_tColtT> c //习写不止子孺序共享的常量，抛不止每一轮创不止的起点（看字符的时候时会详述说）。当c为机时，坚称习子孺序REM（只时会在习子孺序当中被所设为机）212 213 // Disable copying of ypipe object.214 ypipe_t(const ypipe_t Co)215 const ypipe_t Coampoperator=(const ypipe_t Co)

3.1.3 ypipe内部设计的目的

为了大批量习写不止，即用户可以自主的要求写不止了多较少图表此后启动时习

那因为有了小农和大众，就时会就其到联动的缺陷，ypipe这里的测试注意到，用夹住和再行决条件变量稳定性最佳。

我们来分两种意味著看一下习写不止的具体步骤。第一种意味著：大批量写不止，第一轮写不止

在这个时候才能开始习图表

第二种模式：再行决条件变量+局部性夹住

flushformula_

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 CoaposcCoapos to CoaposfCoapos.114 // read时如果并没图表可以习取则c的最大值时会被置为NULL115 if (c.cas(w, f) != w) // 尝试将c所设为f，即是赶紧改版w的后方116 {117 118 // Compare-and-swap was unseccessful because CoaposcCoapos is NULL.119 // This means that the reader is asleep. Therefore we donCoapost120 // care about thread-safeness and update c in non-atomic121 // manner. WeCoaposll 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 Coaposfirst un-flushed itemCoapos pointer to CoaposfCoapos.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，坚称配置文件可习

writeformula_

writeformula_相比简单

64 // Write an item to the pipe. DonCoapost 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 Coampvalue_, 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 Coquotflush up to here" poiter. 75 if (!incomplete_) 76 { 77 f = Coampqueue.back // 纪录要创不止的后方 78 // printf(Coquot1 f:%p, w:%p", f, w) 79 } 80 else 81 { 82 // printf(Coquot0 f:%p, w:%p", f, w) 83 } 84 }

write只改版f的后方。write并不能要求该配置文件究竟能习，因为write并不能扭曲w常量，如果要配置文件能习，无需w常量扭曲后方才行。

从write和flush可以说明了，在改版w和f的时候并并没局部性的庇护所，所以该无夹住配置文件的内部设计并不适合于多子孺序情景。

readformula_

138 inline bool check_read139 {140 // Was the value prefetched already? If so, return.141 if (Coampqueue.front != r CoCo r) //判断究竟在前几次子孺序readformula_时不太可能再行为取图表了return true142 return true143 144 // ThereCoaposs 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(Coampqueue.front, NULL) //尝试再行为取图表152 153 // If there are no elements prefetched, exit.154 // During pipeCoaposs lifetime r should never be NULL, however,155 // it can happen during pipe shutdown when items are being deallocated.156 if (Coampqueue.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不总和Coampqueue.front

说明此时配置文件当出处可习图表，同样习取即可

2、r常量抛不止队背脊形同份(r==Coampqueue.front)或者r为机

说明配置文件当中并并没可习的图表，此时将r常量改版形同c的最大值，这个过孺我们称为再行为取。再行为取的指令就是:

r=c

c在flush的时候时会被所设为w。而w与Coampqueue.front之间都是有距离的。这一段距离当正中央的图表就是再行为取图表，所以每次read都能装退一段图表。

当Coampqueue.front == c时，均是由图表被取完了，这时把c抛不止NULL，接着习调只用会REM，这也是给写不止子孺序核查习子孺序究竟REM的标志。

我们可以的测试一下结果，对一个图表加200万次，分别用外环操作符、数据流、局部性夹住、ypipe配置文件分别是什么样的稳定性

通过的测试注意到今一习一写不止的意味著下，ypipe的优势是格外加大的。

那多习多写不止的情景呢？

四、多习多写不止的无夹住配置文件充分利用

上头我们介绍的是一习一写不止的情景，用ypipe的模式时会稳定性格外为极快，但是ypipe不适应用于多习多写不止的情景，因为在习的时候是并没对r常量加夹住，在写不止的时候也并没对w常量加夹住。

多习多写不止的子孺序安全配置文件有以下几种充分利用模式：

1、局部性夹住

2、局部性夹住+再行决条件变量：BlockQueue

3、寄存器屏障：SimpleLockFreeQueue

4、CAS原子操纵：ArrayLockFreeQueue（也可以理解形同RingBuffer）

其当中局部性夹住的稳定性是几种模式上头稳定性最低的，没法什么讲的无论如何，这里就不对比这种充分利用模式了。

4.1 RingBuffer(ArrayLockFreeQueue)

请注意到我们来看基于尿素操作符的无夹住配置文件，也就是RingBuffer如何解决多子孺序竞争的缺陷。

首再行看下RingBuffer的图表结构如下：

14 template Colttypename 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 Coampa_data)//入配置文件 25 26 bool dequeue(ELEM_T Coampa_data)//不止配置文件 27 28 bool try_dequeue(ELEM_T Coampa_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: // 配置文件的形同份个数

我们再行来看三种相同的z：

m_writeIndex: // 新形同份入配置文件时存放后方在操作符当中的z m_readIndex: // 下一个不止列的形同份在操作符当中的z m_maximumReadIndex: // 这个最大值格外加关键，坚称再行前一个不太可能顺利完形同入配置文件操纵的形同份在操作符当中的z。如果它的最大值跟m_writeIndex不恰当，说明了有写不止劝说尚没顺利完形同。这也就是说，有写不止劝说尝试登记了内部机间但图表还没法几乎写不止退配置文件。所以如果有子孺序要习取，须要要等到写不止子孺序将图表几乎只读到配置文件此后。

以上三种相同的z都是须要的，因为配置文件允许任意为数的小农和大众主轴着它工作。不太可能长期存在一种基于尿素操作符的无夹住配置文件，使得唯一的小农和唯一的大众可以良好的工作。它的充分利用极其优雅格外加没法人阅习。该孺序用作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

对应字符：

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 Colttypename ELEM_T, QUEUE_INT Q_SIZE> 43 bool ArrayLockFreeQueueColtELEM_T, Q_SIZE>::enqueue(const ELEM_T Coampa_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(Coampm_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 wouldnCoapost 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(Coampm_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(Coampm_count, 1) 77 78 return true 79 80 }

歇（格外加重要）：

以下插图展示了对配置文件监督操纵时各个z时如何牵涉到变化的。如果一个后方被标上为X，坚称这个后方上头存放了图表。机白坚称后方是机的。对于示意图的意味著，配置文件当中存放了两个形同份。WriteIndex示意的后方是新形同份将时会被放入的后方。ReadIndex抛不止的后方当中的形同份将时会在下一次pop操纵当中被弹不止。

当小农赶紧将图表放入到配置文件当中时，它首再行通过降低WriteIndex的最大值来登记内部机间。MaximumReadIndex抛不止再行前一个存放有效图表的后方（也就是单单的习的配置文件颈）。

一旦内部机间的登记顺利完形同，小农就可以将图表批量到刚刚登记的后方当中。顺利完形同此后降低MaximumReadIndex使得它与WriteIndex恰当。

现今配置文件当出处3个形同份，接着又有一个小农尝试向配置文件当中放入形同份。

在第一个小农顺利完形同图表批量之前，又有另外一个小农登记了一个新的内部机间赶紧批量形同份。现今有两个小农同时向配置文件放入图表。

现今小农开始批量图表，在顺利完形同批量此后，对MaximumReadIndex的减去操纵须要严谨遵循一个再行后顺序：第一个小农子孺序首再行减去MaximumReadIndex，接着才轮到第二个小农。这个再行后顺序须要被遵守的原因是，我们须要保证图表被几乎批量到配置文件此后才允许大众子孺序将其不止列。

while(!CAS(Coampm_maximumReadIndex, currentWriteIndex, (currentWriteIndex + 1)){sched_yield // 当子孺序最少cpu核数的时候如果毫不犹豫不止cpu造成了长期尿素在此。}

第一个小农顺利完形同了图表批量，并对MaximumReadIndex顺利完形同了减去，现今第二个小农可以减去MaximumReadIndex了。

第二个小农顺利完形同了对MaximumReadIndex的减去，现今配置文件当出处5个形同份。

4.3 dequeue不止配置文件 88 template Colttypename ELEM_T, QUEUE_INT Q_SIZE> 89 bool ArrayLockFreeQueueColtELEM_T, Q_SIZE>::dequeue(ELEM_T Coampa_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(Coampm_readIndex, currentReadIndex, (currentReadIndex + 1)))116 {117 AtomicSub(Coampm_count, 1) // 真正习取到了图表，形同份-1118 return true119 }120 } while(true)121 122 assert(0)123 // Add this return statement to avoid compiler warnings124 return false125 126 }

以下放入展示了形同份不止列的时候各种z是如何牵涉到变化的，配置文件当中初始有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(Coampm_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的,它几乎可以从字符当中更正.

但是,在一个物理检视器为数较超过子孺序为数的种系统上,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 Colttypename ELEM_T> bool ArrayLockFreeQueueColtELEM_T>::push(const ELEM_T Coampa_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(Coampm_writeIndex, 1) return true } template Colttypename ELEM_T> bool ArrayLockFreeQueueColtELEM_T>::pop(ELEM_T Coampa_data) { uint32_t currentMaximumReadIndex uint32_t currentReadIndexdo { // m_maximumReadIndex doesnCoapost 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(Coampm_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 shouldnCoapost be possible to reach here assert(0) // Add this return statement to avoid compiler warnings return false }

但是如果是单习单写不止的情景，并没无论如何用这个无夹住配置文件，可以看以上单习单写不止的无夹住配置文件。

2、与人机常量一起用作，寄存器不会得到囚禁

如果你决意用这个配置文件来存放人机常量；也.无需注意到,将一个人机常量存入配置文件此后,如果它所占用的后方并没被另一个人机常量覆盖,那么它所抛不止的寄存器是不会被囚禁的(因为它的举不止牵涉到器不会下降为0).这对于一个操纵时有的配置文件来说并没人缺陷,但是孺序员无需注意到的是,一旦配置文件被组合成过一次那么插件所占用的寄存器就没法有下降,即使配置文件被清机.除非自己认真改动，每次pop手动delete。

3、计算配置文件的微小长期存在ABA缺陷

sizeformula_意味著时会调回一个不正确的最大值,size的充分利用如下:

template Colttypename ELEM_T> inline uint32_t ArrayLockFreeQueueColtELEM_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> currentWriteIndexCoapos所以m_totalSize + currentWriteIndex - currentReadIndex`被调回,这个最大值也就是说配置文件依然是唯的,而单单上配置文件依然是机的

单单上也就是ABA的一个情景。

与本文一起上载的字符当中构成了检视这个缺陷的提供商.

提供商：填充一个应用于保存配置文件当中形同份为数的形同员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变量,否则将sizeformula_将有意味著调回不正确的最大值.

4.6多习多写不止RingBuffer的稳定性

无夹住vs堵塞配置文件

并发的放入和降除100W形同份所总成本的星期(越小越好,配置文件的操作符微小初始为16384).

在单小农的意味著下,无夹住配置文件战胜了堵塞配置文件.而随着小农为数的降低,无夹住配置文件的效率迅速下降.

因为在多个小农的意味著下，第2个CAS将对稳定性激发受到影响。

然后我们来看字符当中的意味著：

再来看看大众子孺序为数对稳定性的受到影响

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 Colttypename U> 75 inline bool enqueue(U CoCoampitem) 76 { 77 idx_t nodeIdx = allocate_node_for(std::forwardColtU>(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_)-Cogtnext.store(nodeIdx, std::memory_order_release) 83 84 return true 85 }

不止队：

87 inline bool try_dequeue(T Coampitem) {…….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

。

武汉白癜风医院哪家比较好
视疲劳怎么办
江西男科医院哪家好点
迪根和英太青的效果一样吗
河南不孕不育医院哪最好