day35

今日内容：

import time
from multiprocessing import Process, Queue
import random
#         自己理解 ：两个进程之间相互进行数据传输就要通过一个中间介质，这个介质即共享文件有四种方法;
#                       1,管道，单向传输，都是二进制
#                       2.文件，是从硬盘中创建共享文件，再把数据传输到内存，虽然使用数据类型广，可传输的数据量大，但是传输速度慢，效率低
#                       3，socket   编程复杂度较高
#                       4，就是创建一种共享的容器：
#                                1>   Manager类      它可以开启一个共享的dict 或者list，可以提供很多数据结构
#                                                    它所闯将出来的数据结构具备进程间共享的特点,但是出现的不明问题太多，不建议使用
#                                2>   Queue 类  队列  即一个容器     是极力推荐的方法，重点掌握，
#                                        特点：自带锁，不容易出现数据错乱的问题  先进先出
def eat(q):
    # 消费
    for i in range(10):
        res = q.get()      #从q队列中获取元素
        print(res)
        time.sleep(random.randint(0, 2))
        print(res, "吃完了")


def mak_dog(q):
    # 生产者
    for i in range(10):
        time.sleep(random.randint(0, 2))
        print("第%s做完" % i)
        res = "第%s制作完成！" % i
        q.put(res)    #往q中塞数据


if __name__ == '__main__':
    q = Queue()      #增加q队列
    eat_p = Process(target=eat, args=(q,))
    mak_d = Process(target=mak_dog, args=(q,))
    eat_p.start()
    mak_d.start()
       守护进程：  作用：  父进程交给子进程一个任务，然而父进程先于子进程结束了，子进程的任务也就没必要继续执行
                 一个进程可以设为另一个进程的守护进程
、            特点是：被守护的进程挂了，守护进程也就挂了
                 p.daemon = True     呆萌
"""
    互斥锁：相互排斥的锁
              锁的本质就是一个标志 这个标志有两个状态 一个为锁定 一个为未锁定
            用途：当多个进程要同时操作同一个资源时，就会造成数据错乱，通常将写入操作加锁，读取操作不需要加锁
            加锁会把原本并发的任务，修改为串行，降低了效率吗，保证了数据的安全性
            加锁可以指定一部分代码串行，其他任然可以并发
            
            join 也可以将任务变为串行，它固定了任务的执行顺序，就是顺序固定，按顺序执行，不公平
            join会是子进程的代码全部串行执行，并且主进程也会阻塞，是执行一个子进程，不能执行一行代码，他执行，别的子进程只能等待
        注意：要想保证安全，必须保证大家用的都是同一把锁
               不能对同一把锁连续执行acquire 将会导致锁死
        from multiprocessing import Process.Lock
        def task(lock):
            lock.acquire()
            print("任务")
            lock.release()   
        if __name__ == '__main__':
            lock = Lock()       实例化这个类
            p = Process(target=task,args=(lock,))
            p.start()
生产者消费者模型
def eat(q):
    # 消费
    for i in range(10):
        res = q.get()      #从q队列中获取元素
        print(res)
        time.sleep(random.randint(0, 2))
        print(res, "吃完了")


def mak_dog(q):
    # 生产者
    for i in range(10):
        time.sleep(random.randint(0, 2))
        print("第%s做完" % i)
        res = "第%s制作完成！" % i
        q.put(res)    #往q中塞数据


if __name__ == '__main__':
    q = Queue()      #增加q队列
    eat_p = Process(target=eat, args=(q,))
    mak_d = Process(target=mak_dog, args=(q,))
    eat_p.start()
    mak_d.start

其中需要队列这个容器Queue     
解决双方效率，不平衡这个问题

   线程
     概念：线程是操作系统最小的运算调度单位，被包含在进程中，一个线程就是一个固定的执行流程
     线程和进程的关系：
         进程是一个资源管理单位，其包含了运行程序所需的所有资源
         线程不能单独存在 必须存在于进程中，
         线程才是真正的执行单位，没有线程，进程中的资源无法被利用起来，所以一个进程至少包含一个线程，称之为主线程
         线程可以由程序后期开启，自己开启线程称之为子线程--*************-+------------
    使用线程的目的只有一个：
                    就是提高效率
     线程如何使用：*****************重点
               第一种方法：
                                from threading import Thread
                                def task():
                                    print("子线程run")
                                    print("子线程over"
                                #执行顺序不固定 如果开启线程速度足够快 可能子线程先执行
                                # p = Thread(target=task)
                                # p.start()
                                if __name__ == '__main__':
                                t = Thread(target=task)
                                t.start()
                                print("主线程over")
                                结果为：子线程run
                                        主线程over
                                        子线程over
                第二种方法：from threading import Thread
                            class MyThread(Thread):    继承Thread类
                                def run(self):
                                    print("子线程run")
                            MyThread().start()
                            print("主线程over")
               总结：使用方法和多进程方法一模一样，开启线程的代码可以放在任何位置，但是开启进程必须放在判断的下面
            线程的特点：1  创建开销小
                        2  同一个进程中的多个线程线程数据是共享的
                        3，多个线程之间是平等的没有父子关系，所有线程的pid都是一样的（子进程）
                    案例：
                        from threading import Thread
                        import time, os
                        def task():
                            print(os.getpid())
                        if __name__ == '__main__':
                            st_time = time.time()
                            ts = []
                            for i in range(1000):
                                t = Thread(target=task)
                                t.start()
                                ts.append(t)
                            print("主线程over")
                            print(st_time)
                     了解： from multiprocessing import Process
                            #from threading import Thread
                            import time,os
                            def task():
                                print(os.getpid())

                            if __name__ == '__main__':
                                st_time = time.time()
                                ts =[]
                                for i in range(100):
                                    t = Process(target=task)
                                    t.start()
                                    ts.append(t)
                                print("主进程over")
                                print(st_time)
    守护线程：  一个线程可以设置为另一个线程的守护线程
           主线程代码执行完毕后 不会立即结束 会等待其他子进程结束
           主 会等待非守护线程结束后结束
           守护线程会等到所有的非守护线程结束后结束  前提是除了主线程之外，还有别的非守护
           当然如果守护线程已经完成任务。立马就结束
           即如果皇帝活着，守护者 妃子死了，皇帝正常运行，皇帝死了，无论守护者是否完成任务，都立即结束