并发多任务（线程、进程、协程）

一、线程

1、一般多线程

import time
import threading


def sing():
    for i in range(5):              #调用Thread不会创建线程，
        print("----test----")       #调用Thread创建的实例对象start会创建
        time.sleep(1)

def main():
    print(threading.enumerate())    #调用Thread之前打印
    t1 = threading.Thread(target=sing)  #调函数名，告诉函数在哪
    print(threading.enumerate())    #调用Thread之后打印
    t1.start()   
    print(threading.enumerate())    #调用start之后打印


if __name__ == '__main__':
    main()

　　target指定线程去哪执行代码，args指定将来调用传递的数据

　　当线程t1.start()运行时，会先运行下一行代码，因此运行结果为：

[<_MainThread(MainThread, started 139815265257216)>]
[<_MainThread(MainThread, started 139815265257216)>]
----test----
[<_MainThread(MainThread, started 139815265257216)>, <Thread(Thread-1, started 139815239530240)>]
----test----
----test----
----test----
----test----

2、封装多线程为类

import threading
import time


class MyThread(threading.Thread):
    def run(self):
        for i in range(3):
            time.sleep(1)
            msg = "I'm "+self.name+'@'+str(i)
            print(msg)
            self.login()

    def login(self):
        print("登陆")


if __name__ =='__main__':
    t = MyThread()
    t.start()

　　MyThread会先自动调用run方法，再通过run方法引入其他函数self.funtion

3、防止CPU资源竞争-互斥锁

#创建互斥锁，默认没有上锁
mutex = threading.Lock()

def test1(temp):
    global g_num
    #上锁 如果之前没有被上锁，那么此时上锁成功
    #如果之前上锁了，那么此时会被堵塞，直到解锁
    mutex.acquire()
    for i in range(temp):
        g_num += 1
    #解锁
    mutex.release()
    print("---in test1 temp=%d---" % g_num)

　　将互斥锁加在for循环内会影响过程变化，执行顺序不同

二、进程

1、内容

　　进程是资源分配单位，线程是调度单位，线程比进程节省资源；

　　进程：工厂流水线，线程：工人，线程依赖于进程

import multiprocessing
from threading import Thread
import time


def test1():
    while True:
        print("1------")
        time.sleep(1)

def test2():
    while True:
        print("2------")
        time.sleep(1)

def main():
    t1 = multiprocessing.Process(target=test1)    
    t2 = multiprocessing.Process(target=test2)    
    t1.start()
    t2.start()

if __name__ == "__main__":
    main()

2、队列

　　先入先出原则，使用put()方法写入，get()方法取出

import  multiprocessing
import time


def download(q):
    data = [11, 22, 33, 44]
    #向队列中写入数据
    for temp in data:
        q.put(temp)
    print('已下载完并存入队列')

def analysis_data(q):
    '''数据处理''' 
    #从队列中获取数据
    waitting_analysis_data = list()
    while True:
        data = q.get()
        print(data)
        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,))
    print('---p1------')
    p2 =multiprocessing.Process(target=analysis_data, args=(q,))
    print('---p2------')
    p1.start()
    
    print('---p1s-----')
    p2.start()
    print('---p2s-----')


if __name__ =='__main__':
    main()

3、进程池

from multiprocessing import Pool
import os,time,random

def worker(msg):
    t_start = time.time()
    print("%S开始执行，进程号为%d" % (msg,os.getid()))
    #random.random随机生成0~1质检的浮点数
    time.sleep(random.random()*2)
    t_stop = time.time()
    print(msg,"执行完毕，耗时%0.2f" % (t_stop-t_start))

po = Pool(3)    #定义一个进程池，最大进程数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----')

4、显示进度

import os
from multiprocessing import Pool
import multiprocessing
from multiprocessing import Manager


def copy_file(q,file_name, old_folder, new_folder):
    #完成文件的复制
    print("模拟copy文件:从%s复制%s到%s" % (old_folder, file_name, new_folder))
    older_f =  open(old_folder + "/" + file_name, "rb")
    content = older_f.read()
    older_f.close()
    
    new_f = open(new_folder + "/" +file_name, "wb")
    new_f.write(content)
    new_f.close()
    #如果拷贝完文件，那么向队列写入一个消息表示完成
    q.put(file_name)


