python轮询

❶ python中进程与线程的区别是什么

Num01–>线程

线程是操作系统中能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。

一个线程指的是进程中一个单一顺序的控制流。

一个进程中可以并发多条线程，每条线程并行执行不同的任务。

Num02–>进程

进程就是一个程序在一个数据集上的一次动态执行过程。

进程有以下三部分组成：

1，程序：我们编写的程序用来描述进程要完成哪些功能以及如何完成。
2，数据集：数据集则是程序在执行过程中需要的资源，比如图片、音视频、文件等。
3，进程控制块：进程控制块是用来记录进程的外部特征，描述进程的执行变化过程，系统可以用它来控制和管理进程，它是系统感知进程存在的唯一标记。

Num03–>进程和线程的区别：

1、运行方式不同：

进程不能单独执行，它只是资源的集合。

进程要操作CPU，必须要先创建一个线程。

所有在同一个进程里的线程，是同享同一块进程所占的内存空间。

2，关系

进程中第一个线程是主线程，主线程可以创建其他线程；其他线程也可以创建线程；线程之间是平等的。

进程有父进程和子进程，独立的内存空间，唯一的标识符：pid。

3，速度

启动线程比启动进程快。

运行线程和运行进程速度上是一样的，没有可比性。

线程共享内存空间，进程的内存是独立的。

4，创建

父进程生成子进程，相当于复制一份内存空间，进程之间不能直接访问

创建新线程很简单，创建新进程需要对父进程进行一次复制。

一个线程可以控制和操作同级线程里的其他线程，但是进程只能操作子进程。

5，交互

同一个进程里的线程之间可以直接访问。

两个进程想通信必须通过一个中间代理来实现。

相关推荐：《Python视频教程》

Num04–>几个常见的概念

1，什么的并发和并行？

并发：微观上CPU轮流执行，宏观上用户看到同时执行。因为cpu切换任务非常快。

并行：是指系统真正具有同时处理多个任务（动作）的能力。

2，同步、异步和轮询的区别？

同步任务：B一直等着A，等A完成之后，B再执行任务。(打电话案例)

轮询任务：B没有一直等待A，B过一会来问一下A，过一会问下A

异步任务：B不需要一直等着A, B先做其他事情，等A完成后A通知B。（发短信案例）

Num05–>进程和线程的优缺点比较

首先，要实现多任务，通常我们会设计Master-Worker模式，Master负责分配任务，Worker负责执行任务，因此，多任务环境下，通常是一个Master，多个Worker。

如果用多进程实现Master-Worker，主进程就是Master，其他进程就是Worker。

如果用多线程实现Master-Worker，主线程就是Master，其他线程就是Worker。

多进程模式最大的优点就是稳定性高，因为一个子进程崩溃了，不会影响主进程和其他子进程。（当然主进程挂了所有进程就全挂了，但是Master进程只负责分配任务，挂掉的概率低）着名的Apache最早就是采用多进程模式。

多进程模式的缺点是创建进程的代价大，在Unix/linux系统下，用fork调用还行，在Windows下创建进程开销巨大。另外，操作系统能同时运行的进程数也是有限的，在内存和CPU的限制下，如果有几千个进程同时运行，操作系统连调度都会成问题。

多线程模式通常比多进程快一点，但是也快不到哪去，而且，多线程模式致命的缺点就是任何一个线程挂掉都可能直接造成整个进程崩溃，因为所有线程共享进程的内存。在Windows上，如果一个线程执行的代码出了问题，你经常可以看到这样的提示：“该程序执行了非法操作，即将关闭”，其实往往是某个线程出了问题，但是操作系统会强制结束整个进程。

在Windows下，多线程的效率比多进程要高，所以微软的IIS服务器默认采用多线程模式。由于多线程存在稳定性的问题，IIS的稳定性就不如Apache。为了缓解这个问题，IIS和Apache现在又有多进程+多线程的混合模式，真是把问题越搞越复杂。

Num06–>计算密集型任务和IO密集型任务

是否采用多任务的第二个考虑是任务的类型。我们可以把任务分为计算密集型和IO密集型。

