python -- 多线程编程

多线程类似于同时执行多个不同程序，多线程运行有如下优点：

• 使用线程可以把占据长时间的程序中的任务放到后台去处理。
• 用户界面可以更加吸引人，这样比如用户点击了一个按钮去触发某些事件的处理，可以弹出一个进度条来显示处理的进度
• 程序的运行速度可能加快
• 在一些等待的任务实现上如用户输入、文件读写和网络收发数据等，线程就比较有用了。在这种情况下我们可以释放一些珍贵的资源如内存占用等等。

线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。

每个线程都有他自己的一组CPU寄存器，称为线程的上下文，该上下文反映了线程上次运行该线程的CPU寄存器的状态。

指令指针和堆栈指针寄存器是线程上下文中两个最重要的寄存器，线程总是在进程得到上下文中运行的，这些地址都用于标志拥有线程的进程地址空间中的内存。

• 线程可以被抢占（中断）。
• 在其他线程正在运行时，线程可以暂时搁置（也称为睡眠） -- 这就是线程的退让。

python中的多线程

　　多线程之间是共享内存的，而且是可以直接通信的。

1、多线程实现

'''1、直接实现(最常用)'''
import threading
import time

def hello(num):
    print("This threading is no [%s]" %num)
    time.sleep(2)
    
if __name__ == '__main__':
    '''
    t1 = threading.Thread(target=hello,args=[1,])  #实例化一个线程，后面参数为列表，只有一个元素时，要有','
    t2 = threading.Thread(target=hello,args=[2,])
    
    t1.start()  #上面只是实例化，这里才是启动线程
    t2.start()
    t1.join()
    t2.join()
    print('------main------')
    
    以上在没有t1.join()、t2.join()时，后面那句直接打印。因为启动线程后，主线程和两个子线程
相互独立， print('------main------')是属于主线程的，不会等待子线程结束才打印

t1.join() 的作用是：阻塞，等待线程t1结束后猜结束父线程
    '''
    
    #若有多个线程，对上面代码改进：
    t_list = []
    for i in range(10):
        t = threading.Thread(target=hello,args=[i,])
        t.start()
        t_list.append(t)
    
    for i in t_list:
        i.join()
    
    print('------main------')
    
    
'''2、自定义类实现多线程'''
import threading
import time

class MyThread(threading.Thread):
    def __init__(self,num):
        super(MyThread,self).__init__()     #继承父类的构造函数
        self.num = num
        
    #在自定义线程类里面，必须有这个run方法
    #这个run默认是每个线程调用start函数后执行的函数
    def run(self):
        print("This threading is no [%s]" %self.num)
        time.sleep(2)        
        

t1 = MyThread(1)
t2 = MyThread(2)
t1.start()
t2.start()
t1.join()
t2.join()
print("父线程执行结束~")


'''守护线程'''
'''
setDaemon  设置守护线程 eg：t.setDaemon(True)
'''
import time
import threading

