什么是多任务？
就是操作系统可以同时运行多个任务
多任务的执行方式
并发：交替执行，是假的多任务
并行：同时执行，是真的多任务
第一种多任务的实现方式：多线程
python线程的两种写法(第一种会比较常用)：
第一种：
def say():
print("我在说话")
def sing():
print("我在唱歌")
time.sleep(1)
if name == "main":
t1 = threading.Thread(target=say)
t2 = threading.Thread(target=sing)
t1.start()
t2.start()
第二种，通过继承Thread类完成创建线程：
class MyThread(threading.Thread):
def run(self):
for i in range(3):
time.sleep(1)
msg = "I'm " + self.name + " @ " + str(i) # name属性中保存的是当前线程的名字
print(msg)
if name == "__main":
t = MyThread()
t.start()
主线程等待所有子线程执行完才结束
多线程中的全局变量
多线程允许共享全局变量，但全局变量存在资源竞争的问题，导致计算出的结果与预期不符。比如相加到一定数值，得到的结果可能会比预期的小，数值越大结果越明显。
这是因为线程A可能运行到一半，线程B就开始运行，两个线程都竞争全局变量的时候会出现资源竞争问题。
解决资源竞争的问题是使用同步概念，用互斥锁解决，线程A运行时候上了互斥锁，线程B需要等到线程A完成程序后才能运行，这样就避免了资源竞争。
但互斥锁又可能引发死锁的问题。当线程A拥有X锁等待Y锁，线程B拥有Y锁等待X锁，两者都堵塞了在请求对方拥有的资源，导致死锁。
解决死锁的方法有两种：
1，程序实现时尽量避免（银行家算法）
2，添加超时时间
第二种多任务的实现方式：多进程
理解进程和程序：
通俗的讲，运行中的叫进程，没运行的叫程序，程序只有一个，而进程可以有多个
多进程python实现：
def say():
print("我在说话")
def sing():
print("我在唱歌")
time.sleep(1)
if name == "main":
t1 = multiprocessing.Process(target=say)
t2 = multiprocessing.Process(target=sing)
t1.start()
t2.start()
进程，线程对比
进程是资源分配的基本单位，线程是操作系统调度的基本单位（执行即调度），一个进程至少有一个主线程，线程依赖于进程，没有进程就没有线程
多进程通信
多进程之间通过队列来实现数据共享：
def download():
# 模拟从网上下载数据
data = [11, 22, 33, 44]
# 向队列中写入数据
for temp in data:
q.put(temp)
print("---下载器已经下载完了数据并且存入到队列中---")
def analysis(q):
waitting_analysis_data = list()
# 从队列中获取数据
while True:
data = q.get()
waitting_analysis_data.append(data)
if q.empty():
break
# 模拟数据处理
print(waitting_analysis_data)
def main():
# 1.创建一个队列
q = multiprocessing.Queue()
# 2.创建多个进程，将队列的引用当作实参进行传递到里面
p1 = multiprocessing.Process(target=download, args=(q,))
p2 = multiprocessing.Process(target=analysis, args=(q,))
p1.start()
p2.start()
if name == "main":
main()
进程池Pool
进程池Pool的作用是缓冲，减少进程创建和销毁
进程池用python实现如下：
def worker(msg):
t_start = time.time()
print("%s开始执行，进程号为%d" % (msg, os.getpid()))
# random.random()随机生成0-1之间的浮点数
time_sleep(random.random()*2)
t_stop = time.time()
print(msg, "执行完毕，耗时%0.2f" % (t_stop-t.start))
po = Pool(3)
for i in range(0, 10):
# Pool().apply_async(要调用的目标, (传递给目标的参数元祖,))
# 每次循环将会用空闲出来的子进程去调用目标
po.apply_async(worker,(i,))
print("-----start-----")
po.close() # 关闭进程池，关闭后po不再接收新的请求
po.join() # 等待po中所有子进程执行完成，必须放在close语句之后
print("-------end------")
第三种多任务的实现方式：协程
迭代器
数据类型可不可迭代：
可迭代：字符串，列表，元组，字典，集合
不可迭代：数字
如果想要一个对象成为一个可以迭代的对象，即可以使用for，那么必须实现iter方法，返回一个对象的引用。iter()函数会自动调用iter的返回值，iter方法的返回值是一个迭代器。
class Classmate(object):
def init(self):
self.names = list()
self.current_num = 0
def add(self, name):
self.names.append(name)
def __iter__(self):
return self
def __next__(self):
if self.current_num < len(self.names):
ret = self.names[self.current_num]
self.current_num = 1
else:
raise StopIteration
classmate = Classmate()
classmate.add("老王")
classmate.add("王二")
classmate.add("张三")
print("是否可迭代：", isinstance(classmate, Iterable))
classmate_iterator = iter(classmate)
print("是否是迭代器", isinstance(classmate_iterator, Iterator))
print(next(classmate_iterator))
for name in classmate:
print(name)
生成器
生成器是特殊的迭代器。所以生成器也可以迭代要创建一个生成器
第一种方法，只要把一个列表生成式的[]改成():
a = [x2 for x in range(5)] # a是一个列表
b = (x2 for x in range(5)) # b是一个生成器，
第二种方法
如果一个函数中有yield语句，那么这个就不再是函数，而是一个生成器，如果在调用一个函数时。发现这个函数里有yield,不是调用函数，而是创建一个生成器。
def create_num(all_num):
print("------1------")
# a, b = 0, 1
current_num = 0
while current_num < all_num:
print("------2------")
# print(a)
yield a
print("------3------")
a, b = b, a+b
current_num += 1
print("------4------")
obj = create_num(10)
ret = next(obj)
print(ret)
ret = next(obj)
print(ret)
输出结果：
------1------
------2------
0
------3------
------4------
------2------
1
生成器第二次迭代的时候并不会从头开始执行，而是从上一次生成器暂停的位置开始执行
协程
用yeild实现多任务，其实也就叫协程，下面例子t1和t2两个任务交替执行
def task_1():
while True:
print("------1-----")
time.sleep(0.1)
yield
def task_2():
while True:
print("-----2-----")
time.sleep(0.1)
yield
def main():
t1 = task_1()
t2 = task_2()
# 先让t1运行一会，当t1中遇到yield的时候，再返回到24行，然后
# 执行t2,当它遇到yield的时候，再次切换到t1中
# 这样t1/t2/t1/t2的交替运行，最终实现了多任务，协程
while True:
next(t1)
next(t2)
切换开销：协程<线程<进程
实际项目中实现协程一般是用greenlet、gevent完成多任务，只要在程序中加入monkey.patch_all()，就可以将程序中用到的耗时操作
的代码换成gevent中自己实现的模块
monkey.patch_all()
def coroutune_work(coroutinue_name):
for i in range(10):
print(coroutinue_name, i)
time.sleep(random.random())
gevent.joinall([
gevent.spawn(coroutine_work, "work1")
gevent.spawn(coroutine_work, "work2")
])
总结
进程是资源分配的基本单位
线程是操作系统调度的基本单位
进程切换开销大，效率低
线程切换开销一般，效率一般（不考虑GIL锁的情况）
协程切换开销最小，效率高
多进程，多线程根据cpu核数不一样可能是并行的，但协程是在一个线程中，所以是并发