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

退出主线程

学习笔记来源：菜鸟教程