第一种：计算密集型任务的特点是要进行大量的计算，消耗CPU资源，比如计算圆周率、对视频进行高清解码等等，全靠CPU的运算能力。这种计算密集型任务虽然也可以用多任务完成，但是任务越多，花在任务切换的时间就越多，CPU执行任务的效率就越低，所以，要最高效地利用CPU，计算密集型任务同时进行的数量应当等于CPU的核心数。

计算密集型任务由于主要消耗CPU资源，因此，代码运行效率至关重要。Python这样的脚本语言运行效率很低，完全不适合计算密集型任务。对于计算密集型任务，最好用C语言编写。

第二种：任务的类型是IO密集型，涉及到网络、磁盘IO的任务都是IO密集型任务，这类任务的特点是CPU消耗很少，任务的大部分时间都在等待IO操作完成（因为IO的速度远远低于CPU和内存的速度）。对于IO密集型任务，任务越多，CPU效率越高，但也有一个限度。常见的大部分任务都是IO密集型任务，比如Web应用。

IO密集型任务执行期间，99%的时间都花在IO上，花在CPU上的时间很少，因此，用运行速度极快的C语言替换用Python这样运行速度极低的脚本语言，完全无法提升运行效率。对于IO密集型任务，最合适的语言就是开发效率最高（代码量最少）的语言，脚本语言是首选，C语言最差。

相关推荐：

Python中的进程是什么

❷ 详解Python中的协程，为什么说它的底层是生成器

协程又称为是微线程，英文名是Coroutine。它和线程一样可以调度，但是不同的是线程的启动和调度需要通过操作系统来处理。并且线程的启动和销毁需要涉及一些操作系统的变量申请和销毁处理，需要的时间比较长。而协程呢，它的调度和销毁都是程序自己来控制的，因此它更加轻量级也更加灵活。

协程有这么多优点，自然也会有一些缺点，其中最大的缺点就是需要编程语言自己支持，否则的话需要开发者自己通过一些方法来实现协程。对于大部分语言来说，都不支持这一机制。go语言由于天然支持协程，并且支持得非常好，使得它广受好评，短短几年时间就迅速流行起来。

对于Python来说，本身就有着一个GIL这个巨大的先天问题。GIL是Python的全局锁，在它的限制下一个Python进程同一时间只能同时执行一个线程，即使是在多核心的机器当中。这就大大影响了Python的性能，尤其是在CPU密集型的工作上。所以为了提升Python的性能，很多开发者想出了使用多进程+协程的方式。一开始是开发者自行实现的，后来在Python3.4的版本当中，官方也收入了这个功能，因此目前可以光明正大地说，Python是支持协程的语言了。

生成器（generator)

生成器我们也在之前的文章当中介绍过，为什么我们介绍协程需要用到生成器呢，是因为Python的协程底层就是通过生成器来实现的。

通过生成器来实现协程的原因也很简单，我们都知道协程需要切换挂起，而生成器当中有一个yield关键字，刚好可以实现这个功能。所以当初那些自己在Python当中开发协程功能的程序员都是通过生成器来实现的，我们想要理解Python当中协程的运用，就必须从最原始的生成器开始。

生成器我们很熟悉了，本质上就是带有yield这个关键词的函数。

async，await和future

从Python3.5版本开始，引入了async，await和future。我们来简单说说它们各自的用途，其中async其实就是@asyncio.coroutine，用途是完全一样的。同样await代替的是yield from，意为等待另外一个协程结束。

我们用这两个一改，上面的代码就成了：

async def test(k):

n = 0

while n < k:

await asyncio.sleep(0.5)

print('n = {}'.format(n))

n += 1

由于我们加上了await，所以每次在打印之前都会等待0.5秒。我们把await换成yield from也是一样的，只不过用await更加直观也更加贴合协程的含义。

Future其实可以看成是一个信号量，我们创建一个全局的future，当一个协程执行完成之后，将结果存入这个future当中。其他的协程可以await future来实现阻塞。我们来看一个例子就明白了：

future = asyncio.Future()

async def test(k):

n = 0

while n < k:

await asyncio.sleep(0.5)

print('n = {}'.format(n))

n += 1

future.set_result('success')

async def log():

result = await future

print(result)

