go 协程池_go协程池使用

python多进程为什么一定要

import requests

不过特殊情况（特指IO密集型任务）下，多线程是比多进程好用的。

go 协程池_go协程池使用

go 协程池_go协程池使用

go 协程池_go协程池使用

举个例子：给你200W条，需要你把每个对应的页面抓取保存起来，这种时候，单单使用多进程，效果肯定是的。为task_list = []#这个list用于存放协程任务什么呢看

例如每次请求的等待时间是2秒，那么如下（忽略cpu计算时间）：

1、单进程+单线程：需要2秒200W=400W秒==1111.11个小时==46.3天，这个速度明显是不能接受的2、单进程+多线程：例如我们在这个进程中开了10个多线程，比1中能够提升10倍速度，也就是大约4.63天能够完成200W条抓取，请注意，这里的实际执行是：线程1遇见了阻塞，CPU切换到线程2去执行，遇见阻塞又切换到线程3等等，10个线程都阻塞后，这个进程就阻塞了，而直到某个线程阻塞完成后，这个进程才能继续执行，所以速度上提升大约能到10倍（这里忽略了线程切换带来的开销，实际上的提升应该是不能达到10倍的），但是需要考虑的是线程的切换也是有开销的，所以不能无限的启动多线程（开200W个线程肯定是不靠谱的）3、多进程+多线程：这里就厉害了，一般来说也有很多人用这个方法，多进程下，每个进程都能占一个cpu，而多线程从一定程度上绕过了阻塞的等待，所以比单进程下的多线程又更好使了，例如我们开10个进程，每个进程里开20W个线程，执行的速度理论上是比单进程开200W个线程快10倍以上的（为什么是10倍以上而不是10倍，主要是cpu切换200W个线程的消耗肯定比切换20W个进程大得多，考虑到这部分开销，所以是10倍以上）。

还有更好的方法吗看是肯定的，它就是：

4、协程，使用它之前我们先讲讲what/why/how（它是什么/为什么用它/怎么使用它）what：

协程是一种用户级的轻量级线程。协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈。因此：

在并发编程中，协程与线程类似，每个协程表示一个执行单元，有自己的本地数据，与其它协程共享全局数据和其它资源。

why：

所以最的方法，是多进程+协程（可以看作是每个进程里都是单线程，而这个单线程是协程化的）多进程+协程下，避开了CPU切换的开销，又能把多个CPU充分利用起来，这种方式对于数据量较大的爬虫还有文件读写之类的效率提升是巨大的。

小例子：

from gnt import monkey; monkey.patch_all()import sys

reload(sys)

sys.setdefaultencoding('utf8')

def fetch():

try:

s = requests.Session()

r = s.get(,timeout=1)#在这里抓取页面

except Exception,e:

print e

return ''

def process_start(tasks):

def task_start(filepath,flag = 100000):#每10W条启动一个进程with open(filepath,'r') as reader:#从给定的文件中读取 = reader.readline().strip()

i = 0 #计数器，记录添加了多少个到协程队列while !='':

task_list.append(gnt.spawn(fetch,,queue))#每次读取出，将任务添加到协程队列if i == flag:#一定数量的就启动一个进程并执行p = Process(target=process_start,args=(task_list,))p.start()

i = 0 #重置计数器

if task_list not []:#若退出循环后任务队列里还有剩余p = Process(target=process_start,args=(task_list,))#把剩余的全都放到这个进程来执行p.stalocal 成员的真实类型是一个 poolLocal 数组，localSize 是数组长度。这涉及到Pool实现，pool为每个P分配了一个对象，P数量设置为runtime.GOMAXPROCS(0)。在并发读写时，goroutine绑定的P有对象，先用自己的，没有去偷其它P的。go语言将数据分散在了各个真正运行的P中，降低了锁竞争，提高了并发能力。rt()

task_start('./testData.txt')#读取指定文件细心的同学会发现：上面的例子中隐藏了一个问题：进程的数量会随着数量的增加而不断增加，我们在这里不使用进程池multiprocessing.Pool来控制进程数量的原因是multiprocessing.Pool和gnt有冲突不能同时使用，但是有兴趣的同学可以研究一下gnt.pool这个协程池。

