Python学习——Python线程

一、线程创建

#方法一：将要执行的方法作为参数传给Thread的构造方法
import threading
import time

def show(arg):
    time.sleep(2)
    print('thread' + str(arg))

for i in range(10):
    t = threading.Thread(target=show,args=(i,))
    time.sleep(2)
    t.start()

#方法2：从Thread继承，并重写run()
class MyThread(threading.Thread):
    def __init__(self,num):
        threading.Thread.__init__(self)
        self.num = num

    def run(self)):#定义每个线程要运行的函数
        print("running on number:%s" %self.num)
        time.sleep(3)


if __name__ ==  '__main__':
    t1 = MyThread(1)
    t2 = MyThread(2)
    t1.start()
    time.sleep(3)
    t2.start()

注解：
Thread(group=None,target=None,name=None,args=(),kwargs={})
group:线程组，目前还没有实现，库引用时提示必须是None
target：要执行的方法
name：线程名
args/kwargs:要传入方法的参数，args和kwargs两个参数其实是二选一
#实例方法
isAlive():返回线程是否在运行
get/setName(name):获取/设置线程名
is/setDaemon(bool):获取/设置是否守护线程。初始值从创建该线程的线程继承，当没有非守护线程仍在运行时，程序将终止
start():启动线程
join([timeout]):阻塞当前上下文环境的线程。

二、Python多线程用法

import threading
from time import ctime,sleep

def music(func):
    for i in range(2):
        print("I was listening to %s. %s" %(func,ctime()))
        sleep(1)
def move(func):
    for i in range(2):
        print("I was at the %s! %s" %(func,ctime()))
        sleep(5)

threads = []
t1 = threading.Thread(target=music,args=('童话镇',))
threads.append(t1)
t2 = threading.Thread(target=move,args=('变形金刚',))
threads.append(t2)

if __name__ == '__main__':
    for t in threads:
        t.setDaemon(True)
        t.start()

    print("all over %s" %ctime())

注：

threads = []

t1 = threading.Thread(target=music,args=('童话镇',))

threads.append(t1)

　　创建了threads数组，创建线程t1,使用threading.Thread()方法，在这个方法中调用music方法target=music，args方法对music进行传参。 把创建好的线程t1装到threads数组中。

　　接着以同样的方式创建线程t2，并把t2也装到threads数组。

for t in threads:

　　t.setDaemon(True)

　　t.start()

最后通过for循环遍历数组。（数组被装载了t1和t2两个线程）

setDaemon()

　　setDaemon(True)将线程声明为守护线程，必须在start() 方法调用之前设置，如果不设置为守护线程程序会被无限挂起。子线程启动后，父线程也继续执行下去，当父线程执行完最后一条语句print "all over %s" %ctime()后，没有等待子线程，直接就退出了，同时子线程也一同结束。

       serDeamon(False)(默认)前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，主线程停止。

运行结果：

I was listening to 童话镇. Thu Jun 22 23:23:07 2017
I was at the 变形金刚! Thu Jun 22 23:23:07 2017
all over Thu Jun 22 23:23:07 2017

         从执行结果来看，子线程（muisc 、move ）和主线程（print "all over %s" %ctime()）都是同一时间启动，但由于主线程执行完结束，所以导致子线程也终止。 

调整程序：

 

if __name__ == '__main__':
    for t in threads:
        t.setDaemon(True)
        t.start()
    
    t.join()

    print "all over %s" %ctime()

         加了join()方法，用于等待线程终止。join（）的作用是，在子线程完成运行之前，这个子线程的父线程将一直被阻塞。

         join()方法的位置是在for循环外的，也就是说必须等待for循环里的两个进程都结束后，才去执行主进程。

运行结果：

############运行结果###################
I was listening to 童话镇. Thu Jun 22 23:34:22 2017
I was at the 变形金刚! Thu Jun 22 23:34:22 2017
I was listening to 童话镇. Thu Jun 22 23:34:23 2017
I was at the 变形金刚! Thu Jun 22 23:34:27 2017
all over Thu Jun 22 23:34:32 2017

从结果的时间可以看出每首歌之间等待1秒，电影之间等待5秒，但是是同步进行的，总的时间为5秒

三、线程锁（LOCK,RLOCK)
         由于线程之间是进行随机调度，并且每个线程可能只执行n条执行之后，当多个线程同时修改同一条数据时可能会出现脏数据，所以，出现了线程锁 - 同一时刻允许一个线程执行操作。

　　Lock（指令锁）是可用的最低级的同步指令。Lock处于锁定状态时，不被特定的线程拥有。Lock包含两种状态——锁定和非锁定，以及两个基本的方法。

　　可以认为Lock有一个锁定池，当线程请求锁定时，将线程至于池中，直到获得锁定后出池。池中的线程处于状态图中的同步阻塞状态。　　

　　RLock（可重入锁）是一个可以被同一个线程请求多次的同步指令。RLock使用了“拥有的线程”和“递归等级”的概念，处于锁定状态时，RLock被某个线程拥有。拥有RLock的线程可以再次调用acquire()，释放锁时需要调用release()相同次数。

