一个时间间隔内，多个任务同时进行

进程

进程是能拥有资源和独立运行的最小单位，也是程序执行的最小单位
- 动态性：进程是程序一次执行的过程，是临时的，有生命周期的，是动态产生，动态消亡的
- 并发性：任何进程都可以同其他进程一起并发执行
- 独立性：进程是系统进行资源分配和调度的一个独立单位
- 结构性：进程由程序，数据和进程控制三部分组成
线程是包含于线程之类的

线程

线程是程序执行中一个单一的顺序控制流程，是程序执行的最小单元是处理器调度和分派的基本单位

进程与线程的区别

1.进程是执行程序的最小单位，儿进程是操作系统分配资源的最小单位
2.一个进程由一个或多个线程组成，线程是一个进程中代码不同执行的路线
3.进程之间相互独立，但同一进程下的各个线程之间共享的内存空间（包括代码段，数据集，堆等）及一些进程及的资源（如打开文件和信号），某进程内的线程在其他进程可见
4.调度和切换：线程上下文切换比进程上下文切换要快的多
线程和进程都是一种抽象的概念，线程是一种比进程更下的抽象，线程和进程都可用于实现并发

单线程

在单线程中，当处理器需要处理多个任务是，必须对这些任务安排执行顺序，并按照这个顺序来执行任务。

Python中的多线程

Python的多线程是伪多线程

Python多线程模块

• thread模块
• threading模块（推荐）

基本步骤

threading

threading。Thread（self,group=None,target=None,name=
None,args=(),kwargs={}）
Thread是threading模块中最重要的类之一，可以使用他来创建线程。有两种方式来创建线程：一是通过继承Thread类，重写它的run方法；另一种是创建threading.Thread对象，在它的初始化函数（ __init __）中将可调对象作为参数传入。
- 参数group是预留，用于将来扩展
- 参数target是一个可调用对象（也称为活动[activity]），在线程启动后执行
- 参数name是线程名字。默认值为“Thread-N”，N是一个数字

#多线程
def music(name,loop):
    for i in range(loop):
        print('listen music %s %s %s'%(name,time.ctime(),threading.Thread.getName(t1)))
        time.sleep(1)
def movie(name,loop):
    for i in range(loop):
        print('look movie %s %s %s'%(name,time.ctime(),threading.Thread.getName(t2)))
        time.sleep(1)
#1.创建多线程
t1 = threading.Thread(target= music,args=('爱的故事上集',4))
t1.setName('musicThread')
t2 = threading.Thread(target= movie,args=('肖生克的救赎',4),name = 'movieThread')
if __name__ == '__main__':
    #4.守护主线程，主线程结束杀死子线程(相当于参数为True时，没有执行线程阻塞，那么主线程运行之后就会把子线程杀死)
    t1.setDaemon(True)
    t2.setDaemon(True)

    #2.启动线程
    t1.start()
    t2.start()
    # print('end time %s'%time.ctime())
    #打印进程ID
    print(t1.ident)
    print(t2.ident)

    #3.join 可以对主线程进行阻塞，等所有的子线程运行结束在运行主线程
    t1.join()
    t2.join()

    print('主线程：%s'%time.ctime())

GIL全局解释简介

避免线程抢资源，谁有锁就有权限（加锁之后就相当于单线程）

多进程

• 用multiprocessing替代Thread
• multiprocessing库的出现很多程度上是为了弥补thread库因为GIL低效的缺陷。它完整的复制了一套thread所提供的的接口迁移。唯一的不同就是它使用多进程而不是多线程。每个进程有自己独立的GIL，完全并行，无GIL的限制（进程中包括线程），可充分利用多CPU多核的环境，因此也不会出现进程之间的GIL争抢
• 模块名multiprocessing

单进程

def work_1(f,n):
    print('work_1 start')
    for i in range(n):
        with open(f,'a') as fs:
            fs.write('i love pyhton \n')
            time.sleep(1)
    print('work_1 end')
def work_2(f,n):
    print('work_2 start')
    for i in range(n):
        with open(f,'a') as fs:
            fs.write('come on baby \n')
            time.sleep(1)
    print('work_2 end')
if __name__ == '__main__':
    work_1('file.txt',3)
    work_2('file.txt',3)

多进程

def work_1(f,n):
    print('work_1 start')
    for i in range(n):
        with open(f,'a') as fs:
            fs.write('i love pyhton \n')
            time.sleep(1)
    print('work_1 end')
def work_2(f,n):
    print('work_2 start')
    for i in range(n):
        with open(f,'a') as fs:
            fs.write('come on baby \n')
            time.sleep(1)
    print('work_2 end')
if __name__ == '__main__':
    p1 = multiprocessing.Process(target=work_1,args = ('file.txt',3))
    p2 = multiprocessing.Process(target=work_2, args=('file.txt', 3))

    p1.start()
    p2.start()

加锁

def work_1(f,n,lock):
    print('work_1 start')
    lock.acquire()
    for i in range(n):
        with open(f,'a') as fs:
            fs.write('i love pyhton \n')
            time.sleep(1)
    print('work_1 end')
    lock.release()
def work_2(f,n,lock):
    print('work_2 start')
    lock.acquire()
    for i in range(n):
        with open(f,'a') as fs:
            fs.write('come on baby \n')
            time.sleep(1)
    print('work_2 end')
    lock.release()
if __name__ == '__main__':
    lock=multiprocessing.Lock()
    p1 = multiprocessing.Process(target=work_1,args = ('file.txt',3,lock))
    p2 = multiprocessing.Process(target=work_2, args=('file.txt', 3,lock))

    p1.start()
    p2.start()

Queue

import multiprocessing
import time
#queue 跨进程通信
def put(q):
   for value in ['A', 'B', 'C']:
       print ('发送 %s 到 queue...' % value)
       q.put(value)  #通过put发送
       time.sleep(2)
## 读数据进程执行的代码:
def get(q):
   while True:
       value = q.get(True) #接受队列中的数据
       print ('从 queue 接受 %s .' % value)
if __name__=='__main__':
   # 父进程创建Queue，并传给各个子进程：
   q = multiprocessing.Queue()
   pw = multiprocessing.Process(target=put, args=(q,))
   pr = multiprocessing.Process(target=get, args=(q,))
   # 启动子进程pw，写入:
   pw.start()
   # 启动子进程pr，读取:
   pr.start()
   # 等待pw结束:
   pw.join()
   # pr进程里是死循环，无法等待其结束，只能强行终止:
   pr.terminate()

Pipe管道

#-*- conding:utf-8 -*-
import multiprocessing
import time
#PIPE 管道通信
def put(p):
   for value in ['A', 'B', 'C']:
       print ('发送 %s 到 pipe...' % value)
       p[1].send(value)
       time.sleep(2)

# 读数据进程执行的代码:
def get(p):
   while True:
       value = p[0].recv()
       print ('从 pipe 接受 %s .' % value)

if __name__=='__main__':
   # 父进程创建Queue，并传给各个子进程：
   # p = multiprocessing.Pipe()
   p = multiprocessing.Pipe(duplex=False) #左收右发
   pw = multiprocessing.Process(target=put, args=(p,))
   pr = multiprocessing.Process(target=get, args=(p,))
   # 启动子进程pw，写入:
   pw.start()
   # 启动子进程pr，读取:
   pr.start()
   # 等待pw结束:
   pw.join()
   # pr进程里是死循环，无法等待其结束，只能强行终止:
   pr.terminate()