另外还有一个问题：每个进程处理的是累积的而不是的，例如个进程会处理10W个，第二个进程会变成20W个，以此类推。定位到问题是gnt.joinall()导致的问题，有兴趣的同学可以研究一下为什么会这样。不过这个问题的处理方案是：主进程只负责读取然后写入到list中，在创建子进程的时候直接把list传给子进程，由子进程自己去构建协程。这样就不会出现累加的问题

Golang-基于TimeingWheel定时器

from multiprocessing import Process

在linux下实现定时器主要有如下方式

task_list = [] #重置协程队列

在这当中 基于时间轮方式实现的定时器 时间复杂度最小，效率，然而我们可以通过 优先队列 实现时间轮定时器。

how:

优先队列的实现可以使用堆和最小堆，因此在队列中所有的数据都可以定义排序规则自动排序。我们直接通过队列中 pop 函数获取数据，就是我们按照自定义排序规则想要的数据。

在 Golang 中实现一个优先队列异常简单，在 container/head 包中已经帮我们封装了，实现的细节，我们只需要实现特定的接口就可以。

下面是提供的例子

因为优先队列底层数据结构是由二叉树构建的，所以我们可以通过数组来保存二叉树上的每一个。

timerType结构是定时任务抽象结构

首先的 start 函数，当创建一个 TimeingWheel 时，通过一个 goroutine 来执行 start ,在start中for循环和select来不同的channel的状态

通过for循环从队列中取数据，直到该队列为空或者是遇见个当前时间比任务开始时间大的任务， append 到 expired 中。因为优先队列中是根据 expiration 来排序的，

所以当取到个定时任务未到的任务时，表示该定时任务以后的任务都未到时间。

如果大于0 则，表示就生效。

防止外部滥用，阻塞定时器协程，框架又一次封装了timer这个包，名为 timer_wapper 这个包,它提供了两种调用方式。

参数和上面的参数一样，只是在第三个参数中使用了任务池，将定时任务放入了任务池中。定时任务的本身执行就是一个 put 作。

至于put以后，那就是 workers 这个包管理的了。在 worker 包中， 也就是维护了一个任务池，任务池中的任务会有序的执行，方便管理。

python多进程为什么一定要

golang HTTP作

不过特殊情况（特指IO密集型任务）下，多线程是比多进程好用的。

举个例子：给你200W条，需要你把每个对应的页面抓取保存起来，这种时候，单单使用多进程，效果肯定是的。为什么呢？

例如#-- coding=utf-8 --每次请求的等待时间golang HTTP作是2秒，那么如下（忽略cpu计算时间）：

1、单进程+单线程：需要2秒200W=400W秒==1111.11个小时==46.3天，这个速度明显是不能接受的2、单进程+多线程：例如我们在这个进程中开了10个多线程，比1中能够提升10倍速度，也就是大约4.63天能够完成200W条抓取，请注意，这里的实际执行是：线程1遇见了阻塞，CPU切换到线程2去执行，遇见阻塞又切换到线程3等等，10个线程都阻塞后，这个进程就阻塞了，而直到某个线程阻塞完成后，这个进程才能继续执行，所以速度上提升大约能到10倍（这里忽略了线程切换带来的开销，实际上的提升应该是不能达到10倍的），但是需要考虑的是线程的切换也是有开销的，所以不能无限的启动多线程（开200W个线程肯定是不靠谱的）3、多进程+多线程：这里就厉害了，一般来说也有很多人用这个方法，多进程下，每个进程都能占一个cpu，而多线程从一定程度上绕过了阻塞的等待，所以比单进程下的多线程又更好使了，例如我们开10个进程，每个进程里开20W个线程，执行的速度理论上是比单进程开200W个线程快10倍以上的（为什么是10倍以上而不是10倍，主要是cpu切换200W个线程的消耗肯定比切换20W个进程大得多，考虑到这部分开销，所以是10倍以上）。

还有更好的方法吗？是肯定的，它就是：