loop = asyncio.get_event_loop()

loop.run_until_complete(asyncio.wait([

log(),

test(5)

]))

loop.close()

在这个例子当中我们创建了两个协程，第一个协程是每隔0.5秒print一个数字，在print完成之后把success写入到future当中。第二个协程就是等待future当中的数据，之后print出来。

在loop当中我们要调度执行的不再是一个协程对象了而是两个，所以我们用asyncio当中的wait将这两个对象包起来。只有当wait当中的两个对象执行结束，wait才会结束。loop等待的是wait的结束，而wait等待的是传入其中的协程的结束，这就形成了一个依赖循环，等价于这两个协程对象结束，loop才会结束。

总结

async并不只是可以用在函数上，事实上还有很多其他的用法，比如用在with语句上，用在for循环上等等。这些用法比较小众，细节也很多，就不一一展开了，大家感兴趣的可以自行去了解一下。

不知道大家在读这篇文章的过程当中有没有觉得有些费劲，如果有的话，其实是很正常的。原因也很简单，因为Python原生是不支持协程这个概念的，所以在一开始设计的时候也没有做这方面的准备，是后来觉得有必要才加入的。那么作为后面加入的内容，必然会对原先的很多内容产生影响，尤其是协程借助了之前生成器的概念来实现的，那么必然会有很多耦合不清楚的情况。这也是这一块的语法很乱，对初学者不友好的原因。

❸ Python面试题，线程与进程的区别，Python中如何创建多线程

进程和线程

这两个概念属于操作系统，我们经常听说，但是可能很少有人会细究它们的含义。对于工程师而言，两者的定义和区别还是很有必要了解清楚的。

首先说进程，进程可以看成是 CPU执行的具体的任务 。在操作系统当中，由于CPU的运行速度非常快，要比计算机当中的其他设备要快得多。比如内存、磁盘等等，所以如果CPU一次只执行一个任务，那么会导致CPU大量时间在等待这些设备，这样操作效率很低。为了提升计算机的运行效率，把机器的技能尽可能压榨出来，CPU是轮询工作的。也就是说 它一次只执行一个任务，执行一小段碎片时间之后立即切换 ，去执行其他任务。

所以在早期的单核机器的时候，看起来电脑也是并发工作的。我们可以一边听歌一边上网，也不会觉得卡顿。但实际上，这是CPU轮询的结果。在这个例子当中，听歌的软件和上网的软件对于CPU而言都是 独立的进程 。我们可以把进程简单地理解成运行的应用，比如在安卓手机里面，一个app启动的时候就会对应系统中的一个进程。当然这种说法不完全准确， 一个应用也是可以启动多个进程的 。

进程是对应CPU而言的，线程则更多针对的是程序。即使是CPU在执行当前进程的时候，程序运行的任务其实也是有分工的。举个例子，比如听歌软件当中，我们需要显示歌词的字幕，需要播放声音，需要监听用户的行为，比如是否发生了切歌、调节音量等等。所以，我们需要 进一步拆分CPU的工作 ，让它在执行当前进程的时候，继续通过轮询的方式来同时做多件事情。

进程中的任务就是线程，所以从这点上来说， 进程和线程是包含关系 。一个进程当中可以包含多个线程，对于CPU而言，不能直接执行线程，一个线程一定属于一个进程。所以我们知道，CPU进程切换切换的是执行的应用程序或者是软件，而进程内部的线程切换，切换的是软件当中具体的执行任务。

关于进程和线程有一个经典的模型可以说明它们之间的关系，假设CPU是一家工厂，工厂当中有多个车间。不同的车间对应不同的生产任务，有的车间生产汽车轮胎，有的车间生产汽车骨架。但是工厂的电力是有限的，同时只能满足一个厂房的使用。

为了让大家的进度协调，所以工厂需要轮流提供各个车间的供电。 这里的车间对应的就是进程 。

一个车间虽然只生产一种产品，但是其中的工序却不止一个。一个车间可能会有好几条流水线，具体的生产任务其实是流水线完成的，每一条流水线对应一个具体执行的任务。但是同样的， 车间同一时刻也只能执行一条流水线 ，所以我们需要车间在这些流水线之间切换供电，让各个流水线生产进度统一。

