python——threading模块

一、什么是线程

线程是操作系统能够进行运算调度的最小单位。进程被包含在进程中，是进程中实际处理单位。一条线程就是一堆指令集合。

一条线程是指进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

二、什么是进程

进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。

三、区别

进程（process）是一块包含了某些资源的内存区域。操作系统利用进程把它的工作划分为一些功能单元。

进程中所包含的一个或多个执行单元称为线程（thread）。进程还拥有一个私有的虚拟地址空间，该空间仅能被它所包含的线程访问。

线程只能归属于一个进程并且它只能访问该进程所拥有的资源。当操作系统创建一个进程后，该进程会自动申请一个名为主线程或首要线程的线程。

处理IO密集型任务或函数用线程；

处理计算密集型任务或函数用进程。

四、GIL

首先需要明确的一点是 GIL 并不是Python的特性，它是在实现Python解析器(CPython)时所引入的一个概念。就好比C++是一套语言（语法）标准，但是可以用不同的编译器来编译成可执行代码。有名的编译器例如GCC，INTEL C++，Visual C++等。Python也一样，同样一段代码可以通过CPython，PyPy，Psyco等不同的Python执行环境来执行。像其中的JPython就没有GIL。然而因为CPython是大部分环境下默认的Python执行环境。所以在很多人的概念里CPython就是Python，也就想当然的把 GIL 归结为Python语言的缺陷。所以这里要先明确一点：GIL并不是Python的特性，Python完全可以不依赖于GIL

那么CPython实现中的GIL又是什么呢？GIL全称 Global Interpreter Lock 为了避免误导，我们还是来看一下官方给出的解释：

In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple native threads from executing Python bytecodes at once. This lock is necessary mainly because CPython’s memory management is not thread-safe. (However, since the GIL exists, other features have grown to depend on the guarantees that it enforces.)

GIL限制：在同一时刻，只能有一个线程进入CPython解释器。

解决GIL限制的办法：

（1）Multiprocess

既然多线程不能同时进入Cpython解释器，那么，我们可以通过把多个线程放入不同进程中，让多进程进入Cpython解释器，分配给各个CUP，以利用多核实现并行。

（2）C

五、创建线程

导入模块threading，通过threading.Thread()创建线程。其中target接收的是要执行的函数名字，args接收传入函数的参数，以元组（）的形式表示。

import threading

def foo(n)
    print("foo%s"%n)
t1 = threading.Thread(target=foo,args=(1,))　　#创建线程对象

六、启动线程

通过线程对象t1.start()或t2.start()启动线程。

t1 = threading.Thread(target=sayhi, args=(1,))  # 生成一个线程实例
t2 = threading.Thread(target=sayhi, args=(2,))  # 生成另一个线程实例

t1.start()  # 启动线程
t2.start()  # 启动另一个线程

 

实例1：

import threading
import time

def foo(n):
    print("foo%s"%n)
    time.sleep(1)

def bar(n):
    print("bar%s"%n)
    time.sleep(2)

t1 = threading.Thread(target=foo,args=(1,))
t2 = threading.Thread(target=bar,args=(2,))

t1.start()
t2.start()

print("...in the main...")

结果：

程序启动后，主线程从上到下依次执行，t1、t2两个子线程启动后，与主线程并行，抢占CPU资源。因此，前三行的输出结果几乎同时打印，没有先后顺序，此时，需要等t1和t2都结束后程序才结束。故等待2s后，程序结束。程序总共花了2s。

foo1
bar2
...in the main...

Process finished with exit code 0

实例2：

import threading
from time import ctime,sleep
import time

def music(func):
    for i in range(2):
        print ("Begin listening to %s. %s" %(func,ctime()))
        sleep(4)
        print("end listening %s"%ctime())

def move(func):
    for i in range(2):
        print ("Begin watching at the %s! %s" %(func,ctime()))
        sleep(5)
        print('end watching %s'%ctime())

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.start()

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

结果：

Begin listening to 七里香. Thu Sep 29 14:21:55 2016
Begin watching at the 阿甘正传! Thu Sep 29 14:21:55 2016
all over Thu Sep 29 14:21:55 2016
end listening Thu Sep 29 14:21:59 2016
Begin listening to 七里香. Thu Sep 29 14:21:59 2016
end watching Thu Sep 29 14:22:00 2016
Begin watching at the 阿甘正传! Thu Sep 29 14:22:00 2016
end listening Thu Sep 29 14:22:03 2016
end watching Thu Sep 29 14:22:05 2016