4、协程，使用它之前我们先讲讲what/why/how（它是什么/为什么用它/怎么使用它）what：

协程是一种用户级的轻量级线程。协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈。因此：

在并发编程中，协程与线程类似，每个协程表示一个执行单元，有自己的本地数据，与其它协程共享全局数据和其它资源。

why：

python里面怎么使用协程？是使用gnt，使用方法：看这里使用协程，可以不受线程开销的限制，我尝试过一次把20W条放在单进程的协程里执行，完全没问题。

所以最的方法，是多进程+协程（可以看作是每个进程里都是单线程，而这个单线程是协程化的）多进程+协程下，避开了CPU切换的开销，又能把多个CPU充分利用起来，这种方式对于数据量较大的爬虫还有文件读写之类的效率提升是巨大的。

小例子：

from gnt import monkey; monkey.patch_all()import sys

reload(sys)

sys.setdefaultencoding('utf8')

def fetch():

try:

s = requests.Session()

r = s.get(,timeout=1)#在这里抓取页面

except Exception,e:

print e

return ''

def process_start(tasks):

def task_start(filepath,flag = 100000):#每10W条启动一个进程with open(filepath,'r') as reader:#从给定的文件中读取 = reader.readline().strip()

i = 0 #计数器，记录添加了多少个到协程队列while !='':

task_list.append(gnt.spawn(fetch,,queue))#每次读取出，将任务添加到协程队列if i == flag:#一定数量的就启动一个进程并执行p = Process(target=process_start,args=(task_list,))p.start()

i = 0 #重置计数器

if task_list not []:#若退出循环后任务队列里还有剩余p = Process(target=process_start,args=(task_list,))#把剩余的全都放到这个进程来执行p.start()

task_start('./testData.txt')#读取指定文件细心的同学会发现：上面的例子中隐藏了一个问题：进程的数量会随着数量的增加而不断增加，我们在这里不使用进程池multiprocessing.Pool来控制进程数量的原因是multiprocessing.Pool和gnt有冲突不能同时使用，但是有兴趣的同学可以研究一下gnt.pool这个协程池。

另外还有一个问题：每个进程处理的是累积的而不是的，例如个进程会处理10W个，第二个进程会变成20W个，以此类推。定位到问题是gnt.joinall()导致的问题，有兴趣的同学可以研究一下为什么会这样。不过这个问题的处理方案是：主进程只负责读取然后写入到list中，在创建子进程的时候直接把list传给子进程，由子进程自己去构建协程。这样就不会出现累加的问题

python多进程为什么一定要

结论是这样的：

不过特殊情况（特指IO密集型任务）下，多线程是比多进程好用的。

因为协程是用户自己来编写调度逻辑的，对CPU来说，协程其实是单线程，所以CPU不用去考虑怎么调度、切换上下文，这就省去了CPU的切换开销，所以协程在一定程度上又好于多线程。

举个例子：给你200W条，需要你把每个对应的页面抓取保存起来，这种时候，单单使用多进程，效果肯定是的。为什么呢？

例如每次请求的等待时间是2秒，那么如下（忽略cpu计算时间）：

1、单进程+单线程：需要2秒200W=400W秒==1111.11个小时==46.3天，这个速度明显是不能接受的2、单进程+多线程：例如我们在这个进程中开了10个多线程，比1中能够提升10倍速度，也就是大约4.63天能够完成200W条抓取，请注意，这里的实际执行是：线程1遇见了阻塞，CPU切换到线程2去执行，遇见阻塞又切换到线程3等等，10个线程都阻塞后，这个进程就阻塞了，而直到某个线程阻塞完成后，这个进程才能继续执行，所以速度上提升大约能到10倍（这里忽略了线程切换带来的开销，实际上的提升应该是不能达到10倍的），但是需要考虑的是线程的切换也是有开销的，所以不能无限的启动多线程（开200W个线程肯定是不靠谱的）3、多进程+多线程：这里就厉害了，一般来说也有很多人用这个方法，多进程下，每个进程都能占一个cpu，而多线程从一定程度上绕过了阻塞的等待，所以比单进程下的多线程又更好使了，例如我们开10个进程，每个进程里开20W个线程，执行的速度理论上是比单进程开200W个线程快10倍以上的（为什么是10倍以上而不是10倍，主要是cpu切换200W个线程的消耗肯定比切换20W个进程大得多，考虑到这部分开销，所以是10倍以上）。

