进程与线程6

线程和进程：

          进程：稳定，子进程挂，父进程没事，缺点：创造代价大，适合linux平台

          线程：不稳定，效率高。一个挂全挂。

多任务 ：操作系统同时运行多个任务，

并发：看上去一起执行，任务数多于c pu核心数

并行：真正一起执行，任务数小于等于CPU核心数

实现多任务原理：

        多进程

        多线程，携程模式，多线程+多进程

 

 

 

进程：

    对于操作系统一个任务就是一个进程，进程是系统中程序执行和资源分配到基本单位

from multiprocessing import Process

    os.getpid()得到进程的id号，os.getppid()得到它父进程的ID号

p=Process(target=run,args=("",))

p.start()

子进程中修改全局变量，父进程不受影响

进程池：Pool库：

            pp=Pool()默认参数c pu核心数，指一次可以同时启动几个线程

      for i in rang(x):

                  p p.apply_async(run,args=(参数1，参数2))启动线程，统一管理

 

        pp.close() 然后pp.join()一定是close后再join()，调用close后就不能在有新的进程了

 

进程的2个重要方法：

 

join():父启-子启动-子结束-父结束,没有的话就是 父启-父结-子启

daemon()属性是否随主线程退出而退出如果类名.demon=true时它就不会随主线程的退出而退出

terminate()如果开启多个进程后，其中有一个进程无法关闭，陷入死循环就用它强行关闭

 

线程：在一个进程的内部，要同时干多件事，就需要同时运行多个字任务，我们把子任务称为线程

线程是最小的执行单元，而进程由至少一个线程组成。

 

线程支持资源共享，全局变量,所以，任何一个变量都可以被任意一个线程改变，从而线程共享就可能会造成

多个线程同时修改一个变量，从而值发生变化

 

 

 

死锁：多个并发进程因争夺系统资源而产生相互等待的现象。

锁的应用：

            2个线程同时工作，一个取钱，一个存钱，就可能会造成数据异常。解决方法：加锁

lock=      t h reading.lock()

锁：确保了一段代码只能由一个线程从头到尾的完整执行，阻止了多线程的并发执行，由于存在多个锁，不同的线程

持有不同的锁，并试图获取其它的锁，就会造成死锁，导致多个线程挂起，只能考系统强行终止

lock.acquire()加锁，lock.releas（）释放锁

等同与：with lock：

                             执行的代码

 t=thread.Thread(target=,name="线程名称",)

thread.current_thread().name打印线程名字

t.join()等待线程结束

threading.Semphore(3)控制几个线程执行

threading.Timer(3,run)定时线程。3s后开始执行

生产者与消费者：

               生产者的线程在生产数，消费者的线程同时也在消费数，比如在一个队列中，一边的线程在生产，另一边的线程在消费

为什么要使用生产者消费者模型？

     在并发编程中，如果生产者处理速度很快，而消费者处理速度比较慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个等待的问题，就引入了生产者与消费者模型。让它们之间可以不停的生产和消费。

 

实现生产者消费者模型三要素：

    1、生产者

    2、消费者

    3、队列（或其他的容哭器，但队列不用考虑锁的问题）