18、Python之多线程

一、进程与线程概念

     首先说一下进程和程序的区别：程序是静态的，是存在磁盘上的，而进程是在执行中的程序，是在内存中的。起初没有线程的概率，只有进程，一个进程它有独立的资源，这就好比我们把一个班级看做一个进程，黑板，桌椅都是这个班级进程的资源，别的进程（班级）无法享用。对于外界（CPU等）而言班级是一个进程，而实际上在班级中还有很多学生，他们是一个个独立的个体，共享着班级的资源，但由于外界并不知道，一旦班级这个进程被阻塞了，班级内部的学生都无法进行活动了，这显然不适合计算机的高效，因而产生了线程（学生）被外界所认可（cpu）。由此我们可以得出进程和线程的结论为：

    1、进程是作为最小资源分配单位

    2、线程是独立运行的最小单位（被cpu调用）

    3、一个进程下有多个线程，且他们共享进程的资源

    4、一个进程至少有一个线程

   GIL（Global Interpreter Lock）：全局解释器锁

   可能有些人在学python之前就听说过，python有一个缺点就是无法执行多线程，这正是由于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。

二、Python中线程调用的2种方式

    方式一、直接调用

import threading
def run(n):
    print(n)

t1 = threading.Thread(target=run,args=("test1",))
t2 = threading.Thread(target=run,args=("test2",))
t1.start()
t2.start()

上面程序中一共有3个线程，t1,t2以及运行t1,t2的主线程，我们可以使用语句threading.activeCount()打印出当前活跃线程的数量。

  方式二、继承式调用

import threading

class MyThread(threading.Thread):
    def __init__(self,name):
        super(MyThread,self).__init__()
        self.__name = name
    def run(self):
        print(self.__name)

t1 = MyThread("test1")
t2 = MyThread("test2")
t1.start()
t2.start()

三、多线程中的注意点

   1、多线程中，只有一个主线程，主线程可创建多个子线程，子线程一旦被创建后，就与主线程没有半毛钱的关系。因而我们将上面的代码稍微改造一下。

import threading,time

class MyThread(threading.Thread):
    def __init__(self,name):
        super(MyThread,self).__init__()
        self.__name = name
    def run(self):
        time.sleep(1)
        print("线程%s运行完毕" % self.__name)

t1 = MyThread("test1")
t2 = MyThread("test2")
t1.start()
t2.start()
print("主线程运行完毕")

运行结果为：

主线程运行完毕
线程test1运行完毕
线程test2运行完毕

由此可见，一旦主线程创建了子线程之后，将继续运行自己的代码，而子线程独立运行，但是有时候我们期望等待某个线程的执行结束，再运行主线程，这时候需要使用方法join（）。

上述代码要想主线程在2个子线程执行完之后再执行，代码改造如下:

import threading,time

class MyThread(threading.Thread):
    def __init__(self,name):
        super(MyThread,self).__init__()
        self.__name = name
    def run(self):
        time.sleep(1)
        print("线程%s运行完毕" % self.__name)

t1 = MyThread("test1")
t2 = MyThread("test2")
t1.start()
t2.start()
t1.join()
t2.join()
print("主线程运行完毕")

    2、当主线程创建一个守护线程的时，一旦主线程运行结束，守护线程立即结束。在创建线程时使用setDaemon(True)方法就可以将子线程设置为守护线程。

import threading,time

class MyThread(threading.Thread):
    def __init__(self,name):
        super(MyThread,self).__init__()
        self.__name = name
    def run(self):
        time.sleep(1)
        print("线程%s运行完毕" % self.__name)

t1 = MyThread("test1")
t2 = MyThread("test2")
t1.setDaemon(True) #将线程t1设置为守护线程
t2.setDaemon(True) #将线程t2设置为守护线程
t1.start()
t2.start()
print("主线程运行完毕")

运行结果为：主线程运行完毕，子线程还未运行完毕，就结束了。

    3、线程锁：假设有这样一个程序：

import threading,time,random

