进程、线程、锁——12

进程：独立的所有子任务的集合。

线程：进程中的每个子任务，不能独立存在。

线程，进程：目的都是想同时完成任务。

注：当进程结束后，线程将无法运行。

特点：

    进程：独立（内存独占，CPU使用独立）启动进程开销大（速率低），进程之间很难共享数据和

数据通信，数据安全性高。

    线程：依赖进程（内存共享，CPU使用独立）启动开销小，线程之间共享数据容易，方便通信，

线程不安全。

python本质是单线程。

创建线程时需要导入的模块：

1、import __thread

2、import     time

3、import    threading    （threading相比_thread更强大，推荐使用）

        threading.currentThread():返回当前的线程数量
        threading.enumerate():返回一个包含正在运行的线程的list
        threading.activeCount():返回正在运行的线程数量，与len(threading.enumerate())有相同的结果

Thread类提供以下方法：
run（）：用以表示线程活动的方法
start（）：启动线程活动。
join（[time]）：等待线程至终止    加入并阻止主线程的执行，即执行完才执行主线程，可加时间。
isAlive():返回线程是否活动的
getName():返回线程名
setName():设置线程名

两种创建的方式：函数和类

函数：

def print_time(threadName,delay):
    count=0
    while count < 5:
        time.sleep(delay)
        count += 1
        print("%s:%s"%(threadName,time.ctime(time.time())))

print_time("时间：",2)#获取时间，循环五次，没两秒输出一次

类：

class MyThread(threading.Thread):
    def __init__(self,name):#初始化方法
        threading.Thread.__init__(self)
        self.name=name
    def run(self):
        for i in range(10):
            print(self.name,i)
            time.sleep(1)
t=MyThread("th1")    #生成对象
t2=MyThread("th2")
t.start()    #调用run方法
t.join()    #join（）进来的线程先运行，其他线程停止运行
t2.start()

线程的状态：

1、创建    2、就绪    3、运行    4、阻塞    5、死亡

锁：

lock=threading.Lock()    #得到锁

cond=threading.Condition(lock=lock)

Condition:精确的控制锁。

acquire（）：上锁

wait（）：等待

release（）：解锁

notify（）    notify__all（）：唤醒

例：

import threading
import time
class Thread1(threading.Thread):
    def run(self):
        for i in range(1,11):
            if i==3:
                cond.acquire()#上锁
                cond.wait()#等待
                cond.release()#解锁
            print(i)
            time.sleep(1)

class Thread2(threading.Thread):
    def run(self):
        for i in range(30,19,-1):
            print(i)
            time.sleep(1)
        cond.acquire()#上锁
        cond.notify()#唤醒
        cond.release()#解锁

lock=threading.Lock()
cond=threading.Condition(lock=lock)
t1=Thread1()
t2=Thread2()
t1.start()
t2.start()

生产者和消费者按例：

伙夫生产完30个馒头，吃货才可以吃，当缓冲区为空时，吃货等待；当缓冲区满时，伙夫等待

import threading
import time
list=[]#先创建一个空变量存贮伙夫生产的馒头
lock=threading.Lock()#获取锁
huofuCond=threading.Condition(lock=lock)#将锁传进去
lock2=threading.Lock()
chihuoCond=threading.Condition(lock=lock2)
class Huofu(threading.Thread):
    def run(self):
        while True:
            chihuoCond.acquire()#吃货上锁
            for i in range(1,31):
                list.append(i)#生产的馒头添加到列表中
                print("伙夫生产第{0}个馒头".format(i))
                time.sleep(0.5)
            huofuCond.acquire()#伙夫上锁
            chihuoCond.notify_all()#吃货唤醒所有
            chihuoCond.release()#吃货解锁
            huofuCond.wait()#伙夫等待
            huofuCond.release()#伙夫解锁



mantou=None#定义一个变量
class Chihuo(threading.Thread):
    def __init__(self,name=None):
        threading.Thread.__init__(self)
        self.name=name
    def run(self):
       while True:
           chihuoCond.acquire()#吃货上锁
           if len(list)==0:#判断列表中是否有馒头
               huofuCond.acquire()#伙夫上锁
               huofuCond.notify()#伙夫唤醒
               huofuCond.release()#伙夫解锁
               chihuoCond.wait()#吃货等待
           chihuoCond.release()#吃货解锁
           chihuoCond.acquire()#吃货上锁
           if len(list)>0:
               mantou=list.pop()
               print("{0}在吃第{1}个馒头".format(threading.current_thread().name,mantou))
               time.sleep(0.5)
           chihuoCond.release()#吃货解锁

hf=Huofu()
wenbo=Chihuo("文博")
wenxuan=Chihuo("文轩")
wenzhang=Chihuo("文章")
hf.start()
wenbo.start()
wenxuan.start()
wenzhang.start()