多进程、多线程

1.multiprocessing是Python中多进程的模块，使用它能实现多线程代码编写

2.启动子线程并结束子线程

先定义一个创建线程的方法，再在主方法中调用Process()函数创建子线程

以及父线程，再调用start()方法以及join()函数实现进程的启动

def run_proc(name):
  print('Run child process %s(%s)' %(name,os.getpid()))
if __name__ =='__main__':
  print('Parent process %s.' %os.getpid())
  p = Process(target = run_proc,args = ('test',))
  print('Child process will start.')
  p.start()
  p.join()
  print('Child process end.')

3.创建线程池，先创建定义子线程的方法，再在主方法中通过Pool函数配合自己电脑的CPU处理器个数，

再利用Pool函数的实例apply.async方法创建线程池

from multiprocessing import Pool
import os,time,random #random为随机函数
#该方法用于子线程内容的实现
def long_time_task(name):
  print('Run task %s(%s)...'% (name,os.getpid()))
  start = time.time()
  time.sleep(random.random()*3)
  end = time.time()
#显示开始和结束时间
  print('Task %s runs %0.2f seconds' %(name,(start-end)))

if __name__ == '__main__':
  print('Parent process %s.' %os.getpid())
  p = Pool(8)  #表示线程量
  for i in range(9):
#这个函数类似于创建线程池
    p.apply_async(long_time_task,args=(i,))
  print('Waiting for all subprocesses done...')
  p.close()
  p.join()
  print('ALL subprocesses done.')

4.线程间的通信通过Queue、Pipes方法来实现

先创建写方法，像里面传入数据，通过put方法传入，再定义读方法，从Queue中读取数据通过get方法

再通过Process方法创建两个读写变量，调用start方法和join方法最后调用terminate方法终止死循环

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.start()
  #等待pw结束：
  pw.join()
#pr进程是死循环，无法等待其结束，只能强行终止：
pr.terminate()

5.启动线程就是把一个函数传入并创建一个实例，我们通过threading模块中的threading.Thread方法来创建线程实例

threading。current_thread().name方法获得当前线程

def loop():#定义方法来创建一个线程通过循环获得信息
  print('thread %s is running...'% threading.current_thread().name)
  n = 0
  while n<5
    n = n+1
    print('thread %s >>>%s'%(threading.current_thread.name,n))
    time.sleep(1)#通过time.sleep()函数休眠一会儿输出
  print('threading %s ended.' %threading.current_thread().name)
print('thread %s is running...'% threading.current_thread().name)
# 通过threading Thread()函数传入创建线程方法名以及线程名创建实例线程
t = threading.Thread(target = loop,name = 'LoopThread')
t.start()
t.join()
print('thread %s ended.'%threading.current_thread().name)

6.由于线程之间的运行是交替的，所以需要通过Lock来规范线程的运行

先要声明一个锁变量，再获取锁，最后通过try-finally语句释放锁，再调用锁实例来启动线程和关闭线程

7.多核CPU

在Python中任意线程在执行前，都会先获得一个GIL锁，没执行100行代码，就会释放资源，让其他的线程执行