queue

queue up v. 排队等候Queue up at the box office.在售票处排队（有等待的意思。）-------------------line up v. 整队, 排列起All the canoes line up at the starting line.所有划艇都排在起始线上了。（只是排整齐的意思，没有说要等待。）

买本书看看吧，，关于STL的

queue信箱的主要用途是验证。队列是消息存储的目的地，队列可以分成普通队列和延时队列两类。如果发送消息时不指定消息延时参数，被发送到普通队列的消息立刻可以被消费，而发送到延时队列需要经过设定的延时时间后才能被消费。

队列群体。队列是一种特殊的线性表，是一种先进先出（FIFO）的数据结构。它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。队列的链表实现：在队列的形成过程中，可以利用线性链表的原理，来生成一个队列。基于链表的队列，要动态创建和删除节点，效率较低，但是可以动态增长。队列采用的FIFO(first in first out)，新元素（等待进入队列的元素）总是被插入到链表的尾部，而读取的时候总是从链表的头部开始读取。每次读取一个元素，释放一个元素。所谓的动态创建，动态释放。因而也不存在溢出等问题。由于链表由结构体间接而成，遍历也方便。

Queue本身并不是线程安全的，有两种方法来保证线程安全：1.手动加锁。QueuemyCollection=newQueue();lock(myCollection.SyncRoot){foreach(objectiteminmyCollection){//Insertyourcodehere.}}2.调用Synchronized方法，这时候得到的就是一个线程安全的QueueQueuemySyncdQ=Queue.Synchronized(myQ);

queuing

在主函数和定义队列的下面定义queue Q,然后Q就作为全局变量使用了。

Queue.Queue 是进程内非阻塞队列 multiprocess.Queue 是跨进程通信队列 前者是各自进程私有, 后者是各子进程共有.Manager 是 multiprocessing 的封装 .Manager.Queue 和 Queue, multiprocessing.Queue 没有太大关系

Queue是用到需要按顺序进行的时候。会在一个线程中写侦听事件，然后把侦听到的enqueue进去，然后在另外一个线程中dequeue出来。list是用来存储列表，通常存储都可以用。操作方法如下：1、首先打开vs创建一个控制台应用程序，在Main方法中，定义一个整型的队列。2、往队列中添加元素，使用Enqueue方法。3、使用foreach循环，输出整个队列的值。4、从队列中弹出一个元素，使用Dequeue方法，这个方法是没有参数的。弹出的是最先进入队列的元素。5、判断一个元素是否在队列中，使用Contains方法。6、清空整个队列，使用Clear方法。q.Clear();。7、最后获取队列的元素个数，使用Count属性。q.Count，就可以了。

java中queue的使用Queue接口与List、Set同一级别，都是继承了Collection接口。LinkedList实现了Queue接 口。Queue接口窄化了对LinkedList的方法的访问权限（即在方法中的参数类型如果是Queue时，就完全只能访问Queue接口所定义的方法 了，而不能直接访问 LinkedList的非Queue的方法），以使得只有恰当的方法才可以使用。BlockingQueue 继承了Queue接口。队列是一种数据结构．它有两个基本操作：在队列尾部加人一个元素，和从队列头部移除一个元素就是说，队列以一种先进先出的方式管理数据，如果你试图向一个 已经满了的阻塞队列中添加一个元素或者是从一个空的阻塞队列中移除一个元索，将导致线程阻塞．在多线程进行合作时，阻塞队列是很有用的工具。工作者线程可 以定期地把中间结果存到阻塞队列中而其他工作者线线程把中间结果取出并在将来修改它们。队列会自动平衡负载。如果第一个线程集运行得比第二个慢，则第二个 线程集在等待结果时就会阻塞。如果第一个线程集运行得快，那么它将等待第二个线程集赶上来。下表显示了jdk1.5中的阻塞队列的操作：add 增加一个元索 如果队列已满，则抛出一个IIIegaISlabEepeplian异常remove 移除并返回队列头部的元素 如果队列为空，则抛出一个NoSuchElementException异常element 返回队列头部的元素 如果队列为空，则抛出一个NoSuchElementException异常offer 添加一个元素并返回true 如果队列已满，则返回falsepoll 移除并返问队列头部的元素 如果队列为空，则返回nullpeek 返回队列头部的元素 如果队列为空，则返回nullput 添加一个元素 如果队列满，则阻塞take 移除并返回队列头部的元素 如果队列为空，则阻塞remove、element、offer 、poll、peek 其实是属于Queue接口。 阻塞队列的操作可以根据它们的响应方式分为以下三类：aad、removee和element操作在你试图为一个已满的队列增加元素或从空队列取得元素时 抛出异常。当然，在多线程程序中，队列在任何时间都可能变成满的或空的，所以你可能想使用offer、poll、peek方法。这些方法在无法完成任务时 只是给出一个出错示而不会抛出异常。注意：poll和peek方法出错进返回null。因此，向队列中插入null值是不合法的。还有带超时的offer和poll方法变种，例如，下面的调用：boolean success = q.offer(x,100,TimeUnit.MILLISECONDS);尝试在100毫秒内向队列尾部插入一个元素。如果成功，立即返回true；否则，当到达超时进，返回false。同样地，调用：Object head = q.poll(100, TimeUnit.MILLISECONDS);如果在100毫秒内成功地移除了队列头元素，则立即返回头元素；否则在到达超时时，返回null。最后，我们有阻塞操作put和take。put方法在队列满时阻塞，take方法在队列空时阻塞。java.ulil.concurrent包提供了阻塞队列的4个变种。默认情况下，LinkedBlockingQueue的容量是没有上限的（说的不准确，在不指定时容量为Integer.MAX_VALUE，不要然的话在put时怎么会受阻呢），但是也可以选择指定其最大容量，它是基于链表的队列，此队列按 FIFO（先进先出）排序元素。ArrayBlockingQueue在构造时需要指定容量， 并可以选择是否需要公平性，如果公平参数被设置true，等待时间最长的线程会优先得到处理（其实就是通过将ReentrantLock设置为true来 达到这种公平性的：即等待时间最长的线程会先操作）。通常，公平性会使你在性能上付出代价，只有在的确非常需要的时候再使用它。它是基于数组的阻塞循环队 列，此队列按 FIFO（先进先出）原则对元素进行排序。PriorityBlockingQueue是一个带优先级的 队列，而不是先进先出队列。元素按优先级顺序被移除，该队列也没有上限（看了一下源码，PriorityBlockingQueue是对 PriorityQueue的再次包装，是基于堆数据结构的，而PriorityQueue是没有容量限制的，与ArrayList一样，所以在优先阻塞 队列上put时是不会受阻的。虽然此队列逻辑上是无界的，但是由于资源被耗尽，所以试图执行添加操作可能会导致 OutOfMemoryError），但是如果队列为空，那么取元素的操作take就会阻塞，所以它的检索操作take是受阻的。另外，往入该队列中的元 素要具有比较能力。最后，DelayQueue（基于PriorityQueue来实现的）是一个存放Delayed 元素的无界阻塞队列，只有在延迟期满时才能从中提取元素。该队列的头部是延迟期满后保存时间最长的 Delayed 元素。如果延迟都还没有期满，则队列没有头部，并且poll将返回null。当一个元素的 getDelay(TimeUnit.NANOSECONDS) 方法返回一个小于或等于零的值时，则出现期满，poll就以移除这个元素了。此队列不允许使用 null 元素。

工作中的一些体会：如何查看queue里的messages的content.说实在的，MQ的东西很烦琐，虽然很强大。可是中文的资料太少（当然中文版的MQ会带些帮助文档，不过都是垃圾）；英文的太拗口（虽然我整天看英文的文档，还是看不太懂；要不就是MQ太庞大了？）反正我只是在工作中学了那么一点点可怜的东西，就赶快写出来了。据我所知，是有两种的方式来查看queue的content.Prepare:假设queue的名字叫做local.queue, queue manager的名字叫做 test.queue.manager，mq安装在/opt/mqm下.1.先确定queue的长度不是0.$runmqsc test.queue.managerdis ql("local.queue") curdepth 2 : dis ql("local.queue") curdepthAMQ8409: Display Queue details. QUEUE(local.queue) CURDEPTH(1)如上所示，queue里面是有一个message的，因为curdepth的长度为1.2.查看queue的message的内容第一种方式：使用/opt/mqm/samp/bin/amqsget第二种方式：使用/opt/mqm/samp/bin/amqsbcg共同点:都是在命令后面先跟queue的名字，然后再跟queue manager的名字,如下/opt/mqm/samp/bin/amqsget local.queue test.queue.manager区别是：前者只能查看短长度的message，并且会把message取出（还不是太确定后者）；遇到长度稍微长一点的就会发出2080的error code.$/opt/mqm/samp/bin/amqsget local.queue test.queue.managerSample AMQSGET0 startMQGET ended with reason code 2080Sample AMQSGET0 end而后者则没有这个限制；但是amqsbcg显示的message很奇特，连二进制的都同时显示

上面的程序是将0~9十个数字压入队列，然后依次出对queue的成员方法比较少，常用的也就那么几个，注意，要包含头文件<queue>对于priority_queue,他的原则是优先权大的先出队，也就是说，你在创建一个priority_queue的时候是可以指定每个元素的优先级的，优先级越大，出队越早，而queue只是传统意义上简单的队列。 追问： 我的意思是遍历，不出栈。后来我改用Vector了。可以用迭代器。Queue没有设计遍历啊。 回答： queue是严格遵守FIFO的，不提供遍历方式，如果要遍历，只能摧毁之，放到vector等中，然后遍历完了在重新创建之 D0ckLng 的感言： 明白了。

这个就跟字母Q的发音一样

queue up v.排队等候Queue up at the box office.在售票处排队（有等待的意思.）-------------------line up v.整队,排列起All the canoes line up at the starting line.所有划艇都排在起始线上了.（只是排整齐的意思,没有说要等待.）

没有试过，不过应该不过超过2GB大小。这是python在32位版本时就留下的一个内存管理缺陷。通常大小超过500MB，就会很慢。在实际应用环境中，queue最好不要超过几万条。通常保持在几百条以下更好。 单独的消息队列服务器，队列中缓存几百万条数据也是可以的。但是python的queue显然不是这样一个企业级应用。

Queue本身并不是线程安全的， 有两种方法来保证线程安全：1. 手动加锁。Queue myCollection = new Queue();lock(myCollection.SyncRoot){ foreach (object item in myCollection) { // Insert your code here. }}2. 调用Synchronized方法，这时候得到的就是一个线程安全的Queue Queue mySyncdQ = Queue.Synchronized( myQ );

Queue 叫队列，是数据结构中的一种，基本上所有成熟的编程语言都内置了对 Queue 的支持。 Python 中的 Queue 模块实现了多生产者和多消费者模型，当需要在多线程编程中非常实用。而且该模块中的 Queue 类实现了锁原语，不需要再考虑多线程安全问题。 该模块内置了三种类型的 Queue，分别是 class queue.Queue(maxsize=0) ， class queue.LifoQueue(maxsize=0) 和 class queue.PriorityQueue(maxsize=0) 。它们三个的区别仅仅是取出时的顺序不一致而已。 Queue 是一个 FIFO 队列，任务按照添加的顺序被取出。 LifoQueue 是一个 LIFO 队列，类似堆栈，后添加的任务先被取出。 PriorityQueue 是一个优先级队列，队列里面的任务按照优先级排序，优先级高的先被取出。 如你所见，就是上面所说的三种不同类型的内置队列，其中 maxsize 是个整数，用于设置可以放入队列中的任务数的上限。当达到这个大小的时候，插入操作将阻塞至队列中的任务被消费掉。如果 maxsize 小于等于零，则队列尺寸为无限大。 向队列中添加任务，直接调用 put() 函数即可 put() 函数完整的函数签名如下 Queue.put(item, block=True, timeout=None) ，如你所见，该函数有两个可选参数。 默认情况下，在队列满时，该函数会一直阻塞，直到队列中有空余的位置可以添加任务为止。如果 timeout 是正数，则最多阻塞 timeout 秒，如果这段时间内还没有空余的位置出来，则会引发 Full 异常。 当 block 为 false 时，timeout 参数将失效。同时如果队列中没有空余的位置可添加任务则会引发 Full 异常，否则会直接把任务放入队列并返回，不会阻塞。 另外，还可以通过 Queue.put_nowait(item) 来添加任务，相当于 Queue.put(item, False) ，不再赘述。同样，在队列满时，该操作会引发 Full 异常。 从队列中获取任务，直接调用 get() 函数即可。 与 put() 函数一样， get() 函数也有两个可选参数，完整签名如下 Queue.get(block=True, timeout=None) 。 默认情况下，当队列空时调用该函数会一直阻塞，直到队列中有任务可获取为止。如果 timeout 是正数，则最多阻塞 timeout 秒，如果这段时间内还没有任务可获取，则会引发 Empty 异常。 当 block 为 false 时，timeout 参数将失效。同时如果队列中没有任务可获取则会立刻引发 Empty 异常，否则会直接获取一个任务并返回，不会阻塞。 另外，还可以通过 Queue.get_nowait() 来获取任务，相当于 Queue.get(False) ，不再赘述。同样，在队列为空时，该操作会引发 Empty 异常。 Queue.qsize() 函数返回队列的大小。注意这个大小不是精确的，qsize() > 0 不保证后续的 get() 不被阻塞，同样 qsize() < maxsize 也不保证 put() 不被阻塞。 如果队列为空，返回 True ，否则返回 False 。如果 empty() 返回 True ，不保证后续调用的 put() 不被阻塞。类似的，如果 empty() 返回 False ，也不保证后续调用的 get() 不被阻塞。 如果队列是满的返回 True ，否则返回 False 。如果 full() 返回 True 不保证后续调用的 get() 不被阻塞。类似的，如果 full() 返回 False 也不保证后续调用的 put() 不被阻塞。 queue.Queue() 是 FIFO 队列，出队顺序跟入队顺序是一致的。 queue.LifoQueue() 是 LIFO 队列，出队顺序跟入队顺序是完全相反的，类似于栈。 优先级队列中的任务顺序跟放入时的顺序是无关的，而是按照任务的大小来排序，最小值先被取出。那任务比较大小的规则是怎么样的呢。 注意，因为列表的比较对规则是按照下标顺序来比较的，所以在没有比较出大小之前 ，队列中所有列表对应下标位置的元素类型要一致。 好比 [2,1] 和 ["1","b"] 因为第一个位置的元素类型不一样，所以是没有办法比较大小的，所以也就放入不了优先级队列。 然而对于 [2,1] 和 [1,"b"] 来说即使第二个元素的类型不一致也是可以放入优先级队列的，因为只需要比较第一个位置元素的大小就可以比较出结果了，就不需要比较第二个位置元素的大小了。 但是对于 [2,1] 和 1 [2,"b"] 来说，则同样不可以放入优先级队列，因为需要比较第二个位置的元素才可以比较出结果，然而第二个位置的元素类型是不一致的，无法比较大小。 综上，也就是说， 直到在比较出结果之前，对应下标位置的元素类型都是需要一致的 。 下面我们自定义一个动物类型，希望按照年龄大小来做优先级排序。年龄越小优先级越高。 本章节介绍了队列以及其常用操作。因为队列默认实现了锁原语，因此在多线程编程中就不需要再考虑多线程安全问题了，对于程序员来说相当友好了。

java中的queue类是队列数据结构管理类。在它里边的元素可以按照添加它们的相同顺序被移除。队列通常（但并非一定）以 FIFO（先进先出）的方式排序各个元素。不过优先级队列和 LIFO 队列（或堆栈）例外，前者根据提供的比较器或元素的自然顺序对元素进行排序，后者按 LIFO（后进先出）的方式对元素进行排序。无论使用哪种排序方式，队列的头都是调用remove()或poll()所移除的元素。在 FIFO 队列中，所有的新元素都插入队列的末尾。其他种类的队列可能使用不同的元素放置规则。每个Queue实现必须指定其顺序属性。offer 添加一个元素并返回true 如果队列已满，则返回falsepoll 移除并返问队列头部的元素 如果队列为空，则返回nullpeek 返回队列头部的元素 如果队列为空，则返回nullput 添加一个元素 如果队列满，则阻塞take 移除并返回队列头部的元素 如果队列为空，则阻塞element 返回队列头部的元素 如果队列为空，则抛出一个NoSuchElementException异常add 增加一个元索 如果队列已满，则抛出一个IIIegaISlabEepeplian异常remove 移除并返回队列头部的元素 如果队列为空，则抛出一个NoSuchElementException异常注意：poll和peek方法出错进返回null。因此，向队列中插入null值是不合法的。还有带超时的offer和poll方法重载，例如，下面的调用：boolean success = q.offer(x,100,TimeUnit.MILLISECONDS);尝试在100毫秒内向队列尾部插入一个元素。如果成功，立即返回true；否则，当到达超时进，返回false。同样地，调用：Object head = q.poll(100, TimeUnit.MILLISECONDS);如果在100毫秒内成功地移除了队列头元素，则立即返回头元素；否则在到达超时时，返回null。阻塞操作有put和take。put方法在队列满时阻塞，take方法在队列空时阻塞。Queue接口与List、Set同一级别，都是继承了Collection接口。LinkedList实现了Queue接 口。Queue接口窄化了对LinkedList的方法的访问权限（即在方法中的参数类型如果是Queue时，就完全只能访问Queue接口所定义的方法 了，而不能直接访问 LinkedList的非Queue的方法），以使得只有恰当的方法才可以使用。BlockingQueue 继承了Queue接口。

来源：为了理解好这个词组，最简单的方式就是联想到美人鱼。在水手们注意到美人鱼的鱼尾前，他们对美人鱼的上半身十分着迷。早在公元前1世纪时，罗马诗人贺拉斯就已如此描述过一件令人失望的艺术作品：“以致于上半部分如一位令人喜爱的女士，下半部分则如一条可怕的鱼 ”。之后，在19世纪，法国作家巴尔扎克在描述巴黎街道时也用了这个词组，他写道：“有些街道，包括蒙马特尔街，都拥有美丽的街头和如鱼尾般糟糕的街尾。”Exemple: Nous pensons que cet effet va probablement finir en queue de poisson.例子：我们认为这个效果最终可能会令人失望。

做排队的意思时候Line 美国人用得多 Queue英国人用的多

queue n.（人或车辆）行列，长队;辫子vi.（人、车等）排队等候vt.（使）排队，列队等待 第三人称单数：queues过去分词：queued复数：queues现在进行时：queuing过去式：queued

queue[英][kju:][美][kju]n.（人或车辆）行列，长队; 辫子; vi.（人、车等）排队等候; vt.（使）排队，列队等待; 第三人称单数：queues复数：queues现在分词：queuing过去式：queued过去分词：queued1Her gown was a light cotton print, and from the back of her head a kind of rope could be seen descending to some distance below her waist, like a Chinaman"s queue.她穿一件薄薄的印花布女衫，有一条像绳子似的东西从她的脑后垂下来，一直延伸到她的腰下，就像中国人的一条辫子。

queue 英[kju:] 美[kju] n. （人或车辆）行列,长队;辫子 vi. （人、车等）排队等候 vt. （使）排队,列队等待 [例句]Entrances were closed and passengers forced to queue. 车站入口被关闭,乘客被要求排队离开.

1、queue英[kju?]美[kju?]n.(储存的数据)队列; (人、汽车等的)队，行列;v.(人、车等)排队等候; (使)排队; 列队等待。2、[例句]In other cases, however, capacity should expand to keep the queue short.然而，在其他情况下，应该扩展服务能力以保持队列较短。

queue英［kju:]美［kju]。queue，英语单词，名词、动词，作名词时译为“队列；长队；辫子”，作动词时译为“排队；排队等候；将…梳成辫子；使…排队”。ueue变化形式：复数：queues第三人称单数：queues过去式：queued过去分词：queued现在分词：queuing例句：Somehow the queue must be disposed of .不管怎样，总得把排的队解决掉。At the best spots , advanced surfers informally queue for waves .在最佳冲浪点，高级冲浪者不规则的排着队等待冲浪。Entrances were closed and passengers forced to queue .车站入口被关闭，乘客被要求排队离开。This depicts the third queue type mentioned in this article .这描述的是本文中提到的第三种队列类型。

就是Q的发音亲，采纳吧~

System.Collections.Queue qu = new Queue(int);//试试，这里是说要一个类型

你弄个try{}catch(){}，看看哪一行出错啊~

LinkedBlockingDeque在结构上有别于之前讲解过的阻塞队列，它不是Queue而是Deque，中文翻译成双端队列，双端队列指可以从任意一端入队或者出队元素的队列，实现了在队列头和队列尾的高效插入和移除 LinkedBlockingDeque是链表实现的线程安全的无界的同时支持FIFO、LIFO的双端阻塞队列，可以回顾下之前的LinkedBlockingQueue阻塞队列特点，本质上是类似的，但是又有些不同： Queue和Deque的关系有点类似于单链表和双向链表，LinkedBlockingQueue和LinkedBlockingDeque的内部结点实现就是单链表和双向链表的区别，具体可参考源码。 在第二点中可能有些人有些疑问，两个互斥锁和一个互斥锁的区别在哪里？我们可以考虑以下场景： A线程先进行入队操作，B线程随后进行出队操作，如果是LinkedBlockingQueue，A线程入队过程还未结束（已获得锁还未释放），B线程出队操作不会被阻塞等待（锁不同），如果是LinkedBlockingDeque则B线程会被阻塞等待（同一把锁）A线程完成操作才继续执行 LinkedBlockingQueue一般的操作是获取一把锁就可以，但有些操作例如remove操作，则需要同时获取两把锁，之前的LinkedBlockingQueue讲解曾经说明过 LinkedBlockingQueue 由于是单链表结构，只能一端操作，读只能在头，写只能在尾，因此两把锁效率更高。LinkedBlockingDeque 由于是双链表结构，两端头尾都能读写，因此只能用一把锁保证原子性。 当然效率也就更低 ArrayBlockingQueue LinkedBlockingQueue 问题，为什么ArrayBlockingQueue 不能用两把锁 因为取出后，ArrayBlockingQueue 的元素需要向前移动。 LinkedBlockingQueue内部由单链表实现，只能从head取元素，从tail添加元素。添加元素和获取元素都有独立的锁，也就是说LinkedBlockingQueue是读写分离的，读写操作可以并行执行。LinkedBlockingQueue采用可重入锁(ReentrantLock)来保证在并发情况下的线程安全。 LinkedBlockingQueue一共有三个构造器，分别是无参构造器、可以指定容量的构造器、可以穿入一个容器的构造器。如果在创建实例的时候调用的是无参构造器，LinkedBlockingQueue的默认容量是Integer.MAX_VALUE，这样做很可能会导致队列还没有满，但是内存却已经满了的情况（内存溢出）。 size()方法会遍历整个队列，时间复杂度为O(n),所以最好选用isEmtpy 1.判断元素是否为null，为null抛出异常 2.加锁(可中断锁) 3.判断队列长度是否到达容量，如果到达一直等待 4.如果没有队满，enqueue()在队尾加入元素 5.队列长度加1，此时如果队列还没有满，调用signal唤醒其他堵塞队列 1.加锁(依旧是ReentrantLock)，注意这里的锁和写入是不同的两把锁 2.判断队列是否为空，如果为空就一直等待 3.通过dequeue方法取得数据 3.取走元素后队列是否为空，如果不为空唤醒其他等待中的队列 原理：在队尾插入一个元素， 如果队列没满，立即返回true； 如果队列满了，立即返回false。 原理：如果没有元素，直接返回null；如果有元素，出队 1、具体入队与出队的原理图 ： 图中每一个节点前半部分表示封装的数据x，后边的表示指向的下一个引用。 1.1、初始化 初始化之后，初始化一个数据为null，且head和last节点都是这个节点。 1.2、入队两个元素过后 1.3、出队一个元素后 表面上看，只是将头节点的next指针指向了要删除的x1.next，事实上这样我觉的就完全可以，但是jdk实际上是将原来的head节点删除了，而上边看到的这个head节点，正是刚刚出队的x1节点，只是其值被置空了。 2、三种入队对比： 3、三种出队对比：

　　LinkedTransferQueue是一个聪明的队列，他是ConcurrentLinkedQueue,　　SynchronousQueue (in “fair” mode), and unbounded LinkedBlockingQueue的超集。　　LinkedTransferQueue实现了一个重要的接口TransferQueue,该接口含有下面几个重要方法：　　1. transfer(E e)　　若当前存在一个正在等待获取的消费者线程，即立刻移交之；否则，会插入当前元素e到队列尾部，并且等待进入阻塞状态，到有消费者线程取走该元素。　　2. tryTransfer(E e)　　若当前存在一个正在等待获取的消费者线程（使用take()或者poll()函数），使用该方法会即刻转移/传输对象元素e；　　若不存在，则返回false，并且不进入队列。这是一个不阻塞的操作。　　3. tryTransfer(E e, long timeout, TimeUnit unit)　　若当前存在一个正在等待获取的消费者线程，会立即传输给它; 否则将插入元素e到队列尾部，并且等待被消费者线程获取消费掉,　　若在指定的时间内元素e无法被消费者线程获取，则返回false，同时该元素被移除。　　4. hasWaitingConsumer()　　判断是否存在消费者线程　　5. getWaitingConsumerCount()　　获取所有等待获取元素的消费线程数量

首先 BufferSlot 是 Buffer 的封装， BufferQueueCore 使用 mSlots 来管理所有Buffer, mSlots 是一个 BufferSlot 数组， 包含了所有的BufferSlot. BufferSlot里面最重要的两个成员是: mGraphicBuffer 和 mBufferState BufferItem是 mQueue 中的元素， mQueue是 BufferQueueCore中另一个重要的成员， 是一个FIFO队列。 生产者调用queueBuffer的时候， 会把这个Buffer封装成BufferItem，然后放入到 mQueue中。 消费者调用acquireBuffer的时候会取出来mQueue中的第一个元素进行消费。 我们知道Buffer有四种状态: Dequeued, Queued, Acquired, Free. 这种状态使用 BufferState来封装， 就是我们上面提到的 BufferSlot中的 mBufferState. 整个BufferQueue机制是通过 BufferQueue.cpp 的 createBufferQueue来创建的， 会创建三个角色: BufferQueueCore, BufferQueueProducer, BufferQueueConsusmer. 其中 BufferQueueProducer 和 BufferQueueConsumer都是Binder， 可以跨进程调用。 但是我们一般都是在消费者进程创建的BufferQ, 所以一般只要把 BufferQueueProducer传递给远端就可以了。 BufferQueueProducer和BufferQueueConsumer都可以直接访问 BufferQueueCore, 其中 BufferQueueProducer中还包含了BufferQueueCore中的mSlots的一个 引用， 这样会方便 BufferQueueProducer更快捷的操作 mSlots. BufferQueueConsumer 和 BufferQueueProducer 的回调 都是在各自的 connect 方法中执行的。 会向 BufferQueueCore中分别注册自己的回调: ProxyConsumerListener 和 IProducerListener 这两个回调， 因为 Producer一般在远端， 所以 IProducerListener这个回调里面还包含了Binder死亡回调的实现。 BufferItem中定义了索引值mSlot, 这个是 mSlots这个数组的下标， 这样通过BufferItem就可以得到具体的BufferSlot了。 BufferSlot的状态分为： Active状态和Free状态， Active状态代表了正在被生产者或者消费者使用的状态， Free状态代表了空闲的BufferSlot， 而Free状态又被分为了: FreeBuffer 和 FreeSlot, FreeBuffer代表了已经拥有Buffer的BufferSlot, FreeSlot代表还没有拥有Buffer的BufferSlot. Active状态的BufferSlot的下标 被放在了 mActiveBuffers 这个 vector中。 FreeBuffer状态的BufferSlot的下标 被放在了 mFreeBuffers 这个 vector 中。 FreeSlot状态的BufferSlot的下标被放在了mFreeSlot这个vector中。 BufferSlot没有实现任何Binder或者Flattenable接口， 不能跨进程传递， 所以只能在BufferQueueCore中接受管理， 同时 BufferQueueProducer 作为bn端， 和BufferQueueCore在同一个进程中， 也保存了 mSlots 的一个引用。 BufferItem和GraphicBuffer都实现了Flattenable， 可以跨进程传递。 首先看一下生产者最常见的操作: dequeueBuffer 和 queueBuffer dequeueBuffer 这个方法会返回一个可用的GraphicBuffer, 而waitForFreeSlotThenRelock只是会返回可用的slot. requestBuffer 这个方法就是根据传入的slot, 把这个slot对应的GraphicBuffer放入到指定的buffer指针中， 这个方法并不会分配新的Buffer. 也就是说requestBuffer得到的Buffer也有可能是空的。 queueBuffer的流程是比较简单的。 attachBuffer就是把本来不属于该BQ的Buffer放入该BQ中让该BQ管理。 也就是说 Producer 的 attach 和 detach方法， 都不会往FIFO中放入BufferItem, 仅仅是把Buffer放入了BufferQueueCore中进行管理。 attachBuffer之后， 这个Buffer的状态是Dequeued, 是活跃的。 detachBuffer之后， 这个buffer的状态是Queued--的， 是FreeSlot状态。 从上面的分析可以知道， 生产者直接attach一个buffer到BQ中是不能被消费的， 必须 attach+queue才可以。

在Java中，BlockingQueue是一个接口，它的实现类有 ArrayBlockingQueue、DelayQueue、 LinkedBlockingDeque、 LinkedBlockingQueue、PriorityBlockingQueue、 SynchronousQueue等，它们的区别主要体现在存储结构上或对元素 操作上的不同，但是对于take与put操作的原理，却是类似的。 阻塞与非阻塞 LinkedBlockingQueue内部是使用链表实现一个队列的，但是有别于一般的队列，在于该队列至少是有一个节点的，头节点不含有元素。如果队列为空时，头节点的next参数为null。尾节点的next参数也为null。 1、LinkedBlockingQueue不允许插入的元素为null； 2、同一时刻只有一个线程可以进行入队操作，putLock在将元素插入队列尾部时加锁了； 3、如果队列满了，则会调用notFull.await(),将该线程加入到Condition等待队列中。await方法会释放线程占有的锁，这将导致之前由于被阻塞的入队线程将会获取到锁，执行到while循环处，不过可能因为队列仍旧是满的，也被进入到条件队列中； 4、一旦有出队线程取走元素，就会通知到入队等待队列释放线程。那么第一个加入到Condition队列中的将会被释放，那么该线程将会重新获得put锁，继而执行enqueue()方法，将节点插入到队列的尾部； 5、然后得到插入队列前元素的个数，如果插入后队列中还可以继续插入元素，那么就通知notFull条件的等待队列中的线程； 6、如果插入队列前个数为0，那现在插入后，就为1了，那就可以通知因为队列为空而导致阻塞的出队线程去取元素了。 1、同一时刻只有一个线程可以进行出队操作，takeLock在出队之前加锁了； 2、如果队列中元素为空，那就进入notEmpty队列中进行等待。直到队列不为空时，得到队列中的第一个元素。当发现取完发现还有元素可取时，再通知一下notEmpty队列中等待的其他线程。最后判断自己取元素前的是不是满的，如果是满的，那自己取完，就不满了，就可以通知在notFull队列中等待插入的线程进行put了。 LinkedBlockingQueue允许两个线程同时在两端进行入队和出队操作，但一端同时只能有一个线程进行操作，是通过两个锁进行区分的。 为了维护底部数据的统一，引入了AtomicInteger的一个count变量，表示队列中元素的个数。count只能在两个地方变化，一个是入队的方法（进行+1操作），另一个是出队的方法（进行-1操作），而AtomicInteger是原子安全的，所以也就确保了底层队列的数据同步。 ArrayBlockingQueue内部是使用数组实现一个队列的，并且在构造方法中就需要指定容量，也就意味着底层数组一旦创建了，容量就不能改变了，因此ArrayBlockingQueue是一个容量限制的阻塞队列。因此在队列满的时候执行入队会阻塞，在队列为空时出队也会阻塞。 1、ArrayBlockingQueue不允许添加null元素； 2、ArrayBlockingQueue在队列已满的时候，会调用notFull.await()，释放锁并处于阻塞状态； 3、一旦ArrayBlockingQueue在队列不满的时候，就立即入队。 1、取元素时，一旦获得锁，队列为空， 则会阻塞，直至不为空，调用dequeue()出队。 ArrayBlockingQueue是一个底层结构是数组的阻塞队列，是通过 ReentrantLock 和 Condition 来实现的。不可插入为null的元素，入队和出队使用的是同一个锁。意味着同一时刻只能有一个线程能进行入队或者出队操作。入队时，队列已满则会调用notFull.await()，进入阻塞状态。直到队列不满时，再进行入队操作。当出队时，队列为空，则调用notEmpty.await()，进入阻塞状态，直到队列不为空时，则出队。 LinkedBlockingQueue底层实现是链表，ArrayBlockingQueue底层实现是数组 LinkedBlockingQueue默认的队列长度是Integer.Max，但是可以指定容量。在入队与出队都高并发的情况下，性能比ArrayBlockingQueue高很多； ArrayBlockingQueue必须在构造方法中指定队列长度，不可变。在只有入队高并发或出队高并发的情况下，因为操作数组，且不需要扩容，性能很高。 LinkedBlockingQueue有两把锁，可以有两个线程同时进行入队和出队操作，但同时只能有一个线程进行入队或出队操作。 ArrayBlockingQueue只有一把锁，同时只能有一个线程进行入队和出队操作。

1.首先看错误代码行：list 初始化了吗或者被赋值了吗，而且list 里的对象必须是string类型的。2.从异常看java.util.ConcurrentModificationException:字面意思并发修改异常。出现该异常一般是检测到对象的并发修改，但不允许这样修改，就会抛出这样的异常。3.当collection接口如list 被一个线程调用那么另一线程就不允许修改collection。

翻译：队列指标

你是用的web授权方式吧，因为新浪在授权时新增加了一个策略所以要包名和签名，而web方式是没有的，所以你可以找新浪的的人把你的包名和密钥给他，让他在后台给你手动加上。

AWT-EventQueue-0这个线程有异常

肯定可以存放指针诶

Layer收到onFrameAvaliable通知后，会通知SurfaceFlinger更新，重新进行图像合成 在SurfaceFlinger重新合成图像的过程中，会遍历所有发生变化的Layer，此时调用Layer的latchBuffer函数去BufferQueue中拿方才生产者入队的Buffer进行处理 latchBuffer比较长， 主要作用分析是否需要重新计算当前Layer的visibleRegion 接着看下updateTextureImage方法 updateTextureImage函数主要包含个流程 1：acquireBufferLocked从BufferQueue中获取Buffer,拿到Buffer后，将Buffer保存在mSlots[item->mSlot].mGraphicBuffer中。 2：调用参数传入的Rejecter对象。来判断图像缓冲区Buffer是否符合条件。 3：调用updateAndReleaseLocked函数更新Buffer，并且释放掉上一个Buffer SurfaceFlingerConsumer的acquireBufferLocked直接调用了父类的acquireBufferLocked函数。 GLConsumer的acquireBufferLocked函数也比较简单，调用父类ConsumerBase的acquireBufferLocked函数获取新的Buffer，然后根据获取的新GraphicBuffer创建一个EglImage,保存在GLConsumer的数组mEglSlots中。 GLConsumer维护了一个数组mEglSlots，和前面讲的mSlots类似，将EglImage对象保存在数组对应的slot位置上 同理GLConsumer的acquireBufferLocked也是直接调用BufferQueueConsumer的方法。 BufferQueueConsumer的acquiredBuffer函数从BufferQueue中拿准备好的Buffer数据。 1:先统计消费者acquire的buffer的数量是否查过最大限度，超过的话则禁止获取 2:遍历mQueue队列，获取合适的Buffer。如果Queue中等待显示的Buffer数量大于1，需要查看队列后边是否有指定显示时间且显示时间已经到的Buffer，有到话则直接放弃前边一个，显示后一个。循环处理，直到找到最紧急显示到Buffer。 3:根据找到的Buffer判断该Buffer是有需要立刻显示，如果离指定显示时间大于一定时间，则发挥PRESENT_LATER，此次显示不再处理该Buffer。 4:拿到需要显示的Buffer，设置需要显示Buffer的状态为ACQUIRED，并且将它从mQueue等待对了移除。 5:如果有遗弃的Buffer,需要同时有Buffer释放。 分析到这里Buffer已经从BufferQueue队列获取到了，下一步看如何更新Buffer。 updateAndRelease方法从名称就可看出其操作内容。更新新Buffer,释放旧Buffer。 每一个Layer都和一个Surface对应， Surface在App端，是操作和填充当前窗口的接口，而Layer则在SurfaceFlinger端来描述这个窗口。Layer在创建的时候会创建一个纹理Texture,这个Texture id也保存在了SurfaceFlingerConsumer中。SurfaceFlinger绘制的时候遍历Layer，Layer又会调用自己的SurfaceFlingerConsumer将合适的Buffer更新到纹理中。 SufaceFlinger更新纹理，上一步介绍了如果从BufferQueue中获取Buffer.这一步介绍，如何更新到纹理。 1：首先做判断，是否attach到EGLContext，没有Attach则直接释放当前Buffer。普通Layer默认是Attach到SurfaceFlinger主线程的EGLContext上的。(需要attach的SurfaceView) 2：检查EGL状态和上次是否发生了变化 3：每个slot中的GraphicBuffer都会创建一个EGLImage,保存在GLConsumer的mEglSlots数组中。 4：释放掉旧的buffer 5：保存新的Buffer信息到GLConsumer信息中，等待将Buffer数据填充到openGL纹理中 上面的步骤已经把Buffer从Buffer队列获取到了，也已经将Buffer更新到GLConsumer中，同时也释放掉了旧的Buffer,但是何时填充纹理进行绘制呢？ 也是在SurfaceFlinger进行图形合成的过程中，先执行了latchBuffer来更新纹理，后边后依次执行Layer的onDraw方法，进行绘制，Layer的onDraw方法会调用SurfaceFlingerConsumer的bindTextureImage来绑定并填充纹理。 这个步骤将纹理绑定到了EGLContext, 然后调用了glEGLImageTargetTexture2DOES(texTarget,static_cast<GLeglImageOES>(mEglImage));将Buffer内容填充到了纹理中。这样纹理也准备好了，就等SurfaceFlinger进行合成了。 一个GraphicBuffer缓冲区如何从Producer传递到Consumer，以及Consumer接收到之后如何处理已经分析完成了。过程比较长，做一下简单的总结。

queue reservations排队预订