Python：多线程

据廖雪峰老师的学习文档介绍，高级语言通常都内置多线程的支持，Python也不例外，并且，Python的线程是真正的Posix Thread，而不是模拟出来的线程。

Python的标准库提供了两个模块：_thread和threading，_thread是低级模块，threading是高级模块，对_thread进行了封装。绝大多数情况下，我们只需要使用threading这个高级模块。

启动一个线程就是把一个函数传入并创建Thread实例，然后调用start()开始执行。

下面学习笔记从有四个板块知识点：

• _thread模块来做简单尝试
• 线程同步：锁
• threading来class实例化创建多线程
• threading的线程优先级队列

Python中使用线程有两种方式：函数或者用类来包装线程对象。

_thread的创建多线程示例

这就是函数式来包装线程对象：调用 _thread 模块中的start_new_thread()函数来产生新线程。语法如下:
_thread.start_new_thread ( function, args[, kwargs] )

• function：线程函数
• args：传递线程函数的参数 传参数必须是tuple类型(元组）
• kwagrs：可选参数

import _thread
import time

#为线程定义一个函数
def print_time(threadName,delay):
    count= 0
    while count < 3:
        time.sleep(delay)
        count += 1
        print("%s:%s" % (threadName,time.ctime(time.time())))
try:
    #创建两个线程
    _thread.start_new_thread(print_time,("thread-1",1))
    _thread.start_new_thread(print_time,("thread-2",2))
except:
    print("ERROR!!")

#主程序，因为线程需要挂载到主线程运行，因此没有这一步的话不执行多线程

while 1:
    pass

#输出结果：线程1延时取1，线程2延时取2
thread-1:Tue Aug  7 19:52:17 2018
thread-2:Tue Aug  7 19:52:18 2018
thread-1:Tue Aug  7 19:52:19 2018
thread-1:Tue Aug  7 19:52:20 2018
thread-2:Tue Aug  7 19:52:21 2018
thread-2:Tue Aug  7 19:52:23 2018

'''
由于任何进程默认就会启动一个线程，我们把该线程称为主线程，主线程又可以启动新的线程，Python的threading模块有个current_thread()函数，它永远返回当前线程的实例。
主线程实例的名字叫MainThread，子线程的名字在创建时指定，我们用LoopThread命名子线程。
名字仅仅在打印时用来显示，完全没有其他意义，如果不起名字Python就自动给线程命名为Thread-1，Thread-2
'''

线程同步：锁

锁的概念在多线程里应该算是灵魂级重要的东西了吧，多线程和多进程最大的不同在于，多进程中，同一个变量，各自有一份拷贝存在于每个进程中，互不影响，而多线程中，所有变量都由所有线程共享，所以，任何一个变量都可以被任何一个线程修改，因此，线程之间共享数据最大的危险在于多个线程同时改一个变量，把内容给改乱了。

为了解决这些问题，我们需要用到锁：

使用 Thread 对象的 Lock 和 Rlock 可以实现简单的线程同步，这两个对象都有 acquire 方法和 release 方法，对于那些需要每次只允许一个线程操作的数据，可以将其操作放到 acquire 和 release 方法之间。

• 初始化锁：lock=threading.Lock()
• 加锁：lock.acqure()
• 解锁：lock.release（）

import threading
import time

x = 0

#初始化锁
lock = threading.Lock()

def change_it(n):
    global x
    ##加锁
    lock.acquire()

    x = x + n
    x = x - n

    ##解锁，不加这条会导致死锁
    lock.release()

def run_thread(n):
    for i in range(1000000):
        change_it(n)

t1 = threading.Thread(target = run_thread,args=(5,))
t2 = threading.Thread(target = run_thread,args=(8,))

start = time.time()
t1.start()
t2.start()
t1.join()
t2.join()
end = time.time() - start

print(x)
print(end)

#如果不加三条锁的方法会输出：
2
0.9724380970001221
#是因为两个线程在巨多次的循环中发生了错乱

#加锁之后正确输出，虽然时间会长一点但是工作正常
0
2.080798864364624   

上面记录完函数包装多线程后，下面就是用类来包装多线程了~

使用threading模块来class实例化创建多线程

threading 模块除了包含 _thread 模块中的所有方法外，还提供的其他方法：

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

除了使用方法外，线程模块同样提供了Thread类来处理线程，Thread类提供了以下方法:

• run(): 用以表示线程活动的方法。
• start():启动线程活动。
• join([time]): 等待至线程中止。这阻塞调用线程直至线程的join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生。
• isAlive(): 返回线程是否活动的。
• getName(): 返回线程名。
• setName(): 设置线程名。

创建的方式就是：从 threading.Thread 继承创建一个新的子类，并实例化后调用 start() 方法启动新线程，即它调用了线程的 run() 方法：

import threading
import time

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("开始线程：" + self.name)
        print_time(self.name,self.counter,5)
        print("结束线程：" + self.name)

#定义方法
def print_time(threadName,delay,counter):
    while counter:
        if exitflag:
            threadName.exit()
        time.sleep(delay)
        print("%s:%s" % (threadName,time.ctime(time.time())))
        counter -= 1

#创建一个线程
thread1 = myThread(1,"thread1",1)
thread2 = myThread(1,"thread2",2)

#启动线程
thread1.start()
thread2.start()
thread1.join()
thread2.join()
print("已经全部线程结束了")

#输出
开始线程：thread1
开始线程：thread2
thread1:Tue Aug  7 20:04:14 2018
thread2:Tue Aug  7 20:04:15 2018
thread1:Tue Aug  7 20:04:15 2018
thread1:Tue Aug  7 20:04:16 2018
thread2:Tue Aug  7 20:04:17 2018
thread1:Tue Aug  7 20:04:17 2018
thread1:Tue Aug  7 20:04:18 2018
结束线程：thread1
thread2:Tue Aug  7 20:04:19 2018
thread2:Tue Aug  7 20:04:21 2018
thread2:Tue Aug  7 20:04:23 2018
结束线程：thread2
已经全部线程结束了

threading的线程优先级队列（Queue）

Python 的 Queue 模块中提供了同步的、线程安全的队列类，包括FIFO（先入先出)队列Queue，LIFO（后入先出）队列LifoQueue，和优先级队列 PriorityQueue。