　　可以认为RLock包含一个锁定池和一个初始值为0的计数器，每次成功调用 acquire()/release()，计数器将+1/-1，为0时锁处于未锁定状态。

　　简言之：Lock属于全局，Rlock属于线程。

1,未使用锁

import threading
import time

num = 0

def show(arg):
    global num
    time.sleep(1)
    num +=1
    print(num)

for i in range(10):
    t = threading.Thread(target=show, args=(i,))
    t.start()

print('main thread stop')

多次运行可能产生混乱。这种场景就是适合使用锁的场景。

2.使用锁

import threading
import time

num = 0
lock = threading.RLock()

# 调用acquire([timeout])时，线程将一直阻塞，
# 直到获得锁定或者直到timeout秒后（timeout参数可选）。
# 返回是否获得锁。
def show(arg):
    lock.acquire()
    global num
    time.sleep(1)
    num +=1
    print(num)
    lock.release()

for i in range(10):
    t = threading.Thread(target=show, args=(i,))
    t.start()

print('main thread stop')

加上锁后数字会一步步打印出来，不会因为拥堵而错乱的情况！

四、信号量（Semaphore)

互斥锁 同时只允许一个线程更改数据，而Semaphore是同时允许一定数量的线程更改数据 ，比如厕所有3个坑，那最多只允许3个人上厕所，后面的人只能等里面有人出来了才能再进去。

import threading, time

def run(n):
    semaphore.acquire()
    time.sleep(3)
    print("run the thread: %s" % n)
    semaphore.release()

if __name__ == '__main__':
    num = 0
    semaphore = threading.BoundedSemaphore(5)  # 最多允许5个线程同时运行
    for i in range(20):
        t = threading.Thread(target=run, args=(i,))
        t.start()

 五、事件（event)

Python线程的事件主要用于主线程控制其他线程的执行，事件主要提供了三个方法：set、wait、clear

事件处理的机制：全局定义了一个“Flag”，如果“Flag”值为 False，那么当程序执行 event.wait 方法时就会阻塞，如果“Flag”值为True，那么event.wait 方法时便不再阻塞。

clear：将“Flag”设置为False

set：将“Flag”设置为True

用threading.Event实现线程间的通讯

threading.Event使一个线程等待其他线程的通知，把这个Event传递到线程对象中，Event默认内置了一个标志，初始值为False。
一旦该线程通过wait()方法进入等待状态，直到另一个线程调用该Event的set()方法将内置标志设置为True时，
该Event会通知所有等待状态的线程恢复运行。

import threading

def do(event):
    print('start')
    event.wait()
    print('end')

event_obj = threading.Event()

for i in range(10):
    t = threading.Thread(target=do, args=(event_obj,))
    t.start()

event_obj.clear() #继续阻塞

inp = input('input:')
if inp == 'true':
    event_obj.set()  # 唤醒

六、条件(condition)
所谓条件变量，即这种机制是在满足特定条件之后，线程才可以访问相关的数据！

它使用Condition类来完成，由于它也可以像锁机制那样用，所以它也有acquire方法和release方法，而且它还有wait，notify，notifyAll方法

一个简单的生产消费者模型，通过条件变量的控制产品数量的增减，调用一次生产者产品就是+1，调用一次消费者产品就会-1.

使用 Condition 类来完成，由于它也可以像锁机制那样用，所以它也有 acquire 方法和 release 方法，而且它还有

wait， notify， notifyAll 方法。

import threading
import  time

# 产品类
class Goods:
    def __init__(self):
        self.count = 0

    def add(self, num=1):
        self.count += num

    def sub(self):
        if self.count >= 0:
            self.count -= 1

    def empty(self):
        return self.count <= 0

# 生产者
class Producer(threading.Thread):
    def __init__(self, condition, goods, sleeptime=1):
        threading.Thread.__init__(self)
        self.cond = condition
        self.goods = goods
        self.sleeptime = sleeptime

    def run(self):
        cond = self.cond
        goods = self.goods
        while True:
            # 锁住资源
            cond.acquire()
            goods.add()
            print("产品数量:", goods.count, "生产者线程")
            # 唤醒所有等待的线程 -> 其实就是唤醒消费者进程
            cond.notifyAll()
            # 解锁资源
            cond.release()
            time.sleep(self.sleeptime)


# 消费者
class Consumer(threading.Thread):
    def __init__(self, condition, goods, sleeptime=2):
        threading.Thread.__init__(self)
        self.cond = condition
        self.goods = goods
        self.sleeptime = sleeptime

    def run(self):
        cond = self.cond
        goods = self.goods

        while True:
            time.sleep(self.sleeptime)
            # 锁住资源
            cond.acquire()
            # 如无产品则让线程等待
            while goods.empty():
                cond.wait()
            goods.sub()
            print("产品数量:", goods.count, "消费者线程")
            

g = Goods()
c = threading.Condition()
pro = Producer(c, g)
pro.start()
con = Consumer(c, g)
con.start()

七、定时器（Timer)

import threading
def SayHello():
    print("hello world!")
    t=threading.Timer(3,SayHello)
    t.start()
def other_func():
    print("let me running!")
    t=threading.Timer(1,other_func)
    t.start()

if __name__ == "__main__":
    SayHello()
    other_func()