这里车间里的 流水线自然对应的就是线程的概念 ，这个模型很好地诠释了CPU、进程和线程之间的关系。实际的原理也的确如此，不过CPU中的情况要比现实中的车间复杂得多。因为对于进程和CPU来说，它们面临的局面都是实时变化的。车间当中的流水线是x个，下一刻可能就成了y个。

了解完了线程和进程的概念之后，对于理解电脑的配置也有帮助。比如我们买电脑，经常会碰到一个术语，就是这个电脑的CPU是某某核某某线程的。比如我当年买的第一台笔记本是4核8线程的，这其实是在说这台电脑的CPU有 4个计算核心 ，但是使用了超线程技术，使得可以把一个物理核心模拟成两个逻辑核心。相当于我们可以用4个核心同时执行8个线程，相当于8个核心同时执行，但其实有4个核心是模拟出来的虚拟核心。

有一个问题是 为什么是4核8线程而不是4核8进程呢 ？因为CPU并不会直接执行进程，而是执行的是进程当中的某一个线程。就好像车间并不能直接生产零件，只有流水线才能生产零件。车间负责的更多是资源的调配，所以教科书里有一句非常经典的话来诠释： 进程是资源分配的最小单元，线程是CPU调度的最小单元 。

启动线程

Python当中为我们提供了完善的threading库，通过它，我们可以非常方便地创建线程来执行多线程。

首先，我们引入threading中的Thread，这是一个线程的类，我们可以通过创建一个线程的实例来执行多线程。

from threading import Thread t = Thread(target=func, name='therad', args=(x, y)) t.start()

简单解释一下它的用法，我们传入了三个参数，分别是 target，name和args ，从名字上我们就可以猜测出它们的含义。首先是target，它传入的是一个方法，也就是我们希望多线程执行的方法。name是我们为这个新创建的线程起的名字，这个参数可以省略，如果省略的话，系统会为它起一个系统名。当我们执行Python的时候启动的线程名叫MainThread，通过线程的名字我们可以做区分。args是会传递给target这个函数的参数。

我们来举个经典的例子：

import time, threading # 新线程执行的代码: def loop(n): print('thread %s is running...' % threading.current_thread().name) for i in range(n): print('thread %s >>> %s' % (threading.current_thread().name, i)) time.sleep(5) print('thread %s ended.' % threading.current_thread().name) print('thread %s is running...' % threading.current_thread().name) t = threading.Thread(target=loop, name='LoopThread', args=(10, )) t.start() print('thread %s ended.' % threading.current_thread().name)

我们创建了一个非常简单的loop函数，用来执行一个循环来打印数字，我们每次打印一个数字之后这个线程会睡眠5秒钟，所以我们看到的结果应该是每过5秒钟屏幕上多出一行数字。

我们在Jupyter里执行一下：

表面上看这个结果没毛病，但是其实有一个问题，什么问题呢？ 输出的顺序不太对 ，为什么我们在打印了第一个数字0之后，主线程就结束了呢？另外一个问题是，既然主线程已经结束了， 为什么Python进程没有结束 ， 还在向外打印结果呢？

因为线程之间是独立的，对于主线程而言，它在执行了t.start()之后，并 不会停留，而是会一直往下执行一直到结束 。如果我们不希望主线程在这个时候结束，而是阻塞等待子线程运行结束之后再继续运行，我们可以在代码当中加上t.join()这一行来实现这点。

t.start() t.join() print('thread %s ended.' % threading.current_thread().name)

join操作可以让主线程在join处挂起等待，直到子线程执行结束之后，再继续往下执行。我们加上了join之后的运行结果是这样的：

这个就是我们预期的样子了，等待子线程执行结束之后再继续。

我们再来看第二个问题，为什么主线程结束的时候，子线程还在继续运行，Python进程没有退出呢？这是因为默认情况下我们创建的都是用户级线程，对于进程而言， 会等待所有用户级线程执行结束之后才退出 。这里就有了一个问题，那假如我们创建了一个线程尝试从一个接口当中获取数据，由于接口一直没有返回，当前进程岂不是会永远等待下去？

