并发和并行

并发：指的是任务数多余cpu核数，通过操作系统的各种任务调度算法，实现用多个任务“一起”执行（实际上总有一些任务不在执行，因为切换任务的速度相当快，看上去一起执行而已）
并行：指的是任务数小于等于cpu核数，即任务真的是一起执行的

进程：操作系统资源分配的基本单位，

一般开辟进程会开辟5M的内存空间，随着使用需要不断像系统请求资源，所以有的程序刚开始占用资源很小，时间异常就占用很多资源
一个进程默认有一个线程，进程里面可以创建线程，线程是依附在进程里面的，没有进程就没有线程。
进程的状态

进程的状态

就绪态：运行的条件都已经满足，正在等待cpu执行
执行态：cpu真在执行其功能
等待态：等待某些条件满足，例如一个程序sleep了，此时就处于等待状态

python3中进程使用：

进程之间不共享全局变量
import multiprocessing
Process进程类的语法结构如下：
Process([group [, target [, name [, args [, kwargs]]]]])

group：指定进程组，目前只能使用None
target：执行的目标任务名
name：进程名字
args：以元组方式给执行任务传参
kwargs：以字典方式给执行任务传参
Process创建的实例对象的常用方法：

start()：启动子进程实例（创建子进程）
join([timeout])：是否等待子进程执行结束，或等待多少秒
terminate()：不管任务是否完成，立即终止子进程
Process创建的实例对象的常用属性：
daemon = True：设置守护主进程，默认为False
name：当前进程的别名，默认为Process-N，N为从1开始递增的整数
pid：当前进程的pid（进程号）

进程间通信-Queue

初始化Queue()对象时（例如：q=Queue()），若括号中没有指定最大可接收的消息数量，或数量为负值，那么就代表可接受的消息数量没有上限（直到内存的尽头）；

Queue.qsize()：返回当前队列包含的消息数量；

Queue.empty()：如果队列为空，返回True，反之False , 注意这个操作是不可靠的。

Queue.full()：如果队列满了，返回True,反之False；

Queue.get([block[, timeout]])：获取队列中的一条消息，然后将其从列队中移除，block默认值为True；

1）如果block使用默认值，且没有设置timeout（单位秒），消息列队如果为空，此时程序将被阻塞（停在读取状态），直到从消息列队读到消息为止，如果设置了timeout ，则会等待timeout秒，若还没读取到任何消息，则抛出”Queue.Empty”异常；

2）如果block值为False，消息列队如果为空，则会立刻抛出”Queue.Empty”异常；

Queue.get_nowait()：相当Queue.get(False)；

Queue.put(item,[block[, timeout]])：将item消息写入队列，block默认值为True；

1）如果block使用默认值，且没有设置timeout（单位秒），消息列队如果已经没有空间可写入，此时程序将被阻塞（停在写入状态），直到从消息列队腾出空间为止，如果设置了timeout，则会等待timeout秒，若还没空间，则抛出”Queue.Full”异常；

2）如果block值为False，消息列队如果没有空间可写入，则会立刻抛出”Queue.Full”异常；

Queue.put_nowait(item)：相当Queue.put(item, False)；

进程池Pool

池子里面放的是进程，进程池会根据任务执行情况自动创建进程，而且尽量少创建进程，合理利用进程池中的进程完成多任务
multiprocessing.Pool常用函数解析：

apply(func[, args[, kwds]]): 阻塞方式调用函数，args表示以元组方式给函数传参，kwds表示以字典方式给函数传参
apply_async(func[, args[, kwds]]) ：使用非阻塞方式调用函数，args表示以元组方式给函数传参，kwds表示以字典方式给函数传参
close()：关闭Pool，使其不再接受新的任务；
terminate()：不管任务是否完成，立即终止；
join()：主进程阻塞，等待子进程的退出，必须在close或terminate之后使用；

线程：

线程就是在程序运行过程中，执行程序代码的一个分支，每个运行的程序至少都有一个线程
一般新创建一个线程开辟512KB的空间

注意点：

线程之间执行是无序的
2.启动线程统一调用start方法，不要直接调用run方法, 因为这样不是使用子线程去执行任务

全局变量数据错误的解决办法

1.线程等待(join)
2.互斥锁
互斥锁: 对共享数据进行锁定，保证同一时刻只能有一个线程去操作。

创建锁
mutex = threading.Lock()
锁定
mutex.acquire()
释放
mutex.release()

自定义线程

import threading

class MyThread(threading.Thread):
def init(self, info1, info2):
# 调用父类的构造方法
super(MyThread, self).init()
self.info1 = info1
self.info2 = info2

def test1(self):
    print(self.info1)

def test2(self):
    print(self.info2)

def run(self):
    self.test1()
    self.test2()

my_thread = MyThread(“test1”, “test2”)
my_thread.start()

协程

一般开辟一个协成只需要5k的空间，