Process finished with exit code 0

七、join（）

在子线程执行完成之前，这个子线程的父线程将一直被阻塞。就是说，当调用join（）的子进程没有结束之前，主进程不会往下执行。对其它子进程没有影响。

实例1：

import threading
from time import ctime,sleep
import time

def music(func):
    for i in range(2):
        print ("Begin listening to %s. %s" %(func,ctime()))
        sleep(4)
        print("end listening %s"%ctime())

def move(func):
    for i in range(2):
        print ("Begin watching at the %s! %s" %(func,ctime()))
        sleep(5)
        print('end watching %s'%ctime())

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.start()
        t.join()

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

结果解析：

t1线程启动→Begin listening→4s后end listening + Begin listening →4s后t2线程启动end listening t1结束 + Begin watching→5s后end listening + Begin watching→5s后end listening t2结束+ all over最后主进程结束。 就是酱紫，有点乱。。。

Begin listening to 七里香. Thu Sep 29 15:00:09 2016
end listening Thu Sep 29 15:00:13 2016
Begin listening to 七里香. Thu Sep 29 15:00:13 2016
end listening Thu Sep 29 15:00:17 2016
Begin watching at the 阿甘正传! Thu Sep 29 15:00:17 2016
end watching Thu Sep 29 15:00:22 2016
Begin watching at the 阿甘正传! Thu Sep 29 15:00:22 2016
end watching Thu Sep 29 15:00:27 2016
all over Thu Sep 29 15:00:27 2016

实例2：

import threading
from time import ctime,sleep
import time

def music(func):
    for i in range(2):
        print ("Begin listening to %s. %s" %(func,ctime()))
        sleep(4)
        print("end listening %s"%ctime())

def move(func):
    for i in range(2):
        print ("Begin watching at the %s! %s" %(func,ctime()))
        sleep(5)
        print('end watching %s'%ctime())

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.start()
    t.join()        #for循环的最后一次t的值,相当于t2

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

结果：

Begin listening to 七里香. Thu Sep 29 15:16:41 2016　　　　#t1和t2线程启动
Begin watching at the 阿甘正传! Thu Sep 29 15:16:41 2016
end listening Thu Sep 29 15:16:45 2016
Begin listening to 七里香. Thu Sep 29 15:16:45 2016
end watching Thu Sep 29 15:16:46 2016
Begin watching at the 阿甘正传! Thu Sep 29 15:16:46 2016
end listening Thu Sep 29 15:16:49 2016　　　　　　　　　　　　#t1结束
end watching Thu Sep 29 15:16:51 2016　　　　　　　　　　　　#t2结束，t2结束之前，主线程一直被阻塞。t2结束主线程继续执行
all over Thu Sep 29 15:16:51 2016　　　　　　　　　　　　　　#主线程结束

实例3：

import threading
from time import ctime,sleep
import time

def music(func):
    for i in range(2):
        print ("Begin listening to %s. %s" %(func,ctime()))
        sleep(4)
        print("end listening %s"%ctime())

def move(func):
    for i in range(2):
        print ("Begin watching at the %s! %s" %(func,ctime()))
        sleep(5)
        print('end watching %s'%ctime())

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.start()
    t1.join()        #当t1调用join()时

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

结果：

Begin listening to 七里香. Thu Sep 29 15:35:35 2016　　　　#t1和t2启动
Begin watching at the 阿甘正传! Thu Sep 29 15:35:35 2016
end listening Thu Sep 29 15:35:39 2016
Begin listening to 七里香. Thu Sep 29 15:35:39 2016
end watching Thu Sep 29 15:35:40 2016
Begin watching at the 阿甘正传! Thu Sep 29 15:35:40 2016
end listening Thu Sep 29 15:35:43 2016　　　　#t1结束，主线程继续往下执行
all over Thu Sep 29 15:35:43 2016　　　　　　#主线程结束
end watching Thu Sep 29 15:35:45 2016　　　　#t2结束

八、setDaemon(True)