这显然是不合理的，所以为了解决这个问题，我们可以把创建出来的线程设置成 守护线程 。

守护线程

守护线程即daemon线程，它的英文直译其实是后台驻留程序，所以我们也可以理解成 后台线程 ，这样更方便理解。daemon线程和用户线程级别不同，进程不会主动等待daemon线程的执行， 当所有用户级线程执行结束之后即会退出。进程退出时会kill掉所有守护线程 。

我们传入daemon=True参数来将创建出来的线程设置成后台线程：

t = threading.Thread(target=loop, name='LoopThread', args=(10, ), daemon=True)

这样我们再执行看到的结果就是这样了：

这里有一点需要注意，如果你 在jupyter当中运行是看不到这样的结果的 。因为jupyter自身是一个进程，对于jupyter当中的cell而言，它一直是有用户级线程存活的，所以进程不会退出。所以想要看到这样的效果，只能通过命令行执行Python文件。

如果我们想要等待这个子线程结束，就必须通过join方法。另外，为了预防子线程锁死一直无法退出的情况， 我们还可以 在joih当中设置timeout ，即最长等待时间，当等待时间到达之后，将不再等待。

比如我在join当中设置的timeout等于5时，屏幕上就只会输出5个数字。

另外，如果没有设置成后台线程的话，设置timeout虽然也有用，但是 进程仍然会等待所有子线程结束 。所以屏幕上的输出结果会是这样的：

虽然主线程继续往下执行并且结束了，但是子线程仍然一直运行，直到子线程也运行结束。

关于join设置timeout这里有一个坑，如果我们只有一个线程要等待还好，如果有多个线程，我们用一个循环将它们设置等待的话。那么 主线程一共会等待N * timeout的时间 ，这里的N是线程的数量。因为每个线程计算是否超时的开始时间是上一个线程超时结束的时间，它会等待所有线程都超时，才会一起终止它们。

比如我这样创建3个线程：

ths = [] for i in range(3): t = threading.Thread(target=loop, name='LoopThread' + str(i), args=(10, ), daemon=True) ths.append(t) for t in ths: t.start() for t in ths: t.join(2)

最后屏幕上输出的结果是这样的：

所有线程都存活了6秒。

总结

在今天的文章当中，我们一起简单了解了 操作系统当中线程和进程的概念 ，以及Python当中如何创建一个线程，以及关于创建线程之后的相关使用。

多线程在许多语言当中都是至关重要的，许多场景下必定会使用到多线程。比如 web后端，比如爬虫，再比如游戏开发 以及其他所有需要涉及开发ui界面的领域。因为凡是涉及到ui，必然会需要一个线程单独渲染页面，另外的线程负责准备数据和执行逻辑。因此，多线程是专业程序员绕不开的一个话题，也是一定要掌握的内容之一。

❹ Python多线程问题，怎么解决

在python里线程出问题，可能会导致主进程崩溃。 虽然python里的线程是操作系统的真实线程。

那么怎么解决呢？通过我们用进程方式。子进程崩溃后，会完全的释放所有的内存和错误状态。所以进程更安全。 另外通过进程，python可以很好的绕过GIL，这个全局锁问题。

但是进程也是有局限的。不要建立超过CPU总核数的进程，否则效率也不高。

简单的总结一下。
当我们想实现多任务处理时，首先要想到使用multiprocessing， 但是如果觉着进程太笨重，那么就要考虑使用线程。 如果多任务处理中需要处理的太多了，可以考虑多进程，每个进程再采用多线程。如果还处理不要，就要使用轮询模式，比如使用poll event, twisted等方式。如果是GUI方式，则要通过事件机制，或者是消息机制处理，GUI使用单线程。

所以在python里线程不要盲目用， 也不要滥用。 但是线程不安全是事实。如果仅仅是做几个后台任务，则可以考虑使用守护线程做。如果需要做一些危险操作，可能会崩溃的，就用子进程去做。 如果需要高度稳定性，同时并发数又不高的服务。则强烈建议用多进程的multiprocessing模块实现。

在linux或者是unix里，进程的使用代价没有windows高。还是可以接受的。

❺ python 定时轮询目录指定目录下文件

