什么是任务

        一个电脑运行这的软件

    什么是多任务

        电脑同时运行着的多个软件

    多任务原理

        时间片的轮转

    并行与并发

        并发:假的多任务,多个任务共用一个核

        并行:正的多任务,一个核处理一个程序

    生理过程(从生到死)

        创建 -> 就绪 -> 运行 -> 阻塞 -> 死亡

    线程和进程的创建一定要在主函数中,且主任务和子任务一起往下执行,遇到join()方法,主任务会等子任务执行完在结束

        特点

            查看正在运行的线程列表

            threading.enumerate()

            只要程序已启动，Python解释器就会自动创建一个主线程

            主线程等待其他线程结束后在结束

            线程target指向的函数执行完毕，线程就结束了

            子线程是调用start()之后开启的

            多个线程共享全局变量 

        创建

            通过继承的方式创建线程

                特点：写法复杂，使用简单，可以使用对象的特性(封装、继承、多态)业务逻辑比较复杂时使用

            方式一

                import threading

                p = threading.Thread(target=函数名,args=(1,))
　　　　　　　　　 p.setDaemon(True)  # 开启守护线程

                p.start()

                p.join()

            方式二
　　　　　　　　　　# 线程类

                import threading

                class MyThread(threading.Thread):

                    def run():

                        print（'子线程要做的事'）

                t = MyThread()
　　　　　　　　　 t.setDaemon(True)

                t.start()

                t.join()

        互斥锁

            -->科学家吃面(筷子和碗)

            1.什么是资源竞争？

                多个线程争抢做同一件事

            2.资源竞争会带来什么问题？

                多线程共享同一个资源的时候，当操作这个资源(变量)足够多的次数时，可能会出现问题 eg:1000000次的累加

            3.如何解决资源竞争的问题？

                互斥锁

            4.什么是互斥锁？

                确保了某段关键代码只能由一个线程从头到尾完整地执行

            5.如何使用互斥锁？

                1.创建锁对象

                    mutex = threading.Lock()

                2.获取锁

                    mutex.acquire()

                3.释放锁

                    mutex.release()

            6.原则：

                存在资源竞争的代码，加锁的代码越少越少

            7.死锁

                什么是死锁？

                    线程1等待线程2释放锁，线程2等待线程1释放锁

                如何解决死锁？

                    1.设计写代码的时候就避免

                    2.设置超时时间

                    3.银行家算法

from queue import Queue

q = Queue(maxsize=100)

item = {}

q.put_nowait(item) #不等待直接放，队列满的时候会报错

q.put(item) #放入数据，队列满的时候回等待

q.get_nowait() #不等待直接取，队列空的时候会报错

q.get() #取出数据，队列为空的时候会等待

q.qsize() #获取队列中现存数据的个数

q.join() #队列中维持了一个计数，计数不为0时候让主线程阻塞等待，队列计数为0的时候才会继续往后执行

q.task_done()

# put的时候计数+1，get不会-1，get需要和task_done 一起使用才会-1

　　　　　1.程序：

            就是程序员写的代码，没有运行起来的代码

        2.进程

            运行起来的程序，代码+计算机资源，进程是实现多任务的第二种方式

        3.程序运行起来之后，Python解释器会给程序创建一个进程，叫做主进程

        特点

            1.查看进程

                windows： 任务管理器

                linux：ps -aux

                   杀死进程  kill -9 PID

                   top  htop 相当于windows中的任务管理器

            2.进程的写实拷贝

                写(修改)的时候拷贝一份

                进程不共享全局变量

                通过args给进程传递数据

            3.获取进程id和父进程的id

                os.getpid()

                os.getppid()

            4.主进程等待子进程结束后再结束(主进程替子进程收尸)，进程的运行顺便不确定

        创建

            方式一

                import multiprocessing

                p = multiprocessing.Process(target=函数名,args=(1,))
　　　　　　　　　 p.daemon = True  # 开启守护进程

                p.start()

                p.join()

            方式二

                import multiprocessing

                class MyProcess(multiprocessing.Process):

                    def run():

                        print("子进程要做的事情")

                p = MyProcess()
