1. 数据结构中如何理解:循环队列的每一个元素都有一个前驱和后继
一个循环队列就是收尾相连的队列，如果是用数组创建的队列，那么就会有指向队首和队尾的指针，这两个指针通过一个函数不断的在队列中走来走去，当队尾那个指针指向最后了的时候，它会用某个函数（书上有的）指向最前面，所以，这队列中可以一直指下去，没有停断的时候，自然就有一个前驱和后继了。如果是指针的话，就更加形象了，因为它的最后一个结点一直是指向最后一个结点的，所以，第一个元素和最后一个元素都有前驱和后继了，其他中间的我就不说了。
2. 面试 linux 文件系统怎样io到底层
前言：本文主要讲解LinuxIO调度层的三种模式：cfp、deadline和noop，并给出各自的优化和适用场景建议。IO调度发生在Linux内核的IO调度层。这个层次是针对Linux的整体IO层次体系来说的。从read()或者write()系统调用的角度来说，Linux整体IO体系可以分为七层，它们分别是：VFS层：虚拟文件系统层。由于内核要跟多种文件系统打交道，而每一种文件系统所实现的数据结构和相关方法都可能不尽相同，所以，内核抽象了这一层，专门用来适配各种文件系统，并对外提供统一操作接口。文件系统层：不同的文件系统实现自己的操作过程，提供自己特有的特征，具体不多说了，大家愿意的话自己去看代码即可。页缓存层：负责真对page的缓存。通用块层：由于绝大多数情况的io操作是跟块设备打交道，所以Linux在此提供了一个类似vfs层的块设备操作抽象层。下层对接各种不同属性的块设备，对上提供统一的BlockIO请求标准。IO调度层：因为绝大多数的块设备都是类似磁盘这样的设备，所以有必要根据这类设备的特点以及应用的不同特点来设置一些不同的调度算法和队列。以便在不同的应用环境下有针对性的提高磁盘的读写效率，这里就是大名鼎鼎的Linux电梯所起作用的地方。针对机械硬盘的各种调度方法就是在这实现的。块设备驱动层：驱动层对外提供相对比较高级的设备操作接口，往往是C语言的，而下层对接设备本身的操作方法和规范。块设备层：这层就是具体的物理设备了，定义了各种真对设备操作方法和规范。有一个已经整理好的[LinuxIO结构图]，非常经典，一图胜千言：我们今天要研究的内容主要在IO调度这一层。它要解决的核心问题是，如何提高块设备IO的整体性能？这一层也主要是针对机械硬盘结构而设计的。众所周知，机械硬盘的存储介质是磁盘，磁头在盘片上移动进行磁道寻址，行为类似播放一张唱片。这种结构的特点是，顺序访问时吞吐量较高，但是如果一旦对盘片有随机访问，那么大量的时间都会浪费在磁头的移动上，这时候就会导致每次IO的响应时间变长，极大的降低IO的响应速度。磁头在盘片上寻道的操作，类似电梯调度，实际上在最开始的时期，Linux把这个算法命名为Linux电梯算法，即：如果在寻道的过程中，能把顺序路过的相关磁道的数据请求都“顺便”处理掉，那么就可以在比较小影响响应速度的前提下，提高整体IO的吞吐量。这就是我们为什么要设计IO调度算法的原因。目前在内核中默认开启了三种算法/模式：noop，cfq和deadline。严格算应该是两种：因为第一种叫做noop，就是空操作调度算法，也就是没有任何调度操作，并不对io请求进行排序，仅仅做适当的io合并的一个fifo队列。目前内核中默认的调度算法应该是cfq，叫做完全公平队列调度。这个调度算法人如其名，它试图给所有进程提供一个完全公平的IO操作环境。注：请大家一定记住这个词语，cfq，完全公平队列调度，不然下文就没法看了。cfq为每个进程创建一个同步IO调度队列，并默认以时间片和请求数限定的方式分配IO资源，以此保证每个进程的IO资源占用是公平的，cfq还实现了针对进程级别的优先级调度，这个我们后面会详细解释。查看和修改IO调度算法的方法是：cfq是通用服务器比较好的IO调度算法选择，对桌面用户也是比较好的选择。但是对于很多IO压力较大的场景就并不是很适应，尤其是IO压力集中在某些进程上的场景。因为这种场景我们需要的满足某个或者某几个进程的IO响应速度，而不是让所有的进程公平的使用IO，比如数据库应用。deadline调度（最终期限调度）就是更适合上述场景的解决方案。deadline实现了四个队列：其中两个分别处理正常read和write，按扇区号排序，进行正常io的合并处理以提高吞吐量。因为IO请求可能会集中在某些磁盘位置，这样会导致新来的请求一直被合并，可能会有其他磁盘位置的io请求被饿死。另外两个处理超时read和write的队列，按请求创建时间排序，如果有超时的请求出现，就放进这两个队列，调度算法保证超时（达到最终期限时间）的队列中的请求会优先被处理，防止请求被饿死。不久前，内核还是默认标配四种算法，还有一种叫做as的算法（Anticipatoryscheler），预测调度算法。一个高大上的名字，搞得我一度认为Linux内核都会算命了。结果发现，无非是在基于deadline算法做io调度的之前等一小会时间，如果这段时间内有可以合并的io请求到来，就可以合并处理，提高deadline调度的在顺序读写情况下的数据吞吐量。其实这根本不是啥预测，我觉得不如叫撞大运调度算法，当然这种策略在某些特定场景差效果不错。但是在大多数场景下，这个调度不仅没有提高吞吐量，还降低了响应速度，所以内核干脆把它从默认配置里删除了。毕竟Linux的宗旨是实用，而我们也就不再这个调度算法上多费口舌了。1、cfq：完全公平队列调度cfq是内核默认选择的IO调度队列，它在桌面应用场景以及大多数常见应用场景下都是很好的选择。如何实现一个所谓的完全公平队列（CompletelyFairQueueing）？首先我们要理解所谓的公平是对谁的公平？从操作系统的角度来说，产生操作行为的主体都是进程，所以这里的公平是针对每个进程而言的，我们要试图让进程可以公平的占用IO资源。那么如何让进程公平的占用IO资源？我们需要先理解什么是IO资源。当我们衡量一个IO资源的时候，一般喜欢用的是两个单位，一个是数据读写的带宽，另一个是数据读写的IOPS。带宽就是以时间为单位的读写数据量，比如，100Mbyte/s。而IOPS是以时间为单位的读写次数。在不同的读写情境下，这两个单位的表现可能不一样，但是可以确定的是，两个单位的任何一个达到了性能上限，都会成为IO的瓶颈。从机械硬盘的结构考虑，如果读写是顺序读写，那么IO的表现是可以通过比较少的IOPS达到较大的带宽，因为可以合并很多IO，也可以通过预读等方式加速数据读取效率。当IO的表现是偏向于随机读写的时候，那么IOPS就会变得更大，IO的请求的合并可能性下降，当每次io请求数据越少的时候，带宽表现就会越低。从这里我们可以理解，针对进程的IO资源的主要表现形式有两个：进程在单位时间内提交的IO请求个数和进程占用IO的带宽。其实无论哪个，都是跟进程分配的IO处理时间长度紧密相关的。有时业务可以在较少IOPS的情况下占用较大带宽，另外一些则可能在较大IOPS的情况下占用较少带宽，所以对进程占用IO的时间进行调度才是相对最公平的。即，我不管你是IOPS高还是带宽占用高，到了时间咱就换下一个进程处理，你爱咋样咋样。所以，cfq就是试图给所有进程分配等同的块设备使用的时间片，进程在时间片内，可以将产生的IO请求提交给块设备进行处理，时间片结束，进程的请求将排进它自己的队列，等待下次调度的时候进行处理。这就是cfq的基本原理。当然，现实生活中不可能有真正的“公平”，常见的应用场景下，我们很肯能需要人为的对进程的IO占用进行人为指定优先级，这就像对进程的CPU占用设置优先级的概念一样。所以，除了针对时间片进行公平队列调度外，cfq还提供了优先级支持。每个进程都可以设置一个IO优先级，cfq会根据这个优先级的设置情况作为调度时的重要参考因素。优先级首先分成三大类：RT、BE、IDLE，它们分别是实时（RealTime）、最佳效果（BestTry）和闲置（Idle）三个类别，对每个类别的IO，cfq都使用不同的策略进行处理。另外，RT和BE类别中，分别又再划分了8个子优先级实现更细节的QOS需求，而IDLE只有一个子优先级。另外，我们都知道内核默认对存储的读写都是经过缓存（buffer/cache）的，在这种情况下，cfq是无法区分当前处理的请求是来自哪一个进程的。只有在进程使用同步方式（syncread或者syncwirte）或者直接IO（DirectIO）方式进行读写的时候，cfq才能区分出IO请求来自哪个进程。所以，除了针对每个进程实现的IO队列以外，还实现了一个公共的队列用来处理异步请求。当前内核已经实现了针对IO资源的cgroup资源隔离，所以在以上体系的基础上，cfq也实现了针对cgroup的调度支持。总的来说，cfq用了一系列的数据结构实现了以上所有复杂功能的支持，大家可以通过源代码看到其相关实现，文件在源代码目录下的block/cfq-iosched.c。1.1cfq设计原理在此，我们对整体数据结构做一个简要描述：首先，cfq通过一个叫做cfq_data的数据结构维护了整个调度器流程。在一个支持了cgroup功能的cfq中，全部进程被分成了若干个contralgroup进行管理。每个cgroup在cfq中都有一个cfq_group的结构进行描述，所有的cgroup都被作为一个调度对象放进一个红黑树中，并以vdisktime为key进行排序。vdisktime这个时间纪录的是当前cgroup所占用的io时间，每次对cgroup进行调度时，总是通过红黑树选择当前vdisktime时间最少的cgroup进行处理，以保证所有cgroups之间的IO资源占用“公平”。当然我们知道，cgroup是可以对blkio进行资源比例分配的，其作用原理就是，分配比例大的cgroup占用vdisktime时间增长较慢，分配比例小的vdisktime时间增长较快，快慢与分配比例成正比。这样就做到了不同的cgroup分配的IO比例不一样，并且在cfq的角度看来依然是“公平“的。选择好了需要处理的cgroup（cfq_group）之后，调度器需要决策选择下一步的service_tree。service_tree这个数据结构对应的都是一系列的红黑树，主要目的是用来实现请求优先级分类的，就是RT、BE、IDLE的分类。每一个cfq_group都维护了7个service_trees，其定义如下：其中service_tree_idle就是用来给IDLE类型的请求进行排队用的红黑树。而上面二维数组，首先第一个维度针对RT和BE分别各实现了一个数组，每一个数组中都维护了三个红黑树，分别对应三种不同子类型的请求，分别是：SYNC、SYNC_NOIDLE以及ASYNC。我们可以认为SYNC相当于SYNC_IDLE并与SYNC_NOIDLE对应。idling是cfq在设计上为了尽量合并连续的IO请求以达到提高吞吐量的目的而加入的机制，我们可以理解为是一种“空转”等待机制。空转是指，当一个队列处理一个请求结束后，会在发生调度之前空等一小会时间，如果下一个请求到来，则可以减少磁头寻址，继续处理顺序的IO请求。为了实现这个功能，cfq在service_tree这层数据结构这实现了SYNC队列，如果请求是同步顺序请求，就入队这个servicetree，如果请求是同步随机请求，则入队SYNC_NOIDLE队列，以判断下一个请求是否是顺序请求。所有的异步写操作请求将入队ASYNC的servicetree，并且针对这个队列没有空转等待机制。此外，cfq还对SSD这样的硬盘有特殊调整，当cfq发现存储设备是一个ssd硬盘这样的队列深度更大的设备时，所有针对单独队列的空转都将不生效，所有的IO请求都将入队SYNC_NOIDLE这个servicetree。每一个servicetree都对应了若干个cfq_queue队列，每个cfq_queue队列对应一个进程，这个我们后续再详细说明。cfq_group还维护了一个在cgroup内部所有进程公用的异步IO请求队列，其结构如下：异步请求也分成了RT、BE、IDLE这三类进行处理，每一类对应一个cfq_queue进行排队。BE和RT也实现了优先级的支持，每一个类型有IOPRIO_BE_NR这么多个优先级，这个值定义为8，数组下标为0-7。我们目前分析的内核代码版本为Linux4.4，可以看出，从cfq的角度来说，已经可以实现异步IO的cgroup支持了，我们需要定义一下这里所谓异步IO的含义，它仅仅表示从内存的buffer/cache中的数据同步到硬盘的IO请求，而不是aio(man7aio)或者linux的native异步io以及lio机制，实际上这些所谓的“异步”IO机制，在内核中都是同步实现的（本质上冯诺伊曼计算机没有真正的“异步”机制）。我们在上面已经说明过，由于进程正常情况下都是将数据先写入buffer/cache，所以这种异步IO都是统一由cfq_group中的async请求队列处理的。那么为什么在上面的service_tree中还要实现和一个ASYNC的类型呢？这当然是为了支持区分进程的异步IO并使之可以“完全公平”做准备喽。实际上在最新的cgroupv2的blkio体系中，内核已经支持了针对bufferIO的cgroup限速支持，而以上这些可能容易混淆的一堆类型，都是在新的体系下需要用到的类型标记。新体系的复杂度更高了，功能也更加强大，但是大家先不要着急，正式的cgroupv2体系，在Linux4.5发布的时候会正式跟大家见面。我们继续选择service_tree的过程，三种优先级类型的service_tree的选择就是根据类型的优先级来做选择的，RT优先级最高，BE其次，IDLE最低。就是说，RT里有，就会一直处理RT，RT没了再处理BE。每个service_tree对应一个元素为cfq_queue排队的红黑树，而每个cfq_queue就是内核为进程（线程）创建的请求队列。每一个cfq_queue都会维护一个rb_key的变量，这个变量实际上就是这个队列的IO服务时间（servicetime）。这里还是通过红黑树找到servicetime时间最短的那个cfq_queue进行服务，以保证“完全公平”。选择好了cfq_queue之后，就要开始处理这个队列里的IO请求了。这里的调度方式基本跟deadline类似。cfq_queue会对进入队列的每一个请求进行两次入队，一个放进fifo中，另一个放进按访问扇区顺序作为key的红黑树中。默认从红黑树中取请求进行处理，当请求的延时时间达到deadline时，就从红黑树中取等待时间最长的进行处理，以保证请求不被饿死。这就是整个cfq的调度流程，当然其中还有很多细枝末节没有交代，比如合并处理以及顺序处理等等。1.2cfq的参数调整理解整个调度流程有助于我们决策如何调整cfq的相关参数。所有cfq的可调参数都可以在/sys/class/block/sda/queue/iosched/目录下找到，当然，在你的系统上，请将sda替换为相应的磁盘名称。我们来看一下都有什么：这些参数部分是跟机械硬盘磁头寻道方式有关的，如果其说明你看不懂，请先补充相关知识：back_seek_max:磁头可以向后寻址的最大范围，默认值为16M。back_seek_penalty:向后寻址的惩罚系数。这个值是跟向前寻址进行比较的。以上两个是为了防止磁头寻道发生抖动而导致寻址过慢而设置的。基本思路是这样，一个io请求到来的时候，cfq会根据其寻址位置预估一下其磁头寻道成本。设置一个最大值back_seek_max，对于请求所访问的扇区号在磁头后方的请求，只要寻址范围没有超过这个值，cfq会像向前寻址的请求一样处理它。再设置一个评估成本的系数back_seek_penalty，相对于磁头向前寻址，向后寻址的距离为1/2(1/back_seek_penalty)时，cfq认为这两个请求寻址的代价是相同。这两个参数实际上是cfq判断请求合并处理的条件限制，凡事复合这个条件的请求，都会尽量在本次请求处理的时候一起合并处理。fifo_expire_async:设置异步请求的超时时间。同步请求和异步请求是区分不同队列处理的，cfq在调度的时候一般情况都会优先处理同步请求，之后再处理异步请求，除非异步请求符合上述合并处理的条件限制范围内。当本进程的队列被调度时，cfq会优先检查是否有异步请求超时，就是超过fifo_expire_async参数的限制。如果有，则优先发送一个超时的请求，其余请求仍然按照优先级以及扇区编号大小来处理。fifo_expire_sync:这个参数跟上面的类似，区别是用来设置同步请求的超时时间。slice_idle:参数设置了一个等待时间。这让cfq在切换cfq_queue或servicetree的时候等待一段时间，目的是提高机械硬盘的吞吐量。一般情况下，来自同一个cfq_queue或者servicetree的IO请求的寻址局部性更好，所以这样可以减少磁盘的寻址次数。这个值在机械硬盘上默认为非零。当然在固态硬盘或者硬RAID设备上设置这个值为非零会降低存储的效率，因为固态硬盘没有磁头寻址这个概念，所以在这样的设备上应该设置为0，关闭此功能。group_idle:这个参数也跟上一个参数类似，区别是当cfq要切换cfq_group的时候会等待一段时间。在cgroup的场景下，如果我们沿用slice_idle的方式，那么空转等待可能会在cgroup组内每个进程的cfq_queue切换时发生。这样会如果这个进程一直有请求要处理的话，那么直到这个cgroup的配额被耗尽，同组中的其它进程也可能无法被调度到。这样会导致同组中的其它进程饿死而产生IO性能瓶颈。在这种情况下，我们可以将slice_idle＝0而group_idle＝8。这样空转等待就是以cgroup为单位进行的，而不是以cfq_queue的进程为单位进行，以防止上述问题产生。low_latency:这个是用来开启或关闭cfq的低延时（lowlatency）模式的开关。当这个开关打开时，cfq将会根据target_latency的参数设置来对每一个进程的分片时间（slicetime）进行重新计算。这将有利于对吞吐量的公平（默认是对时间片分配的公平）。关闭这个参数（设置为0）将忽略target_latency的值。这将使系统中的进程完全按照时间片方式进行IO资源分配。这个开关默认是打开的。我们已经知道cfq设计上有“空转”（idling）这个概念，目的是为了可以让连续的读写操作尽可能多的合并处理，减少磁头的寻址操作以便增大吞吐量。如果有进程总是很快的进行顺序读写，那么它将因为cfq的空转等待命中率很高而导致其它需要处理IO的进程响应速度下降，如果另一个需要调度的进程不会发出大量顺序IO行为的话，系统中不同进程IO吞吐量的表现就会很不均衡。就比如，系统内存的cache中有很多脏页要写回时，桌面又要打开一个浏览器进行操作，这时脏页写回的后台行为就很可能会大量命中空转时间，而导致浏览器的小量IO一直等待，让用户感觉浏览器运行响应速度变慢。这个low_latency主要是对这种情况进行优化的选项，当其打开时，系统会根据target_latency的配置对因为命中空转而大量占用IO吞吐量的进程进行限制，以达到不同进程IO占用的吞吐量的相对均衡。这个开关比较合适在类似桌面应用的场景下打开。target_latency:当low_latency的值为开启状态时，cfq将根据这个值重新计算每个进程分配的IO时间片长度。quantum:这个参数用来设置每次从cfq_queue中处理多少个IO请求。在一个队列处理事件周期中，超过这个数字的IO请求将不会被处理。这个参数只对同步的请求有效。slice_sync:当一个cfq_queue队列被调度处理时，它可以被分配的处理总时间是通过这个值来作为一个计算参数指定的。公式为：time_slice=slice_sync+(slice_sync/5*(4-prio))。这个参数对同步请求有效。slice_async:这个值跟上一个类似，区别是对异步请求有效。slice_async_rq:这个参数用来限制在一个slice的时间范围内，一个队列最多可以处理的异步请求个数。请求被处理的最大个数还跟相关进程被设置的io优先级有关。1.3cfq的IOPS模式我们已经知道，默认情况下cfq是以时间片方式支持的带优先级的调度来保证IO资源占用的公平。高优先级的进程将得到的时间片长度，而低优先级的进程时间片相对较小。当我们的存储是一个高速并且支持NCQ（原生指令队列）的设备的时候，我们最好可以让其可以从多个cfq队列中处理多路的请求，以便提升NCQ的利用率。此时使用时间片的分配方式分配资源就显得不合时宜了，因为基于时间片的分配，同一时刻最多能处理的请求队列只有一个。这时，我们需要切换cfq的模式为IOPS模式。切换方式很简单，就是将slice_idle=0即可。内核会自动检测你的存储设备是否支持NCQ，如果支持的话cfq会自动切换为IOPS模式。另外，在默认的基于优先级的时间片方式下，我们可以使用ionice命令来调整进程的IO优先级。进程默认分配的IO优先级是根据进程的nice值计算而来的，计算方法可以在manionice中看到，这里不再废话。2、deadline：最终期限调度deadline调度算法相对cfq要简单很多。其设计目标是：在保证请求按照设备扇区的顺序进行访问的同时，兼顾其它请求不被饿死，要在一个最终期限前被调度到。我们知道磁头对磁盘的寻道是可以进行顺序访问和随机访问的，因为寻道延时时间的关系，顺序访问时IO的吞吐量更大，随机访问的吞吐量小。如果我们想为一个机械硬盘进行吞吐量优化的话，那么就可以让调度器按照尽量复合顺序访问的IO请求进行排序，之后请求以这样的顺序发送给硬盘，就可以使IO的吞吐量更大。但是这样做也有另一个问题，就是如果此时出现了一个请求，它要访问的磁道离目前磁头所在磁道很远，应用的请求又大量集中在目前磁道附近。导致大量请求一直会被合并和插队处理，而那个要访问比较远磁道的请求将因为一直不能被调度而饿死。deadline就是这样一种调度器，能在保证IO最大吞吐量的情况下，尽量使远端请求在一个期限内被调度而不被饿死的调度器。
3. java 中 阻塞队列 非阻塞队列 和普通队列的区别是什么
阻塞队列与普通队列的区别在于，当队列是空的时，从队列中获取元素的操作将会被阻塞，或者当队列是满时，往队列里添加元素的操作会被阻塞。试图从空的阻塞队列中获取元素的线程将会被阻塞，直到其他的线程往空的队列插入新的元素。同样，试图往已满的阻塞队列中添加新元素的线程同样也会被阻塞，直到其他的线程使队列重新变得空闲起来，如从队列中移除一个或者多个元素，或者完全清空队列.
1.ArrayDeque, （数组双端队列）
2.PriorityQueue, （优先级队列）
3.ConcurrentLinkedQueue, （基于链表的并发队列）
4.DelayQueue, （延期阻塞队列）（阻塞队列实现了BlockingQueue接口）
5.ArrayBlockingQueue, （基于数组的并发阻塞队列）
6.LinkedBlockingQueue, （基于链表的FIFO阻塞队列）
7.LinkedBlockingDeque, （基于链表的FIFO双端阻塞队列）
8.PriorityBlockingQueue, （带优先级的无界阻塞队列）
9.SynchronousQueue （并发同步阻塞队列）
阻塞队列和生产者-消费者模式
阻塞队列（Blocking queue）提供了可阻塞的put和take方法，它们与可定时的offer和poll是等价的。如果Queue已经满了，put方法会被阻塞直到有空间可用；如果Queue是空的，那么take方法会被阻塞，直到有元素可用。Queue的长度可以有限，也可以无限；无限的Queue永远不会充满，所以它的put方法永远不会阻塞。
阻塞队列支持生产者-消费者设计模式。一个生产者-消费者设计分离了“生产产品”和“消费产品”。该模式不会发现一个工作便立即处理，而是把工作置于一个任务（“to do”）清单中，以备后期处理。生产者-消费者模式简化了开发，因为它解除了生产者和消费者之间相互依赖的代码。生产者和消费者以不同的或者变化的速度生产和消费数据，生产者-消费者模式将这些活动解耦，因而简化了工作负荷的管理。
生产者-消费者设计是围绕阻塞队列展开的，生产者把数据放入队列，并使数据可用，当消费者为适当的行为做准备时会从队列中获取数据。生产者不需要知道消费者的省份或者数量，甚至根本没有消费者—它们只负责把数据放入队列。类似地，消费者也不需要知道生产者是谁，以及是谁给它们安排的工作。BlockingQueue可以使用任意数量的生产者和消费者，从而简化了生产者-消费者设计的实现。最常见的生产者-消费者设计是将线程池与工作队列相结合。
阻塞队列简化了消费者的编码，因为take会保持阻塞直到可用数据出现。如果生产者不能足够快地产生工作，让消费者忙碌起来，那么消费者只能一直等待，直到有工作可做。同时，put方法的阻塞特性也大大地简化了生产者的编码；如果使用一个有界队列，那么当队列充满的时候，生产者就会阻塞，暂不能生成更多的工作，从而给消费者时间来赶进进度。
有界队列是强大的资源管理工具，用来建立可靠的应用程序：它们遏制那些可以产生过多工作量、具有威胁的活动，从而让你的程序在面对超负荷工作时更加健壮。
虽然生产者-消费者模式可以把生产者和消费者的代码相互解耦合，但是它们的行为还是间接地通过共享队列耦合在一起了
类库中包含一些BlockingQueue的实现，其中LinkedBlockingQueue和ArrayBlockingQueue是FIFO队列，与 LinkedList和ArrayList相似，但是却拥有比同步List更好的并发性能。PriorityBlockingQueue是一个按优先级顺序排序的队列，当你不希望按照FIFO的属性处理元素时，这个PriorityBolckingQueue是非常有用的。正如其他排序的容器一样，PriorityBlockingQueue可以比较元素本身的自然顺序（如果它们实现了Comparable），也可以使用一个 Comparator进行排序。
最后一个BlockingQueue的实现是SynchronousQueue，它根本上不是一个真正的队列，因为它不会为队列元素维护任何存储空间。不过，它维护一个排队的线程清单，这些线程等待把元素加入（enqueue）队列或者移出（dequeue）队列。因为SynchronousQueue没有存储能力，所以除非另一个线程已经准备好参与移交工作，否则put和take会一直阻止。SynchronousQueue这类队列只有在消费者充足的时候比较合适，它们总能为下一个任务作好准备。
非阻塞算法
基于锁的算法会带来一些活跃度失败的风险。如果线程在持有锁的时候因为阻塞I/O，页面错误，或其他原因发生延迟，很可能所有的线程都不能前进了。
一个线程的失败或挂起不应该影响其他线程的失败或挂起，这样的算法成为非阻塞（nonblocking）算法；如果算法的每一个步骤中都有一些线程能够继续执行，那么这样的算法称为锁自由（lock-free）算法。在线程间使用CAS进行协调，这样的算法如果能构建正确的话，它既是非阻塞的，又是锁自由的。非竞争的CAS总是能够成功，如果多个线程以一个CAS竞争，总会有一个胜出并前进。非阻塞算法堆死锁和优先级倒置有“免疫性”（但它们可能会出现饥饿和活锁，因为它们允许重进入）。
非阻塞算法通过使用低层次的并发原语，比如比较交换，取代了锁。原子变量类向用户提供了这些底层级原语，也能够当做“更佳的volatile变量”使用，同时提供了整数类和对象引用的原子化更新操作
4. Laravel 如何同时使用不同数据库驱动
queue配置
首先说明一下我之前的项目中如何使用queue的。
我们现在的项目都是用的symfony，老一点的项目用的symfony1poser/vendor/bin 加入到环境变量中。
source ~/.bash_profile 就可以直接在命令行中使用laravel了。试一下。
laravel -V 能够看到下面的，就代表成功了。
Laravel Installer version 1.2.1 2、创建项目。
laravel new guagua 3、配置redis和queue。
4、创建controller，
php artisan make:controller DefaultController 在controller的action中push100个queue的任务。
for($i = 0; $i < 100; $i ++) { Queue::push(new SendEmail("ssss".$i)); } 5、创建queue的Command
php artisan make:command SendEmail --queued 修改app/Commands/SendEmail.php，添加一个私有变量。
protected $msg; 同时修改构造函数。
public function __construct($msg) { $this->msg = $msg; } 再修改的handle方法
public function handle() { sleep(4); echo $this->msg."\t".date("Y-m-d H:i:s")."\n"; $this->delete(); } 6、修改routes
Route::get('/', [ 'as' => 'index', 'uses' => 'DefaultController@index' ]); 7、监听queue
php artisan queue:listen 为了验证多任务处理，我们同时开三个窗口运行同样的命令。
8、用laravel内建的server启动服务
php artisan serve --port 8080 打开浏览器，访问localhost:8080/页面。当然也可以用nginx，apache之类的。但是需要各种配置，还是内建的使用方便。
在控制台就能看到各个queue执行的情况了，如下图。可以看到100个任务被三个work平分了。
到此，基本达到了我想要的效果。验证了laravel可以简单实现queue，并且可以多任务处理。
make command生成的代码中use App\Commands\Command ，但是运行时提示没有这个文件。 解决办法，修改为 use Illuminate\Console\Command; 不知道为什么会出现这个低级问题，难道是我mac系统问题，还是我的人品问题。
在controller的action中push队列的时候，没有异步执行，还是在action的脚本中执行的。 发现是配置问题，原来不仅仅要修改config中的queue.php，还要修改.evn中相关配置。 虽然问题解决了，但是还是觉得蛋疼，不能理解。还需要在学习学习laravel。
异步队列使用方法
1.配置
关于队列的定义，这里就不作介绍了。我们要使用异步队列就有两个关键：
（1）存储队列的地方
（2）执行任务的服务
打开 config/queue.php ，这是Laravel5关于队列的配置文件。首先我们可以通过 default 参数指定默认队列驱动，默认配置是 sync , 这是同步队列，我们要做异步队列首先就要改变这里。假设我们用 database 作为驱动，队列任务将会存放在数据库中，而我们后面会另外启动一个后台服务来处理队列任务，这就是异步方式了。
'default' => 'database' 修改完配置后，我们需要创建一个表来存放队列任务，Laravel5已经在自带artisan命令中内置了一个指令用来生成数据迁移，只需要两条命令即可，当然你得实现配置好数据库连接。
php artisan queue:table php artisan migrate 这样就自动在数据库中创建了 jobs 表。
2.启动队列监听服务
通过下面这条指令启动队列监听服务，它会自动处理 jobs 表中的队列任务：
php artisan queue:listen 在linux中，如果想让它在后台执行，可以这样：
nohup php artisan queue:listen & 3.添加队列任务
关于队列任务的添加，手册里说的比较详细，这里就简单举个例子吧。
首先，通过artisan创建一个队列命令：
php artisan make:command SendEmail --queued 这样会生成 app/Commands/SendEmail.php 这个类文件，这个类会被标识为队列命令，你可以在 handle 方法中写自己的业务逻辑。
在控制器中，可以简单通过 Bus::dispatch 分发任务:
Bus::dispatch(new \App\Commands\SendEmail()); 你会发现任务不会立即执行，而是被放到 jobs 表中，由队列监听服务处理。
更详细的用法建议参考 command bus 和 queue 相关的手册章节。
5. 为什么rabbit mq 本地服务器不能系统根据配置文件自动创建队列
一、WebSphere MQ命令行命令 1、停止队列管理器 endmqm [-z] [([-c -w -i -p] [-r] [-s]) -x] QMgrName endmqm mqm_name 使用默认选项停止队列管理器需要等待当前的应用连接完成并断开。 -i 立即停止队列管理器。 -w 需要等待所有的应用停止以后才会真正关闭队列管理器 -p 使用以上参数都无法正常停止队列管理器的情况下可以使用该参数 2、启动队列管理器 strmqm [-z] [-a -c -r -x] [-d noneminimalall] [-f] [-ns] QMgrName 队列管理器必须在完全停止时才能被启动。 3、创建队列管理器 crtmqm [-z] [-q] [-c Text] [-d DefXmitQ] [-h MaxHandles] [-md DataPath] [-g ApplicationGroup] [-t TrigInt] [-u DeadQ] [-x MaxUMsgs] [-lp LogPri] [-ls LogSec] [-lc -ll] [-lf LogFileSize] [-ld LogPath] QMgrName 队列管理器名大小写敏感且不支持空字符串，长度为48字节，同一网络中不能有重名。 创建队列管理器的时侯最好创建死信队列用于存放无法发送的信息，保证通道不会因为无法发送信息而被关闭。 crtmqm -u deadq_name mqm_name 4、删除队列管理器 dltmqm [-z] QMgrName 删除队列管理器会完全删除其所拥有的对象和相关信息，并且是不可恢复的。要删除一个队列管理器首先要保证他是停止的。 二、WebSphere MQ Script. (MQSC) commands WebSphere MQ Script. (MQSC) commands是常常用来管理队列管理器对象的。这些对象包括队列管理器本身，队列，名称列表，通道，客户端通道，监听，服务等。使用runmqsc 队列管理名来启动，可以运行单个的命令，也可以通过命令集的脚本来运行。 本地队列管理器的作用是接收远程或本地的信息流，并将本地队列中的信息流取出以供应用程序使用。在做这些工作之前需要定义相关的队列管理器，队列和通道等，而这些工作是由WebSphere MQ Script. (MQSC) commands来完整的。在Windows及Linux环境下也可以通过WebSphere MQ Explorer来完成。 启动WebSphere MQ Script. (MQSC) ：runmqsc [-e] [-v] [-w WaitTime [-x] [-m LocalQMgrName]] [QMgrName] runmqsc mqm_name。通过命令runmqsc启动队列管理器的命令服务器。WebSphere MQ Explorer也能完成相同的任务。runmqsc的相关命令有三种运行方式，Verify a command without running it，Run a command on a local queue manager，Run a command on a remote queue manager。runmqsc的相关命令在解释的时候都会以大写来解释，比如DEFINE，ALTER，RESET等。但是这些命令并不是大小写敏感的。每行runmqsc命令最长只能到8个字符，可以通过-或者+连接下一行，-是从下一行的第一个字符开始，+是从下一行的第一个非空字符开始。而且所有命令与平台无关。runmqsc的标准输入是键盘，标准输出时屏幕，我们可以通过<，>重定向。例如从脚本输入命令runmqsc </path/filename.in，将结果重定向到文件runmqsc>/path/filename.out。 1、显示队列管理器属性（DISPLAY QMGR）： DISPLAY QMGR显示当前队列管理器的所有属性，也可以使用DISPLAY QMGR 属性名，单独查看当前队列管理器的某个特定属性。 2、 更改队列管理器属性（ALTER QMGR ）： ALTER QMGR 用于更改队列管理器的相关属性，例如 ALTER QMGR MAXHANDS(255)，这个命令将默认队列管理器的MAXHANDS由256更改为255。 3、创建本地队列（DEFINE QLOCAL ）： DEFINE QLOCAL Q_LOCAL_NAME，在创建队列的时候可以定义相关属性的值，如果没有定义则使用默认值。也可以全部使用默认值，最后通过ALTER QLOCAL命令来修改相关属性。在同一个队列管理器中不能有同名的队列，可以使用REPLACE关键字重建已有的队列。 4、修改本地队列属性（ALTER QLOCAL）： ALTER QLOCAL Q_LOCAL_NAME NEW_ATTRIBUTE。已经定义了的本地队列可以使用ALTER QLOCAL 命令对其属性进行修改。 5、显示本地队列属性（DISPLAY QLOCAL）： DISPLAY QLOCAL Q_LOCAL_NAME ATTRIBUTE。此命令用于显示本地队列的属性，可以使用默认的显示全部属性，也可以显示指定的属性。 6、复制本地队列（DEFINE QLOCAL NEW LIKE OLD)： DEFINE QLOCAL NEW LIKE OLD。此命令可以创建一个属性与OLD完全一样的本地队列。当然，我们也可以在语句后面指定属性的详细信息，没有指定的则继承OLD的对应属性，指定了的则使用新的属性。 7、清除本地队列中的消息（CLEAR QLOCAL）： CLEAR QLOCAL Q_LOCAL_QUEUE。此命令用于清除本地队列中存储的信息。在清除信息的时候系统不会给出任何提示，而是直接把信息删除。在一下两种情况下不能使用CLEAR QLOCAL，本地队列中存储的有在最近一次队列同步以后未提交的信息，有应用程序打开使用本地此队列。 8、删除本地队列（DELETE QLOCAL）： DELETE QLOCAL Q_LOCAL_QUEUE。此命令用于删除本地队列，当本地队列中存在有没有提交的数据此队列不能删除。如果队列中存在数据，且数据是提交了的，可以使用PURGE关键字删除本地队列。例如DELETE QLOCAL (Q_LOCAL_QUEUE) PURGE，在删除的时候可以指定NOPURGE关键字代替PURGE以保护删除的队列中可能存在的已提交数据。 三、PCF commands PCF commands允许管理员通过编程的方式将MQ的日常管理任务集成在程序中。包括创建队列，预定义队列，更改队列管理器等， PCF commands与MQSC锁实现的功能是相同。
6. 如何实现ring buffer
消息驱动机制是 GUI 系统的基础，消息驱动的底层基础设施之一是消息队列，它是整个 GUI
系统运转中枢，本文介绍了一个基于环形队列的消息队列实现方法，给出了它的数据结构、主要操作流程和核心代码。
环形队列
环行队列是一种首尾相连的队列数据结构，遵循先进先出原则，如下图所示：
ring buffer
示意图
在环形队列中用一组连续地址的存储单元依次存放从队列头到队列尾的元素，通过两个指针
read_pos 和 write_pos 分别指向读取位置和写入位置。
初始化队列时，令 read_pos = write_pos = 0，每当写入一个新元素时，
write_pos 增 1；每当读取一个元素时，read_pos 增 1 。若队列已满，不能往队列写入数据；若队列为空，则不能读取数据。判断对列是否为满的的方法是看 (write_pos + 1)% QUEUE_SIZE == read_pos
是否成立，判断队列是否为空的方法是看 write_pos == read_pos 是否成立。
鉴于多个线程同时访问环形队列，需要考虑线程之间的互斥和同步问题，拟采用锁控制多个线程互斥访问环形队列，使用信号量控制线程之间的同步。
一段时间内只能有一个线程获得锁，当它持有锁时，其它线程要访问环形队列必须等待，直到前者释放锁。由此，锁可以保证多个线程互斥的访问环形队列。
线程从队列对数据前首先判断信号量是否大于 1
，若是，则从队列读数据；否则，进入等待状态，直到信号量大于 1 为止；线程往队列写入一个数据后，会将信号量增 1
，若有线程在等待，则会被唤醒。由此，信号量实现了多线程同步访问环形队列。
流程图
下图是环形缓冲区的初始化、读数据、写数据的主要流程。
ring buffer
流程图
初始化时为环形队列分配内存空间，并完成锁和信号量的初始化；
若往环形队列写数据，首先要获得锁， 若锁已被占用，则进入等待状态，否
则进一步去判断环形队列是否已满。若满了，则释放锁并返回；若队列未满，将 数据写入 write_pos 位置，write_pos 增 1，释放锁并将信号量增
1，表示 已写入一个数据；
若从环形队列读数据，首先判断信号量是否大于 1 ，若不是，则等待，否则
去获取锁，若锁已被占用，则等待，否则从 read_pos 位置读取数据，将 read_pos 增 1 ，释放锁，读取完毕。
数据结构
环形队列的数据结构如下所示：
typedef _MSG {
int message;
void* param;
} MSG;
typedef _MSGQUE {
pthread_mutex_t lock;
sem_t wait;
MSG* msg;
int size;
int read_ops;
int write_ops;
} MSGQUEUE;
环形队列包括如下数据：
lock：互斥锁；
wait：信号量
msg：指向数据区的指针；
size：环形队列数据最大个数；
read_ops：读取位置；
write_ops：写入位置。
队列初始化
初始化主要完成三个任务：
为环形队列分配内存；
初始化互斥锁，用 pthread_mutex_init
完成；
初始化信号量，用 sem_init
完成。
/* Create message queue */
_msg_queue = malloc (sizeof (MSGQUEUE));
/* init lock and sem */
pthread_mutex_init (&_msg_queue->lock, NULL);
sem_init (&_msg_queue->wait, 0, 0);
/* allocate message memory */
_msg_queue -> msg = malloc (sizeof(MSG) * nr_msg);
_msg_queue -> size = nr_msg;
写操作
如上面的流程图介绍，写操作主要包括如下几步： - 获取锁；
判断队列是否已满；
若没满，将数据写入 write_pos 处，将 write_pos 增 1，并判断
write_pos 是否越界；
释放锁，并将信号量增 1。
/* lock the message queue */
pthread_mutex_lock (_msg_queue->lock);
/* check if the queue is full. */
if ((_msg_queue->write_pos + 1)% _msg_queue->size == _msg_queue->read_pos) {
/* Message queue is full. */
pthread_mutex_unlock (_msg_queue->lock);
return;
}
/* write a data to write_pos. */
_msg_queue -> msg [write_pos] = *msg;
write_pos ++;
/* check if write_pos if overflow. */
if (_msg_queue->write_pos >= _msg_queue->size)
_msg_queue->write_pos = 0;
/* release lock */
pthread_mutex_unlock (_msg_queue->lock);
sem_post (_msg_queue->wait);
读操作
同理，读操作分如下几个步骤：
检查信号量；
获取锁；
判断队列是否为空；
若不为空，则读取 read_ops 处的数据，将 read_ops 增 1，并判断
read_pos 是否越界；
并释放锁。
sem_wait (_msg_queue->wait);
/* lock the message queue */
pthread_mutex_lock (_msg_queue->lock);
/* check if queue is empty */
if (_msg_queue->read_pos != _msg_queue->write_pos) {
msg = _msg_queue->msg + _msg_queue->read_pos;
/* read a data and check if read_pos is overflow */
_msg_queue->read_pos ++;
if (_msg_queue->read_pos >= _msg_queue->size)
_msg_queue->read_pos = 0;
return;
}
/* release lock*/
pthread_mutex_unlock (_msg_queue->lock);
7. 高分求助SQL存储过程详细分析，最好每句解释一下
ALTER procere [dbo].[wvsp_updateTaskStatus]
@ttype int,
@id int,
@status int // 这一段主要是定义存储过程需要的参数
as
begin 开始存储过程
if @ttype=0 // 开始判断 如果传进来的@ttype=0
begin //开始执行
if (@status=3) //如果(@status=3)
begin //开始执行函数
insert into tb_queuelog([type],mid,code,otherparams,created) //往表名为tb_queuelog的表插入数据，以上为要插入的字段
select @ttype,mid,code,otherparams,created
from tb_mergequeue
where id=@id //要插入字段的数据从表tb_mergequeue 搜索出来，与上表要插入的字段一一对应，搜索条件为：id=@id
delete from tb_mergequeue
where id=@id //删除tb_mergequeue表中where id=@id的字段
end //结束@status=3条件循环
else//如果(@status不等于3，进入另一个方法
update tb_mergequeue
set status=@status
where id=@id //更新tb_mergequeue的数据
end //结束(@status不等于3的条件循环
else if(@ttype=1) //如果 (@ttype=1 -- 页面同步任务
begin开始
if (@status=3)
begin
insert into tb_queuelog([type],mid,code,otherparams,created)
select @ttype,mid,code,otherparams,created
from tb_syncqueue
where id=@id
delete from tb_syncqueue
where id=@id
end
else
update tb_syncqueue
set status=@status
where id=@id
end
select @@rowcount //取得记录总数
end 结束存储过程
8. 队列中存取数据元素的原则是A.先进先出 B.后进先出 C.先进后出 D.随意进出
先进先出。
队列是先进先出的线性表。队列和栈一样，在实际程序的算法设计和计算机一些其他分支里，都有很多重要的应用，比如计算机操作系统对进程或作业的优先级调度算法，对离散事件的模拟算法，还有计算机主机和外部设备运行速度不匹配的问题解决等。
(8)不存储元素的同步队列扩展阅读：
注意事项：
使用顺序存储结构表示队列时，首先申请足够大的内存空间建立一个数组，除此之外，为了满足队列从队尾存入数据元素，从队头删除数据元素，还需要定义两个指针分别作为头指针和尾指针。
当有数据元素进入队列时，将数据元素存放到队尾指针指向的位置，然后队尾指针增加 1。当删除对头元素（即使想删除的是队列中的元素，也必须从队头开始一个个的删除）时，只需要移动头指针的位置就可以。
9. laravel自带队列和redis实现队列哪个效率高
Laravel 的队列只是一些用于操控队列的代码，跟后端具体的数据存储方式无关
Redis 就是数据存储的一种方式，还有 MySQL 等
默认的 Sync 就是同步队列其实并不是队列，它的作用就是把要在队列中执行的代码放到当前 PHP 线程中阻塞执行，因为 PHP 默认是单线程阻塞执行的，不执行完，就无法给用户浏览器返回结果
10. 到底什么是消息队列Java中如何实现消息队列
“消息队列”是在消息的传输过程中保存消息的容器。和我们学过的LinkedHashMap，TreeSet等一样，都是容器。既然是容器，就有有自己的特性，就像LinkedHashMap是以键值对存储。存取顺序不变。而消息队列，看到队列就可以知道。这个容器里面的消息是站好队的，一般遵从先进先出原则。
java中已经为我们封装好了很多的消息队列。在java 1.5版本时推出的java.util.concurrent中有很多现成的队列供我们使用。特性繁多，种类齐全。是你居家旅游开发必备QAQ。
下面简单列举这个包中的消息队列
:阻塞队列 BlockingQueue
数组阻塞队列 ArrayBlockingQueue
延迟队列 DelayQueue
链阻塞队列 LinkedBlockingQueue
具有优先级的阻塞队列 PriorityBlockingQueue
同步队列 SynchronousQueue
阻塞双端队列 BlockingDeque
链阻塞双端队列 LinkedBlockingDeque
不同的队列不同的特性决定了队列使用的时机，感兴趣的话你可以详细了解。具体的使用方式我就不赘述了