python 进程和线程-简介及进程

进程和线程的关系及应用

参考链接：https://www.liaoxuefeng.com/wiki/1016959663602400/1017627212385376

多任务：

　　什么叫“多任务”呢？简单地说，就是操作系统可以同时运行多个任务。打个比方，你一边在用浏览器上网，一边在听MP3，一边在用Word赶作业，这就是多任务，至少同时有3个任务正在运行。

单核CPU执行多任务：

　　操作系统轮流让各个任务交替执行，任务1执行0.01秒，切换到任务2，任务2执行0.01秒，再切换到任务3，执行0.01秒……这样反复执行下去。表面上看，每个任务都是交替执行的，但是，由于CPU的执行速度实在是太快了，我们感觉就像所有任务都在同时执行一样。

多核CPU

　　真正的并行执行多任务只能在多核CPU上实现，但是，由于任务数量远远多于CPU的核心数量，所以，操作系统也会自动把很多任务轮流调度到每个核心上执行。

进程和线程

　　对操作系统来说，一个任务就是一个进程（Process）

　　有的进程，不止干一件事，比如word，它可以同时进行打字、拼写检查、打印等事情。在一个进程内部，要同时干多件事，就需要同时运行多个“子任务”，我们把进程内的这些“子任务”称为线程（Thread）。

　　由于每个进程至少要干一件事，所以，一个进程至少有一个线程。当然，像Word这种复杂的进程可以有多个线程，多个线程可以同时执行，多线程的执行方式和多进程是一样的，也是由操作系统在多个线程之间快速切换，让每个线程都短暂地交替运行，看起来就像同时执行一样。当然，真正地同时执行多线程需要多核CPU才可能实现。

怎样同时执行多个任务：

有两种解决方案：

　　一种是启动多个进程，每个进程虽然只有一个线程，但多个进程可以一块执行多个任务。

　　还有一种方法是启动一个进程，在一个进程内启动多个线程，这样，多个线程也可以一块执行多个任务。

　　当然还有第三种方法，就是启动多个进程，每个进程再启动多个线程，这样同时执行的任务就更多了，当然这种模型更复杂，实际很少采用。

总结一下就是，多任务的实现有3种方式：

多进程模式；
多线程模式；
多进程+多线程模式。

带来的困难

　　同时执行多个任务通常各个任务之间并不是没有关联的，而是需要相互通信和协调，有时，任务1必须暂停等待任务2完成后才能继续执行，有时，任务3和任务4又不能同时执行，所以，多进程和多线程的程序的复杂度要远远高于我们前面写的单进程单线程的程序。

　　因为复杂度高，调试困难，所以，不是迫不得已，我们也不想编写多任务。但是，有很多时候，没有多任务还真不行。想想在电脑上看电影，就必须由一个线程播放视频，另一个线程播放音频，否则，单线程实现的话就只能先把视频播放完再播放音频，或者先把音频播放完再播放视频，这显然是不行的。

小结

线程是最小的执行单元，而进程由至少一个线程组成。如何调度进程和线程，完全由操作系统决定，程序自己不能决定什么时候执行，执行多长时间。

多进程和多线程的程序涉及到同步、数据共享的问题，编写起来更复杂。

多进程（multiprocessing）

参考链接：https://www.liaoxuefeng.com/wiki/1016959663602400/1017628290184064

Unix/Linux上使用python实现多进程

　　fork（），返回两次略

windows上

　　multiprocessing模块是跨平台版本的多进程模块，他提供的一个Process类来代表一个进程对象

　　创建子进程时，只需要传入一个执行函数和函数的参数，创建一个Process实例，用start()方法启动，这样创建进程比fork()还要简单。

　　下面的例子演示了启动一个子进程并等待其结束：

import os

from multiprocessing import Process

#子进程要执行的代码

def run_process(name):

	print('子进程Id是%s,传过来的参数是%s'%(os.getpid(),name))

if __name__ == "__main__":

	r=Process(target=run_process,args=('参数1',))

	r.start()

	r.join()

#输出

子进程Id是17020,传过来的参数是参数1

　　join()方法可以等待子进程结束后再继续往下运行，通常用于进程间的同步。

Pool

如果要启动大量的子进程，可以使用进程池的方式批量创建子进程

import os,random,time

from multiprocessing import Pool

def run_process(name):

	print('子进程Id:%s开始执行,传过来的参数是%s'%(os.getpid(),name))

	time.sleep(random.random())#这是为了增加进程的执行时间，以便观测到同时执行进程的最大个数

	print('子进程Id:%s执行结束'%(os.getpid()))