还有更好的方法吗？是肯定的，它就是：

4、协程，使用它之前我们先讲讲what/why/how（它是什么/为什么用它/怎么使用它）what：

协程是一种用户级的轻量级线程。协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈。因此：

在并发编程中，协程与线程类似，每个协程表示一个执行单元，有自己的本地数据，与其它协程共享全局数据和其它资源。

why：

python里面怎么使用协程？是使用gnt，使用方法：看这里使用协程，可以不受线程开销的限制，我尝试过一次把20W条放在单进程的协程里执行，完全没问题。

所以最的方法，是多进程+协程（可以看作是每个进程里都是单线程，而这个单线程是协程化的）多进程+协程下，避开了CPU切换的开销，又能把多个CPU充分利用起来，这种方式对于数据量较大的爬虫还有文件读写之类的效率提升是巨大的。

小例子：

from gnt import monkey; monkey.patch_all()import sys

reload(sys)

sys.setdefaultencoding('utf8')

def fetch():

try:

s = requests.Session()

r = s.get(,timeout=1)#在这里抓取页面

except Excep而且由于抢占式调度执行顺序无法确定的特点，使用线程时需要非常小心地处理同步问题，而协程完全不存在这个问题（驱动和异步程序也有同样的优点）。tion,e:

print e

return ''

def process_start(tasks):

def task_start(filepath,flag = 100000):#每10W条启动一个进程with open(filepath,'r') as reader:#从给定的文件中读取 = reader.readline().strip()

i = 0 #计数器，记录添加了多少个到协程队列while !='':

task_list.append(gnt.spawn(fetch,,queue))#每次读取出，将任务添加到协程队列if i == flag:#一定数量的就启动一个进程并执行p = Process(target=process_start,args=(task_list,))p.start()

i = 0 #重置计数器

if task_list not []:#若退出循环后任务队列里还有剩余p = Process(target=process_start,args=(task_list,))#把剩余的全都放到这个进程来执行p.start()

task_start('./testData.txt')#读取指定文件细心的同学会发现：上面的例子中隐藏了一个问题：进程的数量会随着数量的增加而不断增加，我们在这里不使用进程池multiprocessing.Pool来控制进程数量的原因是multiprocessing.Pool和gnt有冲突不能同时使用，但是有兴趣的同学可以研究一下gnt.pool这个协程池。

另外还有一个问题：每个进程处理的是累积的而不是的，例如个进程会处理10W个，第二个进程会变成20W个，以此类推。定位到问题是gnt.joinall()导致的问题，有兴趣的同学可以研究一下为什么会这样。不过这个问题的处理方案是：主进程只负责读取然后写入到list中，在创建子进程的时候直接把list传给子进程，由子进程自己去构建协程。这样就不会出现累加的问题

python中多进程+协程的使用以及为什么要用它

不管是进程还是线程，每次阻塞、切换都需要陷入系统调用( call)，先让CPU跑作系统的调度程序，然后再由调度程序决定该跑哪一个进程(线程)。

不过特殊情况（特指IO密集型任务）下，多线程是比多进程好用的。

举个例子：给你200W条，需要你把每个对应的页面抓取保存起来，这种时候，单单使用多进程，效果肯定是的。为什么呢？

例如每次请求的等待时间是2秒，那么如下（忽略cpu计算时间）：

1、单进程+单线程：需要2秒200W=400W秒==1111.11个小时==46.3天，这个速度明显是不能接受的

3、多进程+多线程：这里就厉害了，一般来说也有很多人用这个方法，多进程下，每个进程都能占一个cpu，而多线程从一定程度上绕过了阻塞的等待，所以比单进程下的多线程又更好使了，例如我们开10个进程，每个进程里开20W个线程，执行的速度理论上是比单进程开200W个线程快10倍以上的（为什么是10倍以上而不是10倍，主要是cpu切换200W个线程的消耗肯定比切换20W个进程大得多，考虑到这部分开销，所以是10倍以上）。