#python简单定时器的实现
importos
importtime
importos.path

rootdir='A'

defdoWork():
forparent,dirnames,filenamesinos.walk(rootdir):
forfilenameinfilenames:
print("filenameis:"+filename)
#这里就写你想要对数据的操作咯
defrun(interval):
whileTrue:
try:
#
time_remaining=interval-time.time()%interval
time.sleep(time_remaining)
doWork()
exceptExceptionase:
print(e)
if__name__=="__main__":
interval=60*10
run(interval)

❻ Python进程之串行与并行

串行和并行

串行指的是任务的执行方式。串行在执行多个任务时，各个任务按顺序执行，完成一个之后才能进行下一个。（早期单核CPU的情况下）

并行指的是多个任务在同一时刻可以同时执行（前提是多核CPU），不需要等待。

同步和异步

所谓同步就是一个任务的完成需要依赖另外一个任务时，只有等待被依赖的任务完成后，依赖的任务才能算完成，这是一种可靠的任务序列。要成功都成功，失败都失败，两个任务的状态可以保持一致需要等待、协调运行。

所谓异步就是彼此独立的，分配任务后，不需要等待该任务的执行结果，继续做自己的事，无论被分配的任务是执行成功还是失败都是不关心的，只要自己完成了整个任务就算完成了。至于其它任务是否真正完成无法确定，所以它是不可靠的任务序列。

相关推荐：《Python视频教程》

小结：

1、串行和同步的区别：串行指的是在早期单核CPU时，一台电脑在同一时刻只能执行一个程序，如果想要运行另一个程序需要关闭当前程序，才能执行下一个程序，是针对多个程序来说的。同步指的是在一个程序中同一时刻只能执行一个任务。是针对一个程序中多个进程或多个线程来说的。

所以两者有着本质上的区别。串行是针对多个程序，同步是针对一个程序内部的多个进程或多个线程的。

2、并行和异步的区别：并行指的是多核CPU，在同一时刻可以执行多个程序。异步指的是在同一个程序内可以执行多个进程或者多个线程。

两者本质上的区别就是并行指的是多个程序，异步指的是一个程序内部的多个进程和多个线程。

3、并行和并发的区别：并行和并发都是指多个程序，但不同的是并行在同一时刻可以同时执行多个任务，而并发在同一时刻只能执行一个任务，通过多道技术在空间上可以开启多个程序，在时间上通过时间片的方式轮询多个程序，从用户的角度来看实现了多个程序同时执行的伪并行，从CPU的角度同一时刻它只能执行一个程序，所以说他是串行的，只不过是由于CPU切换速度太快我们无法从表面看出来而已。

并行是真正的同一时刻执行多个程序，并发是通过时间轮询的方式实现了伪并行。

阻塞与非阻塞：

阻塞：只要是涉及到I/O操作或者网络请求的都属于阻塞如read,recv，accept。

非阻塞：只要不涉及到I/O，网络请求的在内存中可以直接计算的就是非阻塞，例如：list.append(8),dict["a"]=1就是非阻塞。

相关推荐：

Python进程之并行与并发的区别

❼ python 定时轮询目录指定目录下最新文件

你每次扫描完后移走A目录下的所有文件就好了，这样就能确保你每次扫描到的文件都是在十分钟以内到达A目录下的了

❽ 有哪些应用场景适合用python的gevent来完成

一种技术的出现必然是为了解决某种问题，gevent是为了解决什么问题呢，设想下面这种情况。
你要做一个千人在线的Web聊天室，聊天室需要能够实时来收发消息。但是，HTTP是无状态的，也就是说，服务器没有直接把消息发给浏览器的能力。所以你往服务器发送数据之后，服务器没法把你的消息推送给其他聊天室的人，但有若干方案可以解决这个问题。
这
里假设我们采用常见的长轮询的方案，即客户端请求服务端获取最新的消息，服务器有消息就返回数据，否则将一直保持连接直到超时。这时候，如果千人在线的
话，就需要保持1000个连接，如果连接是进程模式或者线程模式，那就要开对应个数的进程或者线程，1000个进程或者线程的切换开销会消耗太多的资源。
你仔细分析这个聊天室的代码执行情况，会发现这么多的进程或者线程大部分时间都是闲的，它们在等浏览器发消息，啥事都没干。
针对这个问题，你可以想到，要一个进程在闲的时候去干其他的事情，等这边消息到了再回来处理就好了。gevent把这个功能实现了，切换开销大大降低，系统性能飙升。