class MyThread(threading.Thread):
    count = 0
    def __init__(self,name):
        super(MyThread,self).__init__()
        self.__name = name
    def run(self):
        time.sleep(random.randrange(1,10))
        MyThread.count += 1
        print("线程%s运行完毕" % self.__name)
    @classmethod
    def print_count(self):
        print(MyThread.count)

obj_list = []
for i in range(50):
    t = MyThread(i)
    t.start()
    obj_list.append(t)
for obj in obj_list:
    obj.join()
MyThread.print_count()#打印总共的线程数
print("主线程运行完毕")

50个线程一旦被创建后，都会去修改count的值，如果不加锁的话，就会导致count最终的值是错误的（据说python三种做了处理，但是没有官方声明）。为了使count的值最终正确，我们需要给这段代码加一个锁。假设的三步骤：1、申请一把锁：lock = threading.Lock()  2、加锁 lock.acquire() 3、还锁  lock.release()。

    所以正确的代码应该是：

import threading,time,random

lock = threading.Lock() #申请锁
class MyThread(threading.Thread):
    count = 0
    def __init__(self,name):
        super(MyThread,self).__init__()
        self.__name = name
    def run(self):
        time.sleep(random.randrange(1,10))
        lock.acquire() #加锁
        MyThread.count += 1
        lock.release() #释放锁
        print("线程%s运行完毕" % self.__name)
    @classmethod
    def print_count(self):
        print(MyThread.count)

obj_list = []
for i in range(50):
    t = MyThread(i)
    t.start()
    obj_list.append(t)
for obj in obj_list:
    obj.join()
MyThread.print_count()#打印总共的线程数
print("主线程运行完毕")

四、信号量

    有时候我们系统共享的资源可能有多个，这时候需要用到信号量，信号量的使用代码示例如下：

import threading,time

semaphore = threading.BoundedSemaphore(5)
def run(n):
    semaphore.acquire()
    time.sleep(2)
    print(n+1)
    semaphore.release()

for i in range(23):
    t = threading.Thread(target=run,args=(i,))
    t.start()
while threading.active_count()!=1:
    pass
else:
    print("over")

五、递归锁

    我们申请的每一把锁都应该记住其对应的对象地址，否则当有多把锁时，就会容易导致程序死锁。示例代码如下：

import threading
n = 0
lock = {}
lock["1"] = threading.Lock()
lock["2"] = threading.Lock()
lock["3"] = threading.Lock()
#应该记清楚每一把锁
def run1():
    global n
    lock["1"].acquire()
    print("run1")
    n = n + 1
    lock["1"].release()

def run2():
    global n
    lock["2"].acquire()
    print("run2")
    n = n + 1
    lock["2"].release()

def run3():
    global n
    lock["3"].acquire()
    run1()
    run2()
    lock["3"].release()

t = threading.Thread(target=run3)
t.start()
while threading.active_count()!=1:
    print(threading.active_count())
else:
    print("over")

六、事件

    事件其本质就是设置一个标志位，当线程在运行的时候，判断这个标志位，如果标志位未被设置就阻塞。下面是红绿灯的一个代码示例：

import threading,time,random

event = threading.Event()#获取一个event对象

def lighter():
    count = 0
    event.set() #设置标志位
    while True:
        if count >=0 and count<10:
            event.clear() #清除标志位
            print("33[41;1mred light is on...33[0m")
        elif count>=10 and count<20:
            event.set()
            print("33[42;1mgreen light is on...33[0m")
        else:
            count = 0
        time.sleep(1)
        count = count + 1

t = threading.Thread(target=lighter)
t.start()

def car(n):
    while True:
        if event.is_set():#判断标志位是否被设置
            print("the car is passing the accross")
            time.sleep(random.randrange(1,10))
            print("the %s car has accrosee the across..." % n)
            break
        else:
            print("the %s car is wait..." % n)
            event.wait()

for i in range(20):
    t = threading.Thread(target=car,args=(i,))
    t.start()