def main():
    #1.获取用户要copy的文件夹名字
    old_folder = input("请输入文件夹名字:")
        
    #2.创建一个新的文件夹
    try:
        new_folder = old_folder + "[复件]"
        os.mkdir(new_folder)
    except:
        pass

    #3.获取文件夹的所有待copy文件名字
    file_names = os.listdir(old_folder)
    print(file_names)

    #4.创建进程池
    po = Pool(5)
    #6.创建一个队列
    q = Manager().Queue()

    #5.向进程池中添加copy文件的任务
    for file_name in file_names:
        po.apply_async(copy_file, args=(q, file_name, old_folder, new_folder))
        

    #复制文件夹中的文件，到新文件夹中的文件去
    
    po.close()
   # po.join()
    all_file_num = len(file_names)
    copy_num = 0
    while True:
        file_name = q.get()
        #print("已经完成copy: %s" % file_name)
        copy_num+=1
        print("
拷贝进度为: %.2f %%" % (copy_num*100/all_file_num),end="")
        if all_file_num == copy_num:
            break

    print()


if __name__ == "__main__":
    main()

三、协程

1、迭代与迭代器

from collections import Iterable
from collections import Iterator
import time

class Classmate(object):
    def __init__(self):
        self.names = list()
        self.current_num = 0
    def add(self, name):
        self.names.append(name)

    def __iter__(self):
        '''如果想要一个对象称为一个 可以迭代的兑现，可以使用for,那么必须实现__iter__方法'''
        return self
                                            #1.判断xxx.obj是否可以迭代
                                            #2.调用iter函数得到xxx_obj的_iter_方法返回值
                                             #3.返回值是一个迭代器
    def __next__(self):
        if self.current_num < len(self.names):
            ret = self.names[self.current_num]
            self.current_num += 1
            return ret
        else:
            raise StopIteration

classmate = Classmate()
classmate.add("老王")
classmate.add("老二")
classmate.add("张三")

print(iter(classmate))
print("判断classmate是否是可以迭代的对象:",isinstance(classmate, Iterable))
#classmate_iterator = iter(classmate)
#print("判断classmate是否是可以迭代的对象:",isinstance(classmate_iterator, Iterable))
#print(next(classmate_iterator))

for name in classmate:
    print(name)
    time.sleep(1)

2、生成器与传递值

def create_num(all_num):
    a, b = 0, 1
    current_num = 0
    while current_num < all_num:
        ret = yield a     #第一次暂停，返回a = 0给next(obj)，send值传递给ret
        print('>>>ret>>>', ret)
        a, b = b, a+b
        current_num += 1

obj = create_num(10)

ret = next(obj)
print(ret)

ret = obj.send('hahhah')    #hahha传递给yield a
print(ret)

　　当函数运行到yield时，函数先暂停运行，并跳过该函数继续往下运行直到遇到next()

import time


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，当遇到yield时，返回到24行
    #然后执行t2，遇到yield时切换到t1中
    #t1/t2交替运行实现多任务，并发协程
    while True:
        next(t1)
        next(t2)


if __name__ =="__main__":
    main()

3、greenlet

from greenlet import greenlet
import time

def test1():
    while True:
        print("---1---")
        gr2.switch()
        time.sleep(0.5)

def test2():
    while True:
        print("---2---")
        gr1.switch()
        time.sleep(0.5)

gr1 = greenlet(test1)
gr2 = greenlet(test2)

gr1.switch()

　　在函数中定义greenlet().switch()，当主函数switch()时开始运行，来回切换

4、gevent

import gevent
from gevent import monkey
import time

monkey.patch_all()

def f1(n):
    for i in range(n):
        print(gevent.getcurrent(),i)
        time.sleep(0.5)
def f2(n):
    for i in range(n):
        print(gevent.getcurrent(),i)
        time.sleep(0.5)

def f3(n):
    for i in range(n):
        print(gevent.getcurrent(),i)
        time.sleep(0.5)

print("---1----")
g1 = gevent.spawn(f1, 5)

print("---2----")
g2 = gevent.spawn(f2, 5)

print("---3----")
g3 = gevent.spawn(f3, 5)

print("---4----")

g1.join()
g2.join()
g3.join()

gevent.joinall([
    gevent.spawn(f1,5)    
    gevent.spawn(f2,5)    
    gevent.spawn(f3,5)    
    ])

　　g1 = gevent.spawn(function,arg())

　　g1.join()

　　monkey.patch_all()自动校正延时time.sleep()为gevent.sleep()

　　gevent.joinall([gevent.spawn()])添加多个spawn

 四、总结（个人理解）

1、节省资源方面：协程>线程>进程，程序稳定性方面则反之

2、协程利用线程运行等待的时间，去运行其他任务，切换任务资源小

　  线程资源一般，效率一般

　  进程给线程分配CPU的资源，让线程各自运行任务，切换任务资源大，因此耗费资源最多