总结起来就一句话，如果系统资源过的消耗在进程线程切换上面，用gevent！

❾ python2.7怎么实现异步

改进之前
之前，我的查询步骤很简单，就是：
前端提交查询请求 --> 建立数据库连接 --> 新建游标 --> 执行命令 --> 接受结果 --> 关闭游标、连接
这几大步骤的顺序执行。
这里面当然问题很大：
建立数据库连接实际上就是新建一个套接字。这是进程间通信的几种方法里，开销最大的了。
在“执行命令”和“接受结果”两个步骤中，线程在阻塞在数据库内部的运行过程中，数据库连接和游标都处于闲置状态。
这样一来，每一次查询都要顺序的新建数据库连接，都要阻塞在数据库返回结果的过程中。当前端提交大量查询请求时，查询效率肯定是很低的。
第一次改进
之前的模块里，问题最大的就是第一步——建立数据库连接套接字了。如果能够一次性建立连接，之后查询能够反复服用这个连接就好了。
所以，首先应该把数据库查询模块作为一个单独的守护进程去执行，而前端app作为主进程响应用户的点击操作。那么两条进程怎么传递消息呢？翻了几天Python文档，终于构思出来：用队列queue作为生产者（web前端）向消费者（数据库后端）传递任务的渠道。生产者，会与SQL命令一起，同时传递一个管道pipe的连接对象，作为任务完成后，回传结果的渠道。确保，任务的接收方与发送方保持一致。
作为第二个问题的解决方法，可以使用线程池来并发获取任务队列中的task，然后执行命令并回传结果。
第二次改进
第一次改进的效果还是很明显的，不用任何测试手段。直接点击页面链接，可以很直观地感觉到反应速度有很明显的加快。
但是对于第二个问题，使用线程池还是有些欠妥当。因为，CPython解释器存在GIL问题，所有线程实际上都在一个解释器进程里调度。线程稍微开多一点，解释器进程就会频繁的切换线程，而线程切换的开销也不小。线程多一点，甚至会出现“抖动”问题（也就是刚刚唤醒一个线程，就进入挂起状态，刚刚换到栈帧或内存的上下文，又被换回内存或者磁盘），效率大大降低。也就是说，线程池的并发量很有限。
试过了多进程、多线程，只能在单个线程里做文章了。
Python中的asyncio库
Python里有大量的协程库可以实现单线程内的并发操作，比如Twisted、Gevent等等。Python官方在3.5版本里提供了asyncio库同样可以实现协程并发。asyncio库大大降低了Python中协程的实现难度，就像定义普通函数那样就可以了，只是要在def前面多加一个async关键词。async def函数中，需要阻塞在其他async def函数的位置前面可以加上await关键词。
import asyncio
async def wait():
await asyncio.sleep(2)
async def execute(task):
process_task(task)
await wait()
continue_job()
async def函数的执行稍微麻烦点。需要首先获取一个loop对象，然后由这个对象代为执行async def函数。
loop = asyncio.get_event_loop()
loop.run_until_complete(execute(task))
loop.close()
loop在执行execute(task)函数时，如果遇到await关键字，就会暂时挂起当前协程，转而去执行其他阻塞在await关键词的协程，从而实现协程并发。
不过需要注意的是，run_until_complete()函数本身是一个阻塞函数。也就是说，当前线程会等候一个run_until_complete()函数执行完毕之后，才会继续执行下一部函数。所以下面这段代码并不能并发执行。
for task in task_list:
loop.run_until_complete(task)
对与这个问题，asyncio库也有相应的解决方案：gather函数。
loop = asyncio.get_event_loop()
tasks = [asyncio.ensure_future(execute(task))
for task in task_list]
loop.run_until_complete(asyncio.gather(*tasks))
loop.close()
当然了，async def函数的执行并不只有这两种解决方案，还有call_soon与run_forever的配合执行等等，更多内容还请参考官方文档。
Python下的I/O多路复用
协程，实际上，也存在上下文切换，只不过开销很轻微。而I/O多路复用则完全不存在这个问题。
目前，Linux上比较火的I/O多路复用API要算epoll了。Tornado，就是通过调用C语言封装的epoll库，成功解决了C10K问题（当然还有Pypy的功劳）。
在Linux里查文档，可以看到epoll只有三类函数，调用起来比较方便易懂。
创建epoll对象，并返回其对应的文件描述符（file descriptor）。
int epoll_create(int size);
int epoll_create1(int flags);
控制监听事件。第一个参数epfd就对应于前面命令创建的epoll对象的文件描述符；第二个参数表示该命令要执行的动作：监听事件的新增、修改或者删除；第三个参数，是要监听的文件对应的描述符；第四个，代表要监听的事件。
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
等候。这是一个阻塞函数，调用者会等候内核通知所注册的事件被触发。
int epoll_wait(int epfd, struct epoll_event *events,
int maxevents, int timeout);
int epoll_pwait(int epfd, struct epoll_event *events,
int maxevents, int timeout,
const sigset_t *sigmask);
在Python的select库里：
select.epoll()对应于第一类创建函数；
epoll.register()，epoll.unregister()，epoll.modify()均是对控制函数epoll_ctl的封装；
epoll.poll()则是对等候函数epoll_wait的封装。
Python里epoll相关API的最大问题应该是在epoll.poll()。相比于其所封装的epoll_wait，用户无法手动指定要等候的事件，也就是后者的第二个参数struct epoll_event *events。没法实现精确控制。因此只能使用替代方案：select.select()函数。
根据Python官方文档，select.select(rlist, wlist, xlist[, timeout])是对Unix系统中select函数的直接调用，与C语言API的传参很接近。前三个参数都是列表，其中的元素都是要注册到内核的文件描述符。如果想用自定义类，就要确保实现了fileno()方法。
其分别对应于：
rlist: 等候直到可读
wlist: 等候直到可写
xlist: 等候直到异常。这个异常的定义，要查看系统文档。
select.select()，类似于epoll.poll()，先注册文件和事件，然后保持等候内核通知，是阻塞函数。
实际应用
Psycopg2库支持对异步和协程，但和一般情况下的用法略有区别。普通数据库连接支持不同线程中的不同游标并发查询；而异步连接则不支持不同游标的同时查询。所以异步连接的不同游标之间必须使用I/O复用方法来协调调度。
所以，我的大致实现思路是这样的：首先并发执行大量协程，从任务队列中提取任务，再向连接池请求连接，创建游标，然后执行命令，并返回结果。在获取游标和接受查询结果之前，均要阻塞等候内核通知连接可用。
其中，连接池返回连接时，会根据引用连接的协程数量，返回负载最轻的连接。这也是自己定义AsyncConnectionPool类的目的。
我的代码位于：bottle-blog/dbservice.py
存在问题
当然了，这个流程目前还一些问题。
首先就是每次轮询拿到任务之后，都会走这么一个流程。
获取连接 --> 新建游标 --> 执行任务 --> 关闭游标 --> 取消连接引用
本来，最好的情况应该是：在轮询之前，就建好游标；在轮询时，直接等候内核通知，执行相应任务。这样可以减少轮询时的任务量。但是如果协程提前对应好连接，那就不能保证在获取任务时，保持各连接负载均衡了。
所以这一块，还有工作要做。
还有就是epoll没能用上，有些遗憾。
以后打算写点C语言的内容，或者用Python/C API，或者用Ctypes包装共享库，来实现epoll的调用。
最后，请允许我吐槽一下Python的epoll相关文档：简直太弱了！！！必须看源码才能弄清楚功能。

❿ python 怎样轮询子进程标准输出问题

基于文本文档(Markdown) 设想好需要的基本需要的表、字段、类型； 使用 Rails Migration 随着功能的开发逐步创建表； 随着细节功能的开发、需求，逐步增加字段，删除字段，或者调整字段类型； 第一个 Release 的时候清理 Migrations 合并成一个;...