还有更好的方法吗？是肯定的，它就是：

4、协程，使用它之前我们先讲讲what/why/how（它是什么/为什么用它/怎么使用它）

what：

协程是一种用户级的轻量级线程。协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈。因此：

在并发编程中，协程与线程类似，每个协程表示一个执行单元，有自己的本地数据，与其它协程共享全局数据和其它资源。

why：

python里面怎么使用协程？是使用gnt，使用方法：看这里

使用协程，可以不受线程开销的限制，我尝试过一次把20W条放在单进程的协程里执行，完全没问题。

多进程+协程下，避开了CPU切换的开销，又能把多个CPU充分利用起来，这种方式对于数据量较大的爬虫还有文件读写之类的效率提升是巨大的。

小例子：

[python] view plain copy

import sys

reload(sys)

sys.setdefaultencoding('utf8')

def fetch():

try:

s = requests.Session()

r = s.get(,timeout=1)#在这里抓取页面

except Exception,e:

prif __name__ == '__main__':int e

return ''

def process_start(_list):

for in _list:

tasks.append(gnt.spawn(fetch,))

def task_start(filepath,flag = 100000):#每10W条启动一个进程

with open(filepath,'r') as reader:#从给定的文件中读取

_list = []#这个list用于存放协程任务

i = 0 #计数器，记录添加了多少个到协程队列

while !='':

_list.append()#每次读取出，将添加到队列

if i == flag:#一定数量的就启动一个进程并执行

p =import requests Process(target=process_start,args=(_list,))

_list = [] #重置队列

i = 0 #重置计数器

if _list not []:#若退出循环后任务队列里还有剩余

p = Process(target=process_start,args=(_list,))#把剩余的全都放到这个进程来执行

task_start('./testData.txt')#读取指定文件 细心的同学会发现：上面的例子中隐藏了一个问题：进程的数量会随着数量的增加而不断增加，我们在这里不使用进程池multiprocessing.Pool来控制进程数量的原因是multiprocessing.Pool和gnt有冲突不能同时使用，但是有兴趣的同学可以研究一下gnt.pool这个协程池。

Golang net/ 爬虫[1]

= reader.readline().strip()

上周从零学习了golang，语法简单关键字少，写个爬虫熟悉一下语法结构。

python里面怎么使用协程看是使用gnt，使用方法：看这里使用协程，可以不受线程开销的限制，我尝试过一次把20W条放在单进程的协程里执行，完全没问题。

首先选用了原生的net/包，基本上涵盖了所有的get/t请求，各种参数都可以设置，网上google到html页面解析goquery神器，很轻松就可以解决页面解析问题。

首先就写了个爬取汇率的爬虫。然后重写之前php的一个请求类，请求类的逻辑有点混乱不清晰，往往把两个不同的功能合并到一起写，粒度大，后来发现了一个好用的框架——colly，之后再试试好不好用

Windows 10 Golang

依赖包：goquery

较常用的构造请求ip网站的链接→获取网页内容→ 提取网页中IP地址和端口号→验证IP的有效性并存储方法有Find和Each

爬取银行的汇率牌价表，golang依赖net/包和goquery包

的难点是对于goquery方法的使用，需要阅读文档：

使用原生的net/包基本上可以解决大多数的网页请求，使用goquery可以解决页面解析问题

可以利用golang的协程特性进行异步多协程爬取

增加安全性可以通过几个方面进行改进：

1.首先可以限制爬虫的爬取速度

2.每次对网页的请求都随机选用一个客户端

轻量级反爬虫方案

浅谈JSP

golang带json的Http请求

Get/Post

HTTP请求中的Form Data和Request Payload的区别

HTTP Json请求

python建立爬虫ip池

爬虫黑科技之让你的爬虫程序更像人类用户的行为

特点：，通过callback执行处理

基于colly开发的web管理界面

