Python基础（四）--- Python多线程介绍，开启线程的三种方式，time模块，join，Daemon，Lock、Rlock，事件机制，Timer

一、多线程介绍
---------------------------------------------------------
    1.threading用于提供线程相关的操作，线程是应用程序中工作的最小单元。
    2.python当前版本的多线程库没有实现优先级、线程组，线程也不能被停止、暂停、恢复、中断。

    3.threading模块提供的类：
        Thread, Lock, Rlock, Condition, [Bounded]Semaphore, Event, Timer, local。

    4.threading 模块提供的常用方法：
        threading.currentThread(): 返回当前的线程变量。
        threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
        threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

    5.threading 模块提供的常量：
        threading.TIMEOUT_MAX 设置threading全局超时时间。


二、开启线程的三种方式
------------------------------------------------
    1.[方式一：通过低级api创建]
        # -*- encoding=utf-8 -*-

        # 导包
        import threading        #高级线程接口
        import time
        import _thread          #低级线程接口

        #定义函数
        def hello(str1,str2):
            time.sleep(2)
            #获取当前线程名称
            print("当前线程name:" + threading.currentThread().getName())
            print("hello: " + str1 + ":" + str2)

        # # 开启线程方式1 -- 低级接口方式
        # try:
        #     _thread.start_new(hello,('tom','cat'));
        #     while 1:
        #         pass;
        # except Exception as e :
        #     print("发生异常：" + e)

    2.[方式二：高阶api创建]
        try:
            #定义线程
            for i in (1,2,3):
                t = threading.Thread(target = hello, args = ('tom','cat'))
                #执行线程
                t.start()
        except Exception as e :
            print("发生异常：" + e)

    3.[方式三：通过类创建]
        try:
            # 定义线程类
            class MyThread(threading.Thread):
                def __init__(self,arg1,arg2):
                    super(MyThread, self).__init__()    #注意：一定要显式的调用父类的初始化函数。
                    self.arg1=arg1
                    self.arg2=arg2
                def run(self):  #定义每个线程要运行的函数
                    time.sleep(1)
                    hello(self.arg1,self.arg2)

            # 开启线程
            t = MyThread("tom","cat")
            t.start()

        except Exception as e :
            print("发生异常：" + e)

三、time模块
--------------------------------------------------------
    import time
    //提取秒，精确到微秒.
    cc = int(time.time() * 1000)        #时间戳 转换成毫秒.
    cc = time.ctime()                   #日期date
    print(cc)


四、参数
---------------------------------------------------------
    1.后台线程
        t = MyThread("tom","cat")
        t.setDaemon(True)   #设置线程为后台线程

    2.阻塞线程join
        # join()阻塞当前上下文环境的线程，直到调用此方法的线程终止或到达指定的timeout，
        # 即使设置了setDeamon（True）主线程依然要等待子线程结束。
        t = MyThread("tom","cat")
        t.join()

    3.设置线程名称
        t = MyThread("tom","cat")
        t.setName("thread--10")


五、Lock、Rlock
----------------------------------------------------------
    1.由于线程之间随机调度：某线程可能在执行n条后，CPU接着执行其他线程。为了多个线程同时操作一个内存中的资源时不产生混乱，我们使用锁。

    2.Lock（指令锁）是可用的最低级的同步指令。Lock处于锁定状态时，不被特定的线程拥有。Lock包含两种状态——锁定和非锁定，以及两个基本的方法。
    可以认为Lock有一个锁定池，当线程请求锁定时，将线程至于池中，直到获得锁定后出池。池中的线程处于状态图中的同步阻塞状态。

    3.RLock（可重入锁）是一个可以被同一个线程请求多次的同步指令。RLock使用了“拥有的线程”和“递归等级”的概念，处于锁定状态时，RLock被某个线程拥有。拥有RLock的线程可以再次调用acquire()，释放锁时需要调用release()相同次数。
    可以认为RLock包含一个锁定池和一个初始值为0的计数器，每次成功调用 acquire()/release()，计数器将+1/-1，为0时锁处于未锁定状态。

    4.简言之：Lock属于全局，Rlock属于线程。
        构造方法：
        Lock()，Rlock（）,推荐使用Rlock()

    实例方法：
        acquire([timeout]): 尝试获得锁定。使线程进入同步阻塞状态。
        release(): 释放锁。使用前线程必须已获得锁定，否则将抛出异常。

    5.买票问题分析
        # 票池
        tickets = 100;
        # 线程锁
        lk  = threading.RLock();

        # 取票方法
        def getTicket():
            # 调用acquire([timeout])时，线程将一直阻塞，
            # 直到获得锁定或者直到timeout秒后（timeout参数可选）。
            # 返回是否获得锁。
            lk.acquire();
            global tickets
            tmp = 0;
            if tickets > 0 :
                tmp = tickets;
                tickets -= 1;
            else:
                tmp = 0;
            lk.release();
            return tmp;     # 返回剩余票数


        class Saler(threading.Thread):

            def run(self):
                while True:
                    tick = getTicket();
                    if tick != 0 :
                        print(self.getName() + ":" + str(tick))
                    else:
                        return ;

        s1 = Saler()
        s2 = Saler()

        s1.start()
        s2.start()


六、事件机制
---------------------------------------------------------
    1.Event（事件）是最简单的线程通信机制之一：一个线程通知事件，其他线程等待事件。Event内置了一个初始为False的标志，当调用set()时设为True，调用clear()时重置为 False。wait()将阻塞线程至等待阻塞状态。

    2.Event其实就是一个简化版的 Condition。Event没有锁，无法使线程进入同步阻塞状态。

    3.构造方法：
        Event()

    4.实例方法：
        isSet(): 当内置标志为True时返回True。
        set(): 将标志设为True，并通知所有处于等待阻塞状态的线程恢复运行状态。
        clear(): 将标志设为False。
        wait([timeout]): 如果标志为True将立即返回，否则阻塞线程至等待阻塞状态，等待其他线程调用set()。

    5.演示
        # 定义一个事件
        event = threading.Event()

        def func():
            # 等待事件，进入等待阻塞状态
            print(threading.currentThread().getName() + '线程等待event的执行...')

            event.wait()            # 一直等待，直到收到event

            # 收到事件后进入运行状态
            print (threading.currentThread().getName() +'线程收到事件，开始执行线程...')

        t1 = threading.Thread(target = func)
        t2 = threading.Thread(target = func)
        t1.start()
        t2.start()

        time.sleep(2)

        # 发送事件通知
        print('主线程发起事件')
        event.set()

        ============结果====================
        Thread-1线程等待event的执行...
        Thread-2线程等待event的执行...
        [wait 2s]
        主线程发起事件
        Thread-1线程收到事件，开始执行线程...
        Thread-2线程收到事件，开始执行线程...


七、Timer
---------------------------------------------------------------
    1.Timer（定时器）是Thread的派生类，用于在指定时间后调用一个方法。

    2.构造方法：
        Timer(interval, function, args=[], kwargs={})
            interval: 指定的时间
            function: 要执行的方法
            args/kwargs: 方法的参数

    3.实例方法：
        Timer从Thread派生，没有增加实例方法。

    4.演示
        def func():
            print('定时炸弹爆炸啦~')

        # 新建一个定时器，5秒后执行func方法
        timer = threading.Timer(5,func);
        # 开始计时
        timer.start()