python多线程和多进程【1】GIL和RLock（递归锁）

写在最前面：

 

受

打击

了

 

1、什么是线程？

　　线程是操作系统能够进行运算调度的最小单位（程序执行流的最小单元）。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

　　一个标准的线程由线程ID，当前指令指针(PC)，寄存器集合和堆栈组成。另外，线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。由于线程之间的相互制约，致使线程在运行中呈现出间断性。线程也有就绪、阻塞和运行三种基本状态。就绪状态是指线程具备运行的所有条件，逻辑上可以运行，在等待处理机;运行状态是指线程占有处理机正在运行;阻塞状态是指线程在等待一个事件(如某个信号量)，逻辑上不可执行。每一个程序都至少有一个线程，若程序只有一个线程，那就是程序本身。

　　线程是程序中一个单一的顺序控制流程。进程内一个相对独立的、可调度的执行单元，是系统独立调度和分派CPU的基本单位指运行中的程序的调度单位。在单个程序中同时运行多个线程完成不同的工作，称为多线程。

 

2、什么是进程？

　　进程(Process)是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体;在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。里面包含对各种资源的调用，内存的管理，网络接口的调用等。。。对各种资源管理的集合就可以称为进程。

 

3、线程和进程的区别

（1）线程共享内存空间；进程的内存是独立的

（2）同一个进程的线程之间可以直接交流；两个进程想通信，必须通过一个中间代理来实现

（3）创建新进程需要对其父进程进行一次克隆，多进程中的同一个变量各自有一份拷贝在每个进程中，互不影响

（4）多线程中，所有变量都由所有线程共享，任何一个变量都可能被任何一个线程修改

（5）一个线程可以控制和操作同一进程里的其他线程；但是进程只能操作子进程

（6）改变主线程（如优先权），可能会影响其它线程；改变父进程，不影响子进程

 

4、GIL(Global Interpreter Lock)

无论你启多少个线程，你有多少个cpu, Python在执行的时候会淡定的在同一时刻只允许一个线程运行。

这意味着同一时间只有一个获得GIL的线程在跑，其他线程处于等待的状态。这就到这里多线程只是在做时分切换，并不能利用多核。

 

5、关于守护线程和互斥锁Mutex前面的博客有详细的例子说明。

在python3.X中，当你试图通过不加锁去多线程修改数据的时候，结果也总是正确的，如果想尝试，请使用python2.X。

 

6、RLock（递归锁）

什么是递归锁？就是锁里头包含子锁。

举个最简单的例子吧

import threading
import time


class ChangeMoney():

    def First(name):
        global money
        for i in range(10):
            if mutex.acquire():
                money = money + 1
                msg = "%s set money to " % name + str(money)
                print(msg)
                mutex.release()



money = 0
mutex = threading.Lock()

threads = []
t1 = threading.Thread(target=ChangeMoney.First, args=(u'First',))
threads.append(t1)

if __name__ == '__main__':
    for t in threads:
        # t = ChangeMoney()
        t.start()

看此时的输出threading.Lock()

First set money to 1
First set money to 2
First set money to 3
First set money to 4
First set money to 5
First set money to 6
First set money to 7
First set money to 8
First set money to 9
First set money to 10

 

当普通锁在同一个线程中不释放锁

import threading
import time


class ChangeMoney():

    def First(name):
        global money
        for i in range(10):
            if mutex.acquire():
                money = money + 1
                msg = "%s set money to " % name + str(money)
                print(msg)
                #mutex.release()



money = 0
mutex = threading.Lock()

threads = []
t1 = threading.Thread(target=ChangeMoney.First, args=(u'First',))
threads.append(t1)

if __name__ == '__main__':
    for t in threads:
        # t = ChangeMoney()
        t.start()

此时死锁 

First set money to 1

 

那么当我们换成RLock ()

import threading
import time


class ChangeMoney():

    def First(name):
        global money
        for i in range(10):
            if mutex.acquire():
                money = money + 1
                msg = "%s set money to " % name + str(money)
                print(msg)
                #mutex.release()



money = 0
mutex = threading.RLock()

threads = []
t1 = threading.Thread(target=ChangeMoney.First, args=(u'First',))
threads.append(t1)

if __name__ == '__main__':
    for t in threads:
        # t = ChangeMoney()
        t.start()

输出正常：

First set money to 1
First set money to 2
First set money to 3
First set money to 4
First set money to 5
First set money to 6
First set money to 7
First set money to 8
First set money to 9
First set money to 10

 

注意，RLock只允许在同一线程中被多次acquire()。

 

这样也会死锁，无法启动第二个线程，因为第一个线程没有释放。

import threading
import time


class ChangeMoney():

    def First(name):
        global money
        for i in range(10):
            if mutex.acquire():
                money = money + 1
                msg = "%s set money to " % name + str(money)
                print(msg)
                #mutex.release()


    def Second(name):
        global money
        for i in range(10):
            if mutex.acquire():
                money = money + 1
                msg = "%s set money to " % name + str(money)
                print(msg)
                mutex.release()

    def Third(name):
        global money
        for i in range(10):
            if mutex.acquire():
                money = money + 1
                msg = "%s set money to " % name + str(money)
                print(msg)
                mutex.release()


money = 0
mutex = threading.RLock()

threads = []
t1 = threading.Thread(target=ChangeMoney.First, args=(u'First',))
threads.append(t1)
t2 = threading.Thread(target=ChangeMoney.Second, args=(u'Second',))
threads.append(t2)
t3 = threading.Thread(target=ChangeMoney.Third, args=(u'Third',))
threads.append(t3)

if __name__ == '__main__':
    for t in threads:
        # t = ChangeMoney()
        t.start()

First set money to 1
First set money to 2
First set money to 3
First set money to 4
First set money to 5
First set money to 6
First set money to 7
First set money to 8
First set money to 9
First set money to 10

此时死锁。