将线程声明为守护线程，必须在start() 方法调用之前设置， 如果不设置为守护线程程序会被无限挂起。这个方法基本和join是相反的。当我们 在程序运行中，执行一个主线程，如果主线程又创建一个子线程，主线程和子线程 就兵分两路，分别运行，那么当主线程完成想退出时，会检验子线程是否完成。如 果子线程未完成，则主线程会等待子线程完成后再退出。但是有时候我们需要的是 只要主线程完成了，不管子线程是否完成，都要和主线程一起退出，这时就可以用setDaemon方法。

实例：

import threading
from time import ctime,sleep
import time

def music(func):
    for i in range(2):
        print ("Begin listening to %s. %s" %(func,ctime()))
        sleep(4)
        print("end listening %s"%ctime())

def move(func):
    for i in range(2):
        print ("Begin watching at the %s! %s" %(func,ctime()))
        sleep(5)
        print('end watching %s'%ctime())

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())

结果：

Begin listening to 七里香. Thu Sep 29 15:45:32 2016　　　　#t1和t2启动，分别打印一次后sleep，主进程继续
Begin watching at the 阿甘正传! Thu Sep 29 15:45:32 2016
all over Thu Sep 29 15:45:32 2016　　　　　　　　　　　　　　#主进程结束，程序结束

 九、current_thread()

获取当前进程的名称。

 

十、同步锁

import time
import threading

def addNum():
    global num #在每个线程中都获取这个全局变量
    # num-=1

    temp=num
    print('--get num:',num )
    #time.sleep(0.1)
    num =temp-1 #对此公共变量进行-1操作


num = 100  #设定一个共享变量
thread_list = []
for i in range(100):
    t = threading.Thread(target=addNum)
    t.start()
    thread_list.append(t)

for t in thread_list: #等待所有线程执行完毕
    t.join()

print('final num:', num )

用num -= 1则最终结果没问题，这是因为完成这个操作太快了，在线程切换时间内。用中间变量temp进行赋值时出现问题，这是因为100个线程，每一个都没有执行完就就行了切换，因此最终得到的不是0。

多个线程同时操作同一个共享资源，所以导致冲突，这种情况就需要用同步锁来解决。

import time
import threading

def addNum():
    global num #在每个线程中都获取这个全局变量
    # num-=1
    lock.acquire()　　　　#加同步锁
    temp=num
    print('--get num:',num )
    #time.sleep(0.1)
    num =temp-1 #对此公共变量进行-1操作
    lock.release()　　　　#解锁

num = 100  #设定一个共享变量
thread_list = []
lock=threading.Lock()　　#创建lock对象

for i in range(100):
    t = threading.Thread(target=addNum)
    t.start()
    thread_list.append(t)

for t in thread_list: #等待所有线程执行完毕
    t.join()　　　　　　#所有线程执行完后主程序才能结束

print('final num:', num )

GIL与同步锁的作用对比：

GIL：同一时刻只能有一个线程进入解释器。

同步锁：同一时刻，保证只有一个线程被执行，在局部保证操作共享资源时不会发生冲突。

 

十一、线程死锁和递归锁

所谓死锁： 是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。 由于资源占用是互斥的，当某个进程提出申请资源后，使得有关进程在无外力协助下，永远分配不到必需的资源而无法继续运行，这就产生了一种特殊现象死锁。

实例：

import threading,time

class myThread(threading.Thread):
    def doA(self):
        lockA.acquire()
        print(self.name,"gotlockA",time.ctime())
        time.sleep(3)
        lockB.acquire()
        print(self.name,"gotlockB",time.ctime())
        lockB.release()
        lockA.release()

    def doB(self):
        lockB.acquire()
        print(self.name,"gotlockB",time.ctime())
        time.sleep(2)
        lockA.acquire()
        print(self.name,"gotlockA",time.ctime())
        lockA.release()
        lockB.release()
    def run(self):
        self.doA()
        self.doB()
if __name__=="__main__":

    lockA=threading.Lock()
    lockB=threading.Lock()
    threads=[]
    for i in range(5):
        threads.append(myThread())
    for t in threads:
        t.start()
    for t in threads:
        t.join()#等待线程结束，后面再讲。

死锁解决办法：

使用递归锁,创建Rlock对象，在需要加锁时使用

lockA=threading.Lock()
lockB=threading.Lock()


lock = threading.Rlock()