if __name__ == "__main__":

	p=Pool(4)#通过4来指定进程池中能同时执行的进程数

	for i in range(5):

		p.apply_async(run_process,args=(i,))#这样向进程池中添加进程来创建

	p.close()#使用close（）来关闭向进程池中添加进程

	p.join()

#输出

子进程Id:22808开始执行,传过来的参数是0

子进程Id:2992开始执行,传过来的参数是1

子进程Id:16776开始执行,传过来的参数是2

子进程Id:16304开始执行,传过来的参数是3

子进程Id:2992执行结束

子进程Id:2992开始执行,传过来的参数是4

子进程Id:22808执行结束

子进程Id:2992执行结束

子进程Id:16304执行结束

子进程Id:16776执行结束

　　对Pool对象调用join()方法会等待所有子进程执行完毕，调用join()之前必须先调用close()，调用close()之后就不能继续添加新的Process了。

　　pool的默认大小是CPU的核数

子进程

　　很多时候，子进程并不是自身，而是一个外部进程，这就涉及到输入和输出

　　subprocess模块可以方便的启动一个子进程，并且控制它的输入和输出

　　下面的例子演示了如何在Python代码中运行命令nslookup www.python.org，这和命令行直接运行（命令行并不能直接运行他）的效果是一样的：

import subprocess

print('$ nslookup www.python.org')

r = subprocess.call(['nslookup', 'www.python.org'])

print('Exit code:', r)#r可以看作是上是’nslookup www.python.org‘命令执行后的返回状态码

#输出

$nslookup www.python.org

服务器:  UnKnown

Address:  10.0.100.101

非权威应答:

名称:    dualstack.python.map.fastly.net

Addresses:  2a04:4e42:6::223

          151.101.24.223

Aliases:  www.python.org

Exit code  0

　　如果子进程还需要输入，则可以通过communicate()方法输入：

import subprocess

print('$ nslookup')

p = subprocess.Popen(['nslookup'], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

output, err = p.communicate(b'set q=mx\npython.org\nexit\n')

print(output.decode('gbk'))#windows默认使用的字符编码

print('Exit code:', p.returncode)

#输出

$ nslookup

Server:		192.168.19.4

Address:	192.168.19.4#53

Non-authoritative answer:

python.org	mail exchanger = 50 mail.python.org.

Authoritative answers can be found from:

mail.python.org	internet address = 82.94.164.166

mail.python.org	has AAAA address 2001:888:2000:d::a6

Exit code: 0

　　上面的代码相当于在命令行执行命令nslookup，然后手动输入：

set q=mx

python.org

exit

进程间的通信

　　Process之间肯定是需要通信的，操作系统提供了很多机制来实现进程间的通信。Python的multiprocessing模块包装了底层的机制，提供了Queue、Pipes等多种方式来交换数据。

　　我们以Queue为例，在父进程中创建两个子进程，一个往Queue里写数据，一个从Queue里读数据：

from multiprocessing import Process, Queue

import os, time, random

# 写数据进程执行的代码:

def write(q):

    print('Process to write: %s' % os.getpid())

    for value in ['A', 'B', 'C']:

        print('Put %s to queue...' % value)

        q.put(value)

        time.sleep(random.random())

# 读数据进程执行的代码:

def read(q):

    print('Process to read: %s' % os.getpid())

    while True:

        value = q.get(True)

        print('Get %s from queue.' % value)

if __name__=='__main__':

    # 父进程创建Queue，并传给各个子进程：

    q = Queue()

    pw = Process(target=write, args=(q,))

    pr = Process(target=read, args=(q,))

    # 启动子进程pw，写入:

    pw.start()

    # 启动子进程pr，读取:

    pr.start()

    # 等待pw结束:

    pw.join()

    # pr进程里是死循环，无法等待其结束，只能强行终止:

    pr.terminate()

#输出

Process to write: 50563

Put A to queue...

Process to read: 50564

Get A from queue.#会一次从queue中读取所有的，比如将wirte中改为，put两次

Put B to queue...

Get B from queue.

Put C to queue...

Get C from queue.

　　在Unix/Linux下，multiprocessing模块封装了fork()调用，使我们不需要关注fork()的细节。由于Windows没有fork调用，因此，multiprocessing需要“模拟”出fork的效果，父进程所有Python对象都必须通过pickle序列化再传到子进程去，所有，如果multiprocessing在Windows下调用失败了，要先考虑是不是pickle失败了。

小结

　　在Unix/Linux下，可以使用fork()调用实现多进程。

　　要实现跨平台的多进程，可以使用multiprocessing模块。

　　进程间通信是通过Queue、Pipes等实现的。