def run(n):
    print("[%s] ------running------
" %n)
    time.sleep(2)
    print('---done---')
    
def main():
    for i in range(5):
        t = threading.Thread(target=run,args=[i,])
        t.start()
        print("starting thread",t.getName())
    t.join(1)
    
m = threading.Thread(target=main,args=[])
#将m线程设置为Daemon线程,它做为程序主线程的守护线程,当主线程退出时,m线程也会退出,由m启动的其它子线程会同时退出,不管是否执行完任务
m.setDaemon(True)  
m.start()
m.join(2)
print("----main thread done---")

　　注意：python的多线程是通过c语言的接口调用的系统原生的线程，所以在线程调用后，python就是去了对线程的控制能力，当线程结束后会把执行结果返回给python。

2、GIL与线程锁　　　　

　　　　GIL锁：全局解释器锁，它是解释器层次的，作用是控制每次只能有一个python线程在操作系统中运行
　　　　线程锁(互斥锁)：是在解释器之上控制同一时间只能一个线程修改指定变量的锁

　　　　在多线程时，若多个线程都是修改同一份数据，那么就要对修改数据的代码部分加上线程锁
　　　　这样能使在同一时刻，只有一个线程在修改该数据，这样才能达到预想的效果

import threading
import time

def addNum():
    global num
    print("--get num:",num)
    time.sleep(1)
    lock.acquire()    #加锁
    num -= 1   #修改变量
    lock.release()    #解锁   加锁后必须要解锁，不然程序就死了
    
num = 100    
thread_list = []
lock = threading.Lock()    #实例化一个线程锁

for i in range(100):
    t = threading.Thread(target=addNum)
    t.start()
    thread_list.append(i)
    
for i in thread_list:      #等待所有线程都执行完毕
    #t.join(timeout=3)   #注意：这里设置了timeout后就不再是阻塞状态，而且，并不是等待3s...
    t.join()    #作用：只要子线程t还没执行结束，这里就阻塞，父线程就不能退出（父线程就是执行脚本这个）

print('finally num:',num)
'''
没加锁时，各线程执行后可能会覆盖其他线程的结果，导致结果是随机的
加锁后，每次都只有一个线程在操作数据，所以结果就是确定的
'''
print('All of thread was exec over~')

3、递归锁

#!/usr/bin/env python
#coding:utf-8

'''
递归锁：就是大锁里面还要包含子锁
'''
import threading,time

def run1():
    print("grab the first data")
    rlock.acquire()   #捕获(加锁)
    global num1
    num1 += 1
    rlock.release()   #释放(去锁)
    return num1
    
def run2():
    print("geab the second data")
    rlock.acquire()
    global num2
    num2 += 1
    rlock.release()
    return num2
    
def run3():
    rlock.acquire()
    res1 = run1()
    print("------btween run1 and run2------")
    res2 = run2()
    rlock.release()
    print("res1：%s , res2: %s" %(res1,res2))
    
if __name__ == "__main__":
    num1,num2 = 0,0
    rlock = threading.RLock()    #实例化一个递归锁
    for i in range(10):
        t = threading.Thread(target=run3)
        t.start()
        
    while threading.active_count() != 1:
        print("剩余线程个数：",threading.active_count())
    else:
        print("剩余线程个数：",threading.active_count())
        print('------all threads done------')
        print("最后 num1：%s  num2： %s" %(num1,num2))

4、信号量

#!/usr/bin/env python
#coding:utf-8
'''
信号量：互斥锁同时只允许一个线程更改数据，而Semaphore(信号量)是同时允许一定数量的线程更改数据
'''
import threading,time

def run(n):
    semaphore.acquire()
    time.sleep(1)
    print("run the thread: %s
" %n)
    semaphore.release()
    
if __name__ == '__main__':
    
    semaphore = threading.BoundedSemaphore(3)  #最多允许3个线程同时运行
    for i in range(20):
        t = threading.Thread(target=run,args=[i,])
        t.start()
        
while threading.active_count() != 1:
    #print('当前剩余线程数：',threading.active_count())
    pass
else:
    print("------ all threads done ------")
    

5、接收线程返回的数据

#!/usr/bin/env python
# coding:utf-8
import time
import threading

data = []
def func(n):
    time.sleep(3)
    data.append(n**n)
    print('hello',n)
    return n**n

thread_list = []
for i in range(20):
    #t = threading.Thread(target=func,args=[i,]) #这里传参时，参数以列表形式后面可以加','，也可以不加；以元组形式必须加
    t = threading.Thread(target=func,args=(i,)) 
    t.start()
    thread_list.append(t)
    
#for i in thread_list:
    #i.join()
    #print('hello ',i)

#print(thread_list)
print(data)
print('----main thread end----')

6、event模块

#!/usr/bin/env python
# coding:utf-8

'''
通过Event来实现两个或多个线程间的交互，下面是一个红绿灯的例子，即起动一个线程做交通指挥灯，生成几个线程做车辆，车辆行驶按红灯停，绿灯行的规则。
个人理解：
    通过Event实例化一个对象，这个对象用set方法设置一直flag，所有线程都能访问flag，并根据flag不同的值做不同的处理
'''
import threading
import time


def light():
    if not event.isSet():
        event.set()   # set后，wait就不阻塞
    count = 0
    while True:
        if count < 10:
            print(' 33[42;1m--green light on---33[0m')
        elif count < 13:
            print(' 33[43;1m--yellow light on---33[0m ')
        elif count < 20:
            if event.isSet():
                event.clear()
            print(' 33[41;1m--red light on---33[0m ')
        else:
            count = 0
            event.set() 
        time.sleep(1)
        count += 1


def car(n):

    ''' 
    :param n:  给车辆的编号 
    :return:  默认返回值是None
    '''

    while True:
        time.sleep(1)
        if event.isSet():
            print('car [%s] is running...' % n)
        else:
            print('car [%s] is waiting for the red light...' % n)
            event.wait()

if __name__ == "__main__":
    event = threading.Event()   # 实例化一个Event对象
    Light = threading.Thread(target=light)
    Light.start()
    for i in range(3):
        Car = threading.Thread(target=car,args=(i,))
        Car.start()