如果对队列还有些疑问的可以线看一看我上一个博客：用Java描述数据结构之栈和队列，以及栈和队列的常用方法

当我们只有一段固定大小空间去存一个队列时像这样：


Front是队首，Rear是队尾，很明显这个空间已经满了，现在依次删除队首元素：


可以发现随着队列内元素越来越少，没有用到的空间越来越大，且总空间大小不变，所以说到最后这段空间就算是废了。
为了让这段空间可持续利用，我们其实可以这样：





就是每次头删之后将队列中所有元素向前移，这就很好的解决了问题，完美的提升了空间的利用。可是，每头删一个元素都依次将后续元素前移这个操作无疑增加了时间复杂度。

所以为了降低时间复杂度我们可以设置一段检测队列大小和数组大小关系的代码，只有满足这个条件的时候在将有效数据依次前移，这样就不必每次头删都要前移，在一定程度上降低了时间复杂度。
当然还有另外一个方案解决，就是我们根本不必前移元素，只用改变以下头尾指针（就比喻为指针了）的用法，让队列在逻辑上看起来像个环就行了，这就是我们今天的主角——循环队列：


这是一个空队列，现在加入元素（下面环形队列图中的Rear指向有错，Rear应该指向队尾的下一个，就是空的第一个）：



继续加入：




现在队列满了，我们头删元素：



可以看到，我们头删之后队列既多出空间插入新的元素，也不必前移元素，那么怎么去实现逻辑上是个环的这个循环队列呢？其实只需更灵活的使用头尾指针就可以。
我们结合LeetCode第622题来看

LeetCode.622.

现在来讨论它的具体实现：
public class MyCircularQueue {
    //数组实现循环队列
    private int[] queueArray;
    //记录队首位置
    private int frontIndex;
    //记录队尾位置
    private int rearIndex;
    //记录队列长度
    private int size;

    //构造方法
    public MyCircularQueue(int k) {
        queueArray = new int[k];
        frontIndex = 0;
        rearIndex = 0;
        size = 0;
    }

    //插入新元素
    public boolean enQueue(int value) {
        if(size == queueArray.length){
            return false;
        }
            queueArray[rearIndex] = value;
            size++;
            rearIndex = (rearIndex + 1) % queueArray.length;
            return true;
    }

    //删除元素
    public boolean deQueue() {
        if (size == 0){
            return false;
        }
        frontIndex = (frontIndex + 1) % queueArray.length;
        size--;
        return  true;
    }

    //从队首获取元素，如果队列为空返回-1
    public int Front() {
        if(size == 0){
            return -1;
        }
        return queueArray[frontIndex];
    }
    //获取队尾元素，如果队列为空，返回-1
    public int Rear() {
        if(size == 0){
            return -1;
        }
        //rearIndex始终指向第一个空的下标，
        //所以要取队尾元素，就得取rearIndex前一个下标内的元素
        //为了防止rearIndex指向0号下标
        //做以下操作
        int index = (rearIndex - 1 + queueArray.length) % queueArray.length;
        return queueArray[index];
    }
    //判断队列是否为空
    public boolean isEmpty() {
        return size == 0;
    }
    //判断队列是否满
    public boolean isFull() {
        return size == queueArray.length;
    }
}


以上就是对循环及其实现的简单介绍，如果理解有偏差，还望看官在评论区指正，谢谢

一、是什么
JavaScript在设计之初便是单线程，即指程序运行时，只有一个线程存在，同一时间只能做一件事

为什么要这么设计，跟JavaScript的应用场景有关，JavaScript 初期作为一门浏览器脚本语言，通常用于操作 DOM ，如果是多线程，一个线程进行了删除 DOM ，另一个添加 DOM，此时浏览器该如何处理？
为了解决单线程运行阻塞问题，JavaScript用到了计算机系统的一种运行机制，这种机制就叫做事件循环（Event Loop）
事件循环（Event Loop）
在JavaScript中，所有的任务都可以分为
同步任务：立即执行的任务，同步任务一般会直接进入到主线程中执行
异步任务：异步执行的任务，比如ajax网络请求，setTimeout定时函数等
从上面我们可以看到，同步任务进入主线程，即主执行栈，异步任务进入任务队列，主线程内的任务执行完毕为空，会去任务队列读取对应的任务，推入主线程执行。上述过程的不断重复就是事件循环
二、宏任务与微任务

如果将任务划分为同步任务和异步任务并不是那么的准确，举个例子：
console.log(11)

setTimeout(()=>{
    console.log(22)
}, 0)

new Promise((resolve, reject)=>{
    console.log('new Promise')
    resolve()
}).then(()=>{
    console.log('then')
})

console.log(33)

如果按照上面流程图来分析代码，我们会得到下面的执行步骤：
console.log(11)，同步任务，主线程中执行
setTimeout() ，异步任务，放到 Event Table，0 毫秒后console.log(22)回调推入 Event Queue 中
new Promise ，同步任务，主线程直接执行
.then ，异步任务，放到 Event Table
console.log(33)，同步任务，主线程执行
所以按照分析，它的结果应该是 11 => 'new Promise' => 33 => 22 => 'then'

