python之线程

概念

线程是多任务编程方式之一，可以使用计算机的多核资源。

线程又称为轻量级的进程，在并发执行上和进程相同。但是一个进程中可以包含多个线程，这些线程共享线程的运行环境。

线程和进程的比较：

1 进程的创建开销大，而线程的创建开销小。

2 进程间的资源共享，只能通过进程间通信。而同一进程下线程间的资源共享，就像使用全局变量一样。

3 多个功能独立的程序需要成为不同的进程。而不能通过多线程凑成一个进程。

4 进程空间独立性高，安全性也高，也较少使用同步和互斥方法。而多个线程间因为数据共享，所以同步和互斥几乎是数据必须必须的。

5 线程也有自己的独立资源，比如说ID，资源集。

创建线程

import threading

t = threading.Thread(target, args, kwargs, name)

t.name 线程名字

t.setName() ：设置线程名称

t.getName() : 获取名称

t.join(n) :主线程阻塞等待分支线程退出，n为超时时间

t.start() :启动线程

t.Daemon : daemon属性

如果在进程中创建了多个线程，当主进程结束时，会根据子进程的daemon属性来来处理不同的情况：

1 如果某个子线程的daemon为False，那么主线程结束时会检测这个子线程是否结束，如果子线程没有结束，那么主线程会等待子线程运行完后再退出。

2 如果某个子线程的daemon为True，那么主线程结束时不会对这个子线程进行检查而直接退出，同时daemon为True的子线程将随主线程一起退出，不论它们是否运行完成。

属性Daemon的默认值为False，如果要设置，必须在调用start（）方法启用前。

t.is_Daemon() :判断Daemon的状态

t.is_alive() : 判断线程状态

import threading
from time import sleep, ctime

# 听歌
def music(name):
    print('Listen music %s at the %s '%(name, ctime()))
    sleep(2)

# 看书
def read(name):
    print('Read book %s at the %s'%(name, ctime()))
    sleep(5)

if __name__ == '__main__':
    threads = []
    t1 = threading.Thread(target=music, args=('James',))
    threads.append(t1)
    t2 = threading.Thread(target=read, args=('Wade',))
    threads.append(t2)

    # 启动线程
    for t in threads:
        t.start()

    # 回收线程
    for t in threads:
        t.join()

多线程类的创建

import threading
from time import sleep, ctime

exitFlag = 0
class MyThread(threading.Thread):
    def __init__(self, threadID, name, counter):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.counter = counter

    def run(self):
        print('starting' + self.name)
        print_time(self.name, self.counter, 5)
        print('ending' + self.name)

def print_time(theadName, delay, counter):
    while counter:
        if exitFlag:
            (threading.Thread).exit()
        sleep(delay)
        print("%s at the time:%s"%(theadName, ctime()))
        counter -= 1

if __name__ == '__main__':
    t1 = MyThread(1, 'Mythread-1', 1)
    t2 = MyThread(2, 'Mythread-2', 2)

    t1.start()
    t2.start()

    t1.join()
    t2.join()
    print('主线程退出!!!')

线程间的通信

线程间的通信一般是使用全局变量,但是这种方法会带来资源的争夺，所有线程间的共享资源一般需要同步互斥机制。

所以为了解决这个问题，我们需要使用2种方法。

方法1: 锁

lock

lock = threading.Lock()

lock.acquire()

lock.release()

import threading

a = b = 0
lock = threading.Lock()

def value():
    while True:
        lock.acquire()
        if a != b:
            print('a = %d, b = %d'%(a, b))
        lock.release()

if __name__ == '__main__':
    t = threading.Thread(target=value)
    t.start()
    while True:
        lock.acquire()
        a += 1
        b += 1
        lock.release()
    t.join()
    '''
    结果是永远也不会发生a!=b,只能在a,b同时修改后读取a，b的值
    '''

方法2：事件 event

python事件主要是主线程控制其他线程的执行，主要提供了wait，set，clear方法。

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

clear:将Flag定义为False。

set:将Flag定义为True。

线程间通信：

使用event可以让以一个线程等待其他线程的通知，

e = threading.Event()

e.set() 设置标志位 设置Flag其为True

e.wait() 等待设置标志位 等待标志变为True后执行,当为False时候阻塞等待

e.clear() 清空标志位 设置Flag其为False

import threading
import random
import time

e = threading.Event()
a = 500

def fun():
    while True:
        time.sleep(2)
        e.wait()
        global a
        print('a = %d'%a)
        a -= random.randint(1, 100)

if __name__ == '__main__':
    t = threading.Thread(target=fun)
    t.start()

    while True:
        time.sleep(1)
        a += random.randint(0, 10)
        if a > 100:
            e.set()
        else:
            e.clear()
    t.join()
    '''
    主线程加数字0-10
    子线程减数字0-100
    当数字大于100时，其Flag一直为True，当小于100时，其Flag为Flase，一直阻塞无法打印
    '''

'''
只有当判断输入q时,才会改变Flag为False,从而结束子线程循环,结束程序
'''
import threading
import time

class MyThread9(threading.Thread):

    def __init__(self):
        threading.Thread.__init__(self)

    def run(self):
        global event
        while True:
            if event.isSet():
                print(self.getName() + ' is Running!')
                time.sleep(2)
            else:
                print(self.getName() + ' Stop!!')
                break

event = threading.Event()
event.set()

def func():
    t1 = []
    t1.append(MyThread9())

    for i in t1:
        i.start()
    time.sleep(10)
    q = input('请输入退出:')
    if q == 'q':
        event.clear()
    for i in t1:
        i.join()
    print('all over!!!')
if __name__ == '__main__':
    func()