golang sync.pool对象复用 并发原理 缓存池

from gnt import monkey; monkey.patch_all()

在go 每一次go serve(l)都会构建Request数据结构。在大量数据请求或高并发的场景中，频繁创建销毁对象，会导致GC压力。解决办法之一就是使用对象复用技术。在协议层之下，使用对象复用技术创建Request数据结构。在协议层之上，可以使用对象复用技术创建(w,r,ctx)数据结构。这样即可以回快TCP层读包之后的解析速度，也可也加快请求处理的速度。

先上一个测试：

貌似使用池化，性能弱爆了？？？这似乎与net/使用sync.pool池化Request来优化性能的选择相违背。这同时也说明了一个问题，好的东西，如果滥用反而造成了性能成倍的下降。在看过pool原理之后，结合实例，将给出正确的使用方法，并给出预期的效果。

不要习惯性地误认为New是一个关键字，这里的New是Pool的一个字段，也是一个闭包名称。其API：

如果不指定New字段，对象池为空时会返回nil，而不是一个新构建的对象。Get()到的对象是随机的。

原生sync.Pool的问题是，Pool中的对象会被GC清理掉，这使得sync.Pool只适合做简单地对象池，不适合作连接池。

pool创建时不能指定大小，没有数量限制。pool中对象会被GC清掉，只存在于两次GC之间。实现是pool的init方法注册了一个poolCleanup()函数，这个方法在GC之前执行，清空pool中的所有缓存对象。

为使多协程使用同一个POOL。最基本的想法就是每个协程，加锁去作共享的POOL，这显然是低效的。而进一步改进，类似于ConcurrentHashMap（JDK7）的分Segment，提高其并发性可以一定程度性缓解。

Get对象过程：

如何解决Get最坏情况遍历所有P才获取得对象呢：

方法1止前sync.pool并没有这样的设置。方法2由于goroutine被分配到哪个P由调度器调度不可控，无法确保其平衡。

由于不可控的GC导致生命周期过短，且池大小不可控，因而不适合作连接池。仅适用于增加对象重用机率，减少GC负担。2

执行结果:

单线程情况下，遍历其它无元素的P，长时间加锁性能低下。启用协程改善。

结果：

测试场景在goroutines远大于GOMAXPROCS情况下，与非池化性能异巨大。

测试结果

结论：pool在一定的使用条件下提高并发性能，条件1是协程数远大于GOMAXPROCS，条件2是池中对象远大于GOMAXPROCS。归结成一个原因就是使对象在各个P中均匀分布。

池pool和缓存cache的区别。池的意思是，池内对象是可以互换的，不关心具体值，甚至不需要区分是新建的还是从池中拿出的。缓存指的是KV映射，缓存里的值互不相同，清除机制更为复杂。缓存清除算法如LRU、LIRS缓存算法。

池空间回收的几种方式。一些是GC前回收，一些是基于时钟或弱引用回收。最终确定在GC时回收Pool内对象，即不回避GC。用ja的GC解释弱引用。GC的四种引用：强引用、弱引用、软引用、虚引用。虚引用即没有引用，弱引用GC但有空间则保留，软引用GC即清除。ThreadLocal的值为弱引用的例子。

regexp 包为了保证并发时使用同一negnt.joinall(tasks)#使用协程来执行t/： 个正则，而维护了一组状态机。

fmt包做字串拼接，从sync.pool拿[]byte对象。避免频繁构建再GC效率高很多。

golang协程占用资源小，有必要写协程池吗

i += 3.选用IP池，防止IP误封（及限制ip访问次数）1

和你有同目前主流语言基本上都选择了多线程作为并发设施，与线程相关的概念是抢占式多任务（Preemptive multitasking），而与协程相关的是协作式多任务。样的疑问。

我在google上搜索关于这方面的文章不多。目前的处理方式还是普遍通过channel接收，有任务进来才开启协程，不会一直保留，顶多设置一个协程开启上限。

--- 共有 1 条评论 ---