但是实际结果是：11=>'new Promise'=> 33 => 'then' => 22

出现分歧的原因在于异步任务执行顺序，事件队列其实是一个“先进先出”的数据结构，排在前面的事件会优先被主线程读取
例子中 setTimeout回调事件是先进入队列中的，按理说应该先于 .then 中的执行，但是结果却偏偏相反
原因在于异步任务还可以细分为微任务与宏任务
微任务
一个需要异步执行的函数，执行时机是在主函数执行结束之后、当前宏任务结束之前
常见的微任务有：
Promise.then

MutaionObserver

Object.observe（已废弃；Proxy 对象替代）

process.nextTick（Node.js）

宏任务
宏任务的时间粒度比较大，执行的时间间隔是不能精确控制的，对一些高实时性的需求就不太符合

常见的宏任务有：
script (可以理解为外层同步代码)
setTimeout/setInterval
UI rendering/UI事件
postMessage、MessageChannel
setImmediate、I/O（Node.js）

按照这个流程，它的执行机制是：
执行一个宏任务，如果遇到微任务就将它放到微任务的事件队列中

当前宏任务执行完成后，会查看微任务的事件队列，然后将里面的所有微任务依次执行完

回到上面的题目
console.log(1)
setTimeout(()=>{
    console.log(2)
}, 0)
new Promise((resolve, reject)=>{
    console.log('new Promise')
    resolve()
}).then(()=>{
    console.log('then')
})
console.log(3)

流程如下
// 遇到 console.log(1) ，直接打印 1
// 遇到定时器，属于新的宏任务，留着后面执行
// 遇到 new Promise，这个是直接执行的，打印 'new Promise'
// .then 属于微任务，放入微任务队列，后面再执行
// 遇到 console.log(3) 直接打印 3
// 好了本轮宏任务执行完毕，现在去微任务列表查看是否有微任务，发现 .then 的回调，执行它，打印 'then'
// 当一次宏任务执行完，再去执行新的宏任务，这里就剩一个定时器的宏任务了，执行它，打印 2

三、async与await
async 是异步的意思，await则可以理解为等待
放到一起可以理解async就是用来声明一个异步方法，而 await是用来等待异步方法执行
async
async函数返回一个promise对象，下面两种方法是等效的
function f() {
    return Promise.resolve('TEST');
}

// asyncF is equivalent to f!
async function asyncF() {
    return 'TEST';
}

await
正常情况下，await命令后面是一个 Promise对象，返回该对象的结果。如果不是 Promise对象，就直接返回对应的值
async function f(){
    // 等同于
    // return 123
    return await 123
}
f().then(v => console.log(v)) // 123
不管await后面跟着的是什么，await都会阻塞后面的代码

async function fn1 (){
    console.log(1)
    await fn2()
    console.log(2) // 阻塞
}

async function fn2 (){
    console.log('fn2')
}

fn1()
console.log(3)

上面的例子中，await 会阻塞下面的代码（即加入微任务队列），先执行 async外面的同步代码，同步代码执行完，再回到 async 函数中，再执行之前阻塞的代码
所以上述输出结果为：1，fn2，3，2

四、流程分析

通过对上面的了解，我们对JavaScript对各种场景的执行顺序有了大致的了解
这里直接上代码：
async function async1() {
    console.log('async1 start')
    await async2()
    console.log('async1 end')
}
async function async2() {
    console.log('async2')
}
console.log('script start')
setTimeout(function () {
    console.log('settimeout')
})
async1()
new Promise(function (resolve) {
    console.log('promise1')
    resolve()
}).then(function () {
    console.log('promise2')
})
console.log('script end')

分析过程：
执行整段代码，遇到 console.log(‘script start’) 直接打印结果，输出 script start

遇到定时器了，它是宏任务，先放着不执行

遇到 async1()，执行 async1 函数，先打印 async1 start，下面遇到await怎么办？先执行 async2，打印 async2，然后阻塞下面代码（即加入微任务列表），跳出去执行同步代码

跳到 new Promise 这里，直接执行，打印 promise1，下面遇到 .then()，它是微任务，放到微任务列表等待执行

最后一行直接打印 script end，现在同步代码执行完了，开始执行微任务，即 await下面的代码，打印 async1 end

继续执行下一个微任务，即执行 then 的回调，打印 promise2

上一个宏任务所有事都做完了，开始下一个宏任务，就是定时器，打印 settimeout
所以最后的结果是：script start、async1 start、async2、promise1、script end、async1 end、promise2、settimeout