　　　　　　　　　 p.daemon = True  # 开启守护进程

                p.start()

                p.join()

        进程间通信(传递数据)

            默认情况下，进程之间不能互相访问数据

            队列(Queue)

                常用的方法

                    get()/put()/full()

                每个进程都可以往这个队列中写数据，都可以从这个队列中读取数据

            编码步骤：

                创建队列对象

                给队列中放数据

                从队列中取数据

        进程池(Pool)

            什么是进程池？

                一次性在进程池中创建多个进程

            进程的作用？

                减少了销毁线程的次数，从而提高效率

            如何使用进程池？

                创建进程池对象，调用方法完成任务

            from multiprocessing import Pool

            import os, time, random

            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))

            def main():

                po = Pool(3)  # 定义一个进程池，最大进程数3

                for i in range(0, 10):

                    # Pool().apply_async(要调用的目标,(传递给目标的参数元祖,))

                    # 每次循环将会用空闲出来的子进程去调用目标

                    po.apply_async(worker, (i,))

                print("----start----")

                po.close()  # 关闭进程池，关闭后po不再接收新的请求

                time.sleep(1)

                # po.join()  # 等待po中所有子进程执行完成，必须放在close语句之后

                print("-----end-----")

　　　　　　　# 进程一定要放在入口函数中执行,否则会抛出异常

            if __name__ == '__main__':

                main()    

        什么是可迭代对象

            一个普通的对象实现了iter内置函数

        什么是迭代器

            一个普通的对象实现了iter和next内置函数

        迭代器的特点

            保存的是生成数据的方式，而不直接存储数据，好处：节省系统空间

        什么是生成器

            它是一个特殊的迭代器

        yield

            一个普通的函数里面写了yield的话，他就是一个生成器模板，执行函数遇到yield会阻塞，调用next()或者send()会解阻塞，end()可以用来传递参数

            eg:

                def func(all_num):

                a, b = 0, 1

                count_num = 0

                while True:

                    if count_num < all_num:

                        result = yield a  # 如果一个函数中有yield,则说明这是特殊函数,叫生成器的模板

                        print(">>>>ret>>>>", result)

                        a, b = b, a + b

                        count_num += 1

                    else:

                        raise StopIteration

            f = func(10)

            ret = next(f)

            print(ret)

            ret = f.send("hahaha")   # 将这个结果传递给 result = yield a 让result来保存"hahaha"

            ret1 = next(f)

            print(ret1)      # 结果为None传递一次send后,后面的数据都需要send来传输,否则结果为None

            ret2 = f.send("ok")

        利用yield做协程

            写多个函数，每个函数中都写yield，函数执行时遇到yield就会阻塞，然后交替着调用不同任务的next()方法，这样就用协程实现了多任务

            原理：

                利用线程的空闲时间去执行其他的任务

            特点：

                协程依赖于线程，线程依赖进程，从系统开销讲，进程>线程>协程

        创建协程

            yield  next()  send()

            import gevent

            import time

            from gevent import monkey

            monkey.patch_all()

            def func1(num):

                for i in range(num):

                    print(gevent.getcurrent(), i)

                    time.sleep(0.5)

            def func2(num):

                for i in range(num):

                    print(gevent.getcurrent(), i)

                    time.sleep(0.5)

            def func3(num):

                for i in range(num):

                    print(gevent.getcurrent(), i)

                    time.sleep(0.5)

            def func4(num):

                for i in range(num):

                    print(gevent.getcurrent(), i)

                    time.sleep(0.5)

            def func5(num):

                for i in range(num):

                    print(gevent.getcurrent(), i)

                    time.sleep(0.5)

            def main():

                gevent.joinall([gevent.spawn(func1, 10),

                                gevent.spawn(func2, 10),

                                gevent.spawn(func3, 10),

                                gevent.spawn(func4, 10),

                                gevent.spawn(func5, 10)

                                ])

            if __name__ == "__main__":

                main()