这些队列都实现了锁原语，能够在多线程中直接使用，可以使用队列来实现线程间的同步。

Queue 模块中的常用方法:

• Queue.qsize() 返回队列的大小
• Queue.empty() 如果队列为空，返回True,反之False
• Queue.full() 如果队列满了，返回True,反之False
• Queue.full 与 maxsize 大小对应
• Queue.get([block[, timeout]])获取队列，timeout等待时间
• Queue.get_nowait() 相当Queue.get(False)
• Queue.put(item) 写入队列，timeout等待时间
• Queue.put_nowait(item) 相当Queue.put(item, False)
• Queue.task_done() 在完成一项工作之后，Queue.task_done()函数向任务已经完成的队列发送一个信号
• Queue.join() 实际上意味着等到队列为空，再执行别的操作

import threading
import time
import queue
exitflag=0
queueLock=threading.Lock()
workQueue=queue.Queue(10)
class  myThread(threading.Thread):
       def __init__(self,threadID,name,c):
             threading.Thread.__init__(self)
             self.threadID=threadID
             self.name=name
             self.c=c
       def run(self):
             print("开始线程:"+self.name)
             process_data(self.name,self.c)
             print("退出线程:"+self.name)

def process_data(threadName,c):
        while not exitflag:
               queueLock.acquire()
               if not workQueue.empty():
                   data=c.get()
                   queueLock.release()
                   print("%s processing %s"%(threadName,data))
               else:
                   queueLock.release()
               time.sleep(1)
threadID=1
threads=[]
threadlist=["thread-1","thread-2","thread-3"]
namelist=["one","two","three","four","five"]
#创建线程
for  tName   in  threadlist:
     thread=myThread(threadID,tName,workQueue)
     thread.start()
     threads.append(thread)
     threadID+=1

#填充我们的队列
queueLock.acquire()
for word in namelist:
       workQueue.put(word)
queueLock.release()

#等待队列清空
while not workQueue.empty():
         pass

exitflag=1

#等待所有线程完成
for t in threads:
    t.join()
print("退出主线程")

#输出
开始线程:thread-1
开始线程:thread-2
开始线程:thread-3
thread-3 processing one
thread-2 processing threethread-1 processing two

thread-3 processing four
thread-2 processing five
退出线程:thread-3
退出线程:thread-2
退出线程:thread-1
退出主线程

学习笔记来源：菜鸟教程