golang_yh应该还是有需要的，频繁的创建和释放协程会引起堆内存空间抖动，毕竟协程创建后应该会分配默认大小的栈，听说是8k (8个

golang sync.pool对象复用 并发原理 缓存池

task_list = []#这个list用于存放协程任务

在go 每一次go serve(l)都会构建Request数据结构。在大量数据请求或高并发的场景中，频繁创建销毁对象，会导致GC压力。解决办法之一就是使用对象复用技术。在协议层之下，使用对象复用技术创建Request数据结构。在协议层之上，可以使用对象复用技术创建(w,r,ctx)数据结构。这样即可以回快TCP层读包之后的解析速度，也可也加快请求处理的速度。

先上一个测试：

貌似使用池化，性能弱爆了？？？这似乎与net/使用sync.pool池化Request来优化性能的选择相违背。这同时也说明了一个问题，好的东西，如果滥用反而造成了性能成倍的下降。在看过pool原理之后，结合实例，将给出正确的使用方法，并给出预期的效果。

不要习惯性地误认为New是一个关键字，这里的New是Pool的一个字段，也是一个闭包名称。其API：

如果不指定New字段，对象池为空时会返回nil，而不是一个新构建的对象。Get()到的对象是随机的。

原生sync.Pool的问题是，Pool中的对象会被GC清理掉，这使得sync.Pool只适合做简单地对象池，不适合作连接池。

pool创建时不能指定大小，没有数量限制。pool中对象会被GC清掉，只存在于两次GC之间。实现是pool的init方法注册了一个poolCleanup()函数，这个方法在GC之前执行，清空pool中的所有缓存对象。

为使多协程使用同一个POOL。最基本的想法就是每个协程，加锁去作共享的POOL，这显然是低效的。而进一步改进，类似于ConcurrentHashMap（JDK7）的分Segment，提高其并发性可以一定程度性缓解。

Get对象过程：

如何解决Get最坏情况遍历所有P才获取得对象呢：

方法1止前sync.pool并没有这样的设置。方法2由于goroutine被分配到哪个P由调度器调度不可控，无法确保其平衡。

由于不可控的GC导致生命周期过短，且池大小不可控，因而不适合作连接池。仅适用于增加对象重用机率，减少GC负担。2

执行结果:

单线程情况下，遍历其它无元素的P，长时间加锁性能低下。启用协程改善。

结果：

测试场景在goroutines远大于GOMAXPROCS情况下，与非池化性能异巨大。

测试结果

结论：pool在一定的使用条件下提高并发性能，条件1是协程数远大于GOMAXPROCS，条件2是池中对象远大于GOMAXPROCS。归结成一个原因就是使对象在各个P中均匀分布。

池pool和缓存cache的区别。池的意思是，池内对象是可以互换的，不关心具体值，甚至不需要区分是新建的还是从池中拿出的。缓存指的是KV映射，缓存里的值互不相同，清除机制更为复杂。缓存清除算法如LRU、LIRS缓存算法。而且由于抢占式调度执行顺序无法确定的特点，使用线程时需要非常小心地处理同步问题，而协程完全不存在这个问题（驱动和异步程序也有同样的优点）。

池空间回收的几种方式。一些是GC前回收，一些是基于时钟或弱引用回收。最终确定在GC时回收Pool内对象，即不回避GC。用ja的GC解释弱引用。GC的四种引用：强引用、弱引用、软引用、虚引用。虚引用即没有引用，弱引用GC但有空间则保留，软引用GC即清除。ThreadLocal的值为弱引用的例子。

regexp 包为import gnt了保证并发时使用同一个正则，而维护了一组状态机。

fmt包做字串拼接，从sync.pool拿[]byte对象。避免频繁构建再GC效率高很多。

Golang-基于TimeingWheel定时器

改数组需要实现 Go 预先定义的接口 Len , Less , Swap , Push , Pop 和 update 。

在linux下实现定时器主要有如下方式

前面讲了为什么Python里用多进程而不是多线程，但是多进程也有其自己的限制：相比线程更加笨重、切换耗时更长，并且在python的多进程下，进程数量不超过CPU核心数（一个进程只有一个GIL，所以一个进程只能跑满一个CPU），因为一个进程占用一个CPU时能充分利用机器的性能，但是进程多了就会出现频繁的进程切换，反而得不偿失。

在这当中 基于时间轮方式实现的定时器 时间复杂度最小，效率，然而我们可以通过 优先队列 实现时间轮定时器。

优先队列的实现可以使用堆和最小堆，因此在队列中所有的数据都可以定义排序规则自动排序。我们直接通过队列中 pop 函数获取数据，就是我们按照自定义排序规则想要的数据。

在 Golang 中实现一个优先队列异常简单，在 container/head 包中已经帮我们封装了，实现的细节，我们只需要实现特定的接口就可以。

下面是提供的例子

因为优先队列底层数据结构是由二叉树构建的，所以我们可以通过数组来保存二叉树上的每一个。

timerType结构是定时任务抽象结构

首先的 start 函数，当创建一个 TimeingWheel 时，通过一个 goroutine 来执行 start ,在start中for循环和select来不同的channel的状态

通过for循环从队列中取数据，直到该队列为空或者是遇见个当前时间比任务开始时间大的任务， append 到 expired 中。因为优先队列中是根据 expiration 来排序的，

所以当取到个定时任务未到的任务时，表示该定时任务以后的任务都未到时间。

如果大于0 则，表示就生效。

防止外部滥用，阻塞定时器协程，框架又一次封装了timer这个包，名为 timer_wapper 这个包,它提供了两种调用方式。

参数和上面的参数一样，只是在第三个参数中使用了任务池，将定时任务放入了任务池中。定时任务的本身执行就是一个 put 作。

至于put以后，那就是 workers 这个包管理的了。在 worker 包中， 也就是维护了一个任务池，任务池中的任务会有序的执行，方便管理。

Golang net/ 爬虫[1]

tasks = []

上周从零学习了golang，语法简单关键字少，写个爬虫熟悉一下语法结构。

2、单进程+多线程：例如我们在这个进程中开了10个多线程，比1中能够提升10倍速度，也就是大约4.63天能够完成200W条抓取，请注意，这里的实际执行是：线程1遇见了阻塞，CPU切换到线程2去执行，遇见阻塞又切换到线程3等等，10个线程都阻塞后，这个进程就阻塞了，而直到某个线程阻塞完成后，这个进程才能继续执行，所以速度上提升大约能到10倍（这里忽略了线程切换带来的开销，实际上的提升应该是不能达到10倍的），但是需要考虑的是线程的切换也是有开销的，所以不能无限的启动多线程（开200W个线程肯定是不靠谱的）

首先选用了原生的net/包，基本上涵盖了所有的get/t请求，各种参数都可以设置，网上google到html页面解析goquery神器，很轻松就可以解决页面解析问题。

首先就写了个爬取汇率的爬虫。然后重写之前php的一个请求类，请求类的逻辑有点混乱不清晰，往往把两个不同的功能合并到一起写，粒度大，后来发现了一个好用的框架——colly，之后再试试好不好用

Windows 10 Golang

依赖包：goquery

较常用的方法有Find和Each

爬取银行的汇率牌价表，golang依赖net/包和goquery包

的难点是对于goquery方法的使用，需要阅读文档：

使用原生的net/包基本上可以解决大多数的网页请求，使用goquery可以解决页面解析问题

可以利用golang的协程特性进行异步多协程爬取

增加安全性可以通过几个方面进行改进：

1.首先可以限制爬虫的爬取速度

2.每次对网页的请求都随机选用一个客户端

轻量级反爬虫方案

浅谈JSP

golang带jso当 getExpired 函数取出队列中要执行的任务时，当有的定时任务需要不断执行，所以就需要判断是否该定时任务需要重新放回优先队列中。 isRepeat 是通过判断任务中 interval 是否大于 0 判断，n的Http请求

Get/Post

HTTP请求中的Form Data和Request Payload的区别

HTTP Json请求

python建立爬虫ip池

爬虫黑科技之让你的爬虫程序更像人类用户的行为

特点：，通过callback执行处理

基于colly开发的web管理界面