一、引
JavaScript 最大特点，同时也是最大的缺点就是 单线程 ，这就导致了，同一个时间它只能做一件事。那么，为什么 JavaScript 不能有多个线程呢？这样能提高效率啊？其实我一开始也是很迷惑的。但是原因很简单：
JavaScript 的设计为单线程很大原因就是它是要对浏览器进行操作。作为浏览器脚本语言， JavaScript 的主要用途是与用户互动，以及操作DOM。这决定了它只能是单线程，否则会出现逻辑问题。比如，假定同时存在又两个线程，一个线程在某个DOM节点上添加内容，另一个线程删除节点上的内容，这时浏览器应该以哪个线程为准？
所以，为了避免复杂性，从一诞生， JavaScript 就是单线程，这已经成了这门语言的核心特征，将来也不会改变。
但是，在HTML5里提出Web Worker标准，允许 JavaScript 脚本创建多个线程，但是子线程完全受主线程控制，且不得操作DOM。导致这个新标准并没有改变 JavaScript 单线程的本质。
看个例子：接下来解答
console.log('start')
setTimeout(function(){
    console.log('hello world')
},0)
console.log('end')
// start
// end
// hello world

二、任务队列
由于 JavaScript 是单线程的，所以所有的任务都要进入队列进行排队，等待前一个任务结束了再执行下一个任务。这样就出现了问题，如果前任务“又臭又长”,那么后面的任务就得耐心的等下去。
任务常分为 IO 密集型和计算密集型。当任务是计算密集型那也还好，等的人无所谓。但是如果前任务是 IO 密集型，在等待键盘的输入完成或者在等到 AJAX 的回调结果。那么后面的任务就很难受了，看着 CPU 空闲着，就是不给你用。
于是 JavaScript 就把任务分为了俩种，同步任务和异步任务。这样的话，任务队列也就拆分成了 同步任务队列(主线程) 和 异步任务队列(任务队列)。在同步任务队列中，即是主线程上排队执行的任务，只有前一个任务执行完毕，才能执行后一个任务；在异步任务队列中的任务，只有"任务队列"通知主线程，某个异步任务可以执行了，该任务才会进入主线程执行。
总结下就是下面这样：
1.所有的同步任务形成一个执行栈。
2.任务队列放除了同步任务的异步任务，运行有结果了，就在任务队列中放一个通知事件。
3.执行栈运行完栈内任务，就去任务队列中读取通知事件，调入执行栈执行。
4.循环123，直至俩个队列全空。

在 JavaScript 中有这几种异步任务，会被放到任务队列
1.定时器
2.事件绑定
3.大部分的 AJAX（可这是为非异步）
4.回调函数

这里回答上面的问题，为什么是先打印出 end 后再打印出 hello world 呢，因为 setTimeout 是异步任务，读取这个任务的时候，会被直接存入任务队列，当执行栈中的任务执行完才会去执行任务队列中的任务，所以当俩个打印任务完成后，去读取任务队列中的定时任务，间隔为0秒，则立马打印出 hello world。不难…
三、事件循环
执行栈中执行 -> 执行栈空 -> 任务队列调取事件到执行栈 -> 执行栈执行 -> … -> 执行栈空、任务队列空。这个机制就是事件循环( Event Loop )

这张图来自网络。解释下其中的名词：
heap:堆:      (用来存常量、变量什么的)
stack:执行栈 
callback queue:回调队列

四、Node.js中的事件循环
在另一篇文章中详细解答了，可以查看。

Python 是一个设计优美的解释型高级语言，它提供了很多能让程序员感到舒适的功能特性。但有的时候 Python 的一些输出结果对于初学者来说似乎并不是那么一目了然。
GitHub 有个仓库收集 Python 中那些难以理解和鲜为人知的功能特性，并尝试讨论这些现象背后真正的原理!
虽然有些例子并不一定会让你觉得“卧槽”（WTF），但它们依然有可能会告诉你一些你所不知道的 Python 有趣特性。我觉得这是一种学习编程语言内部原理的好办法，而且我相信你也会从中获得乐趣!
如果你是一位经验比较丰富的 Python 程序员，你可以尝试挑战看是否能一次就找到例子的正确答案。你可能对其中的一些例子已经比较熟悉了，那这也许能唤起你当年踩这些坑时的甜蜜回忆。
for 循环怎么会事儿？
some_string = "wtf"
some_dict = {}
for i, some_dict[i] in enumerate(some_string):
    pass

Output:
>>> some_dict # 创建了索引字典.
{0: 'w', 1: 't', 2: 'f'}

说明:

Python 语法[1] 中对 for 的定义是:
for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]

其中 exprlist 指分配目标. 这意味着对可迭代对象中的每一项都会执行类似 {exprlist} = {next_value} 的操作.
一个有趣的例子说明了这一点:
for i in range(4):
    print(i)
    i = 10

Output:
0
1
2
3

你可曾觉得这个循环只会运行一次?
说明:
由于循环在Python中工作方式, 赋值语句 i = 10 并不会影响迭代循环, 在每次迭代开始之前, 迭代器(这里指 range(4)) 生成的下一个元素就被解包并赋值给目标列表的变量(这里指 i)了.

在每一次的迭代中, enumerate(some_string) 函数就生成一个新值 i (计数器增加) 并从 some_string 中获取一个字符. 然后将字典 some_dict 键 i (刚刚分配的) 的值设为该字符. 本例中循环的展开可以简化为:
>>> i, some_dict[i] = (0, 'w')
>>> i, some_dict[i] = (1, 't')
>>> i, some_dict[i] = (2, 'f')
>>> some_dict