线程-threading

python的thread模块是比较底层的模块，python的threading模块是对thread做了一些包装的，可以更加方便的被使用

1. 使用threading模块

单线程执行

1
#coding=utf-8
2
import time
3
?
4
def saySorry():
5
    print("亲爱的，我错了，我能吃饭了吗？")
6
    time.sleep(1)
7
?
8
if __name__ == "__main__":
9
    for i in range(5):
10
        saySorry()

多线程执行

1
#coding=utf-8
2
import threading
3
import time
4
?
5
def saySorry():
6
    print("亲爱的，我错了，我能吃饭了吗？")
7
    time.sleep(1)
8
?
9
if __name__ == "__main__":
10
    for i in range(5):
11
        t = threading.Thread(target=saySorry)
12
        t.start() #启动线程，即让线程开始执行

说明

1. 可以明显看出使用了多线程并发的操作，花费时间要短很多
2. 创建好的线程，需要调用start()方法来启动

2. 主线程会等待所有的子线程结束后才结束

1
#coding=utf-8
2
import threading
3
from time import sleep,ctime
4
?
5
def sing():
6
    for i in range(3):
7
        print("正在唱歌...%d"%i)
8
        sleep(1)
9
?
10
def dance():
11
    for i in range(3):
12
        print("正在跳舞...%d"%i)
13
        sleep(1)
14
?
15
if __name__ == ‘__main__‘:
16
    print(‘---开始---:%s‘%ctime())
17
?
18
    t1 = threading.Thread(target=sing)
19
    t2 = threading.Thread(target=dance)
20
?
21
    t1.start()
22
    t2.start()
23
?
24
    #sleep(5) # 屏蔽此行代码，试试看，程序是否会立马结束？
25
    print(‘---结束---:%s‘%ctime())

3. 查看线程数量

1
#coding=utf-8
2
import threading
3
from time import sleep,ctime
4
?
5
def sing():
6
    for i in range(3):
7
        print("正在唱歌...%d"%i)
8
        sleep(1)
9
?
10
def dance():
11
    for i in range(3):
12
        print("正在跳舞...%d"%i)
13
        sleep(1)
14
?
15
if __name__ == ‘__main__‘:
16
    print(‘---开始---:%s‘%ctime())
17
?
18
    t1 = threading.Thread(target=sing)
19
    t2 = threading.Thread(target=dance)
20
?
21
    t1.start()
22
    t2.start()
23
?
24
    while True:
25
        length = len(threading.enumerate())
26
        print(‘当前运行的线程数为：%d‘%length)
27
        if length<=1:
28
            break
29
?
30
        sleep(0.5)

threading注意点

1. 线程执行代码的封装

通过上一小节，能够看出，通过使用threading模块能完成多任务的程序开发，为了让每个线程的封装性更完美，所以使用threading模块时，往往会定义一个新的子类class，只要继承threading.Thread就可以了，然后重写run方法

示例如下：

1
#coding=utf-8
2
import threading
3
import time
4
?
5
class MyThread(threading.Thread):
6
    def run(self):
7
        for i in range(3):
8
            time.sleep(1)
9
            msg = "I‘m "+self.name+‘ @ ‘+str(i) #name属性中保存的是当前线程的名字
10
            print(msg)
11
?
12
?
13
if __name__ == ‘__main__‘:
14
    t = MyThread()
15
    t.start()

说明

• python的threading.Thread类有一个run方法，用于定义线程的功能函数，可以在自己的线程类中覆盖该方法。而创建自己的线程实例后，通过Thread类的start方法，可以启动该线程，交给python虚拟机进行调度，当该线程获得执行的机会时，就会调用run方法执行线程。

2. 线程的执行顺序

1
#coding=utf-8
2
import threading
3
import time
4
?
5
class MyThread(threading.Thread):
6
    def run(self):
7
        for i in range(3):
8
            time.sleep(1)
9
            msg = "I‘m "+self.name+‘ @ ‘+str(i)
10
            print(msg)
11
def test():
12
    for i in range(5):
13
        t = MyThread()
14
        t.start()
15
if __name__ == ‘__main__‘:
16
    test()

执行结果：(运行的结果可能不一样，但是大体是一致的)

1
    I‘m Thread-1 @ 0
2
    I‘m Thread-2 @ 0
3
    I‘m Thread-5 @ 0
4
    I‘m Thread-3 @ 0
5
    I‘m Thread-4 @ 0
6
    I‘m Thread-3 @ 1
7
    I‘m Thread-4 @ 1
8
    I‘m Thread-5 @ 1
9
    I‘m Thread-1 @ 1
10
    I‘m Thread-2 @ 1
11
    I‘m Thread-4 @ 2
12
    I‘m Thread-5 @ 2
13
    I‘m Thread-2 @ 2
14
    I‘m Thread-1 @ 2
15
    I‘m Thread-3 @ 2

说明

从代码和执行结果我们可以看出，多线程程序的执行顺序是不确定的。当执行到sleep语句时，线程将被阻塞（Blocked），到sleep结束后，线程进入就绪（Runnable）状态，等待调度。而线程调度将自行选择一个线程执行。上面的代码中只能保证每个线程都运行完整个run函数，但是线程的启动顺序、run函数中每次循环的执行顺序都不能确定。

3. 总结

1. 每个线程一定会有一个名字，尽管上面的例子中没有指定线程对象的name，但是python会自动为线程指定一个名字。
2. 当线程的run()方法结束时该线程完成。
3. 无法控制线程调度程序，但可以通过别的方式来影响线程调度的方式。
4. 线程的几种状态

python基础语言

多线程-共享全局变量

1
from threading import Thread
2
import time
3
?
4
g_num = 100
5
?
6
def work1():
7
    global g_num
8
    for i in range(3):
9
        g_num += 1
10
?
11
    print("----in work1, g_num is %d---"%g_num)
12
?
13
?
14
def work2():
15
    global g_num
16
    print("----in work2, g_num is %d---"%g_num)
17
?
18
?
19
print("---线程创建之前g_num is %d---"%g_num)
20
?
21
t1 = Thread(target=work1)
22
t1.start()
23
?
24
#延时一会，保证t1线程中的事情做完
25
time.sleep(1)
26
?
27
t2 = Thread(target=work2)
28
t2.start()

运行结果:

1
---线程创建之前g_num is 100---
2
----in work1, g_num is 103---
3
----in work2, g_num is 103---

列表当做实参传递到线程中

1
from threading import Thread
2
import time
3
?
4
def work1(nums):
5
    nums.append(44)
6
    print("----in work1---",nums)
7
?
8
?
9
def work2(nums):
10
    #延时一会，保证t1线程中的事情做完
11
    time.sleep(1)
12
    print("----in work2---",nums)
13
?
14
g_nums = [11,22,33]
15
?
16
t1 = Thread(target=work1, args=(g_nums,))
17
t1.start()
18
?
19
t2 = Thread(target=work2, args=(g_nums,))
20
t2.start()

运行结果:

1
----in work1--- [11, 22, 33, 44]
2
----in work2--- [11, 22, 33, 44]

总结：

• 在一个进程内的所有线程共享全局变量，能够在不适用其他方式的前提下完成多线程之间的数据共享（这点要比多进程要好）
• 缺点就是，线程是对全局变量随意遂改可能造成多线程之间对全局变量的混乱（即线程非安全）

python基础语言

进程VS线程

功能

• 进程，能够完成多任务，比如 在一台电脑上能够同时运行多个QQ
• 线程，能够完成多任务，比如 一个QQ中的多个聊天窗口

定义的不同

• 进程是系统进行资源分配和调度的一个独立单位.
• 线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.

区别

• 一个程序至少有一个进程,一个进程至少有一个线程.
• 线程的划分尺度小于进程(资源比进程少)，使得多线程程序的并发性高。
• 进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率
• 线线程不能够独立执行，必须依存在进程中

优缺点

线程和进程在使用上各有优缺点：线程执行开销小，但不利于资源的管理和保护；而进程正相反。

同步的概念

1. 多线程开发可能遇到的问题

假设两个线程t1和t2都要对num=0进行增1运算，t1和t2都各对num修改10次，num的最终的结果应该为20。

但是由于是多线程访问，有可能出现下面情况：

在num=0时，t1取得num=0。此时系统把t1调度为”sleeping”状态，把t2转换为”running”状态，t2也获得num=0。然后t2对得到的值进行加1并赋给num，使得num=1。然后系统又把t2调度为”sleeping”，把t1转为”running”。线程t1又把它之前得到的0加1后赋值给num。这样，明明t1和t2都完成了1次加1工作，但结果仍然是num=1。

1
from threading import Thread
2
import time
3
?
4
g_num = 0
5
?
6
def test1():
7
    global g_num
8
    for i in range(1000000):
9
        g_num += 1
10
?
11
    print("---test1---g_num=%d"%g_num)
12
?
13
def test2():
14
    global g_num
15
    for i in range(1000000):
16
        g_num += 1
17
?
18
    print("---test2---g_num=%d"%g_num)
19
?
20
?
21
p1 = Thread(target=test1)
22
p1.start()
23
?
24
# time.sleep(3) #取消屏蔽之后 再次运行程序，结果会不一样，，，为啥呢？
25
?
26
p2 = Thread(target=test2)
27
p2.start()
28
?
29
print("---g_num=%d---"%g_num)

运行结果(可能不一样，但是结果往往不是2000000)：

1
---g_num=284672---
2
---test1---g_num=1166544
3
---test2---g_num=1406832

取消屏蔽之后，再次运行结果如下：

1
---test1---g_num=1000000
2
---g_num=1041802---
3
---test2---g_num=2000000

问题产生的原因就是没有控制多个线程对同一资源的访问，对数据造成破坏，使得线程运行的结果不可预期。这种现象称为“线程不安全”。

2. 什么是同步

同步就是协同步调，按预定的先后次序进行运行。如:你说完，我再说。

"同"字从字面上容易理解为一起动作

其实不是，"同"字应是指协同、协助、互相配合。

如进程、线程同步，可理解为进程或线程A和B一块配合，A执行到一定程度时要依靠B的某个结果，于是停下来，示意B运行;B依言执行，再将结果给A;A再继续操作。

3. 解决问题的思路

对于本小节提出的那个计算错误的问题，可以通过线程同步来进行解决

思路，如下:

1. 系统调用t1，然后获取到num的值为0，此时上一把锁，即不允许其他现在操作num
2. 对num的值进行+1
3. 解锁，此时num的值为1，其他的线程就可以使用num了，而且是num的值不是0而是1
4. 同理其他线程在对num进行修改时，都要先上锁，处理完后再解锁，在上锁的整个过程中不允许其他线程访问，就保证了数据的正确性

互斥锁

当多个线程几乎同时修改某一个共享数据的时候，需要进行同步控制

线程同步能够保证多个线程安全访问竞争资源，最简单的同步机制是引入互斥锁。

互斥锁为资源引入一个状态：锁定/非锁定。

某个线程要更改共享数据时，先将其锁定，此时资源的状态为“锁定”，其他线程不能更改；直到该线程释放资源，将资源的状态变成“非锁定”，其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。

threading模块中定义了Lock类，可以方便的处理锁定：

1
#创建锁
2
mutex = threading.Lock()
3
#锁定
4
mutex.acquire([blocking])
5
#释放
6
mutex.release()

其中，锁定方法acquire可以有一个blocking参数。

• 如果设定blocking为True，则当前线程会堵塞，直到获取到这个锁为止（如果没有指定，那么默认为True）
• 如果设定blocking为False，则当前线程不会堵塞

使用互斥锁实现上面的例子的代码如下：

1
from threading import Thread, Lock
2
import time
3
?
4
g_num = 0
5
?
6
def test1():
7
    global g_num
8
    for i in range(1000000):
9
        #True表示堵塞 即如果这个锁在上锁之前已经被上锁了，那么这个线程会在这里一直等待到解锁为止 
10
        #False表示非堵塞，即不管本次调用能够成功上锁，都不会卡在这,而是继续执行下面的代码
11
        mutexFlag = mutex.acquire(True) 
12
        if mutexFlag:
13
            g_num += 1
14
            mutex.release()
15
?
16
    print("---test1---g_num=%d"%g_num)
17
?
18
def test2():
19
    global g_num
20
    for i in range(1000000):
21
        mutexFlag = mutex.acquire(True) #True表示堵塞
22
        if mutexFlag:
23
            g_num += 1
24
            mutex.release()
25
?
26
    print("---test2---g_num=%d"%g_num)
27
?
28
#创建一个互斥锁
29
#这个所默认是未上锁的状态
30
mutex = Lock()
31
?
32
p1 = Thread(target=test1)
33
p1.start()
34
?
35
?
36
p2 = Thread(target=test2)
37
p2.start()
38
?
39
print("---g_num=%d---"%g_num)

运行结果：

1
---g_num=61866---
2
---test1---g_num=1861180
3
---test2---g_num=2000000

可以看到，加入互斥锁后，运行结果与预期相符。

上锁解锁过程

当一个线程调用锁的acquire()方法获得锁时，锁就进入“locked”状态。

每次只有一个线程可以获得锁。如果此时另一个线程试图获得这个锁，该线程就会变为“blocked”状态，称为“阻塞”，直到拥有锁的线程调用锁的release()方法释放锁之后，锁进入“unlocked”状态。

线程调度程序从处于同步阻塞状态的线程中选择一个来获得锁，并使得该线程进入运行（running）状态。

总结

锁的好处：

• 确保了某段关键代码只能由一个线程从头到尾完整地执行

锁的坏处：

• 阻止了多线程并发执行，包含锁的某段代码实际上只能以单线程模式执行，效率就大大地下降了
• 由于可以存在多个锁，不同的线程持有不同的锁，并试图获取对方持有的锁时，可能会造成死锁

多线程-非共享数据

对于全局变量，在多线程中要格外小心，否则容易造成数据错乱的情况发生

1. 非全局变量是否要加锁呢？

1
    #coding=utf-8
2
    import threading
3
    import time
4
?
5
    class MyThread(threading.Thread):
6
        # 重写 构造方法
7
        def __init__(self,num,sleepTime):
8
            threading.Thread.__init__(self)
9
            self.num = num
10
            self.sleepTime = sleepTime
11
?
12
        def run(self):
13
            self.num += 1
14
            time.sleep(self.sleepTime)
15
            print(‘线程(%s),num=%d‘%(self.name, self.num))
16
?
17
    if __name__ == ‘__main__‘:
18
        mutex = threading.Lock()
19
        t1 = MyThread(100,5)
20
        t1.start()
21
        t2 = MyThread(200,1)
22
        t2.start()

1
    import threading
2
    from time import sleep
3
?
4
    def test(sleepTime):
5
        num=1
6
        sleep(sleepTime)
7
        num+=1
8
        print(‘---(%s)--num=%d‘%(threading.current_thread(), num))
9
?
10
?
11
    t1 = threading.Thread(target = test,args=(5,))
12
    t2 = threading.Thread(target = test,args=(1,))
13
?
14
    t1.start()
15
    t2.start()

小总结

• 在多线程开发中，全局变量是多个线程都共享的数据，而局部变量等是各自线程的，是非共享的

死锁

1. 死锁

在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁。

尽管死锁很少发生，但一旦发生就会造成应用的停止响应。下面看一个死锁的例子

1
#coding=utf-8
2
import threading
3
import time
4
?
5
class MyThread1(threading.Thread):
6
    def run(self):
7
        if mutexA.acquire():
8
            print(self.name+‘----do1---up----‘)
9
            time.sleep(1)
10
?
11
            if mutexB.acquire():
12
                print(self.name+‘----do1---down----‘)
13
                mutexB.release()
14
            mutexA.release()
15
?
16
class MyThread2(threading.Thread):
17
    def run(self):
18
        if mutexB.acquire():
19
            print(self.name+‘----do2---up----‘)
20
            time.sleep(1)
21
            if mutexA.acquire():
22
                print(self.name+‘----do2---down----‘)
23
                mutexA.release()
24
            mutexB.release()
25
?
26
mutexA = threading.Lock()
27
mutexB = threading.Lock()
28
?
29
if __name__ == ‘__main__‘:
30
    t1 = MyThread1()
31
    t2 = MyThread2()
32
    t1.start()
33
    t2.start()

此时已经进入到了死锁状态，可以使用ctrl-z退出

3. 避免死锁

• 程序设计时要尽量避免

• 添加超时时间等

  同步应用

  多个线程有序执行

  1
  from threading import Thread,Lock
  2
  from time import sleep
  3
  ?
  4
  class Task1(Thread):
  5
      def run(self):
  6
          while True:
  7
              if lock1.acquire():
  8
                  print("------Task 1 -----")
  9
                  sleep(0.5)
  10
                  lock2.release()
  11
  ?
  12
  class Task2(Thread):
  13
      def run(self):
  14
          while True:
  15
              if lock2.acquire():
  16
                  print("------Task 2 -----")
  17
                  sleep(0.5)
  18
                  lock3.release()
  19
  ?
  20
  class Task3(Thread):
  21
      def run(self):
  22
          while True:
  23
              if lock3.acquire():
  24
                  print("------Task 3 -----")
  25
                  sleep(0.5)
  26
                  lock1.release()
  27
  ?
  28
  #使用Lock创建出的锁默认没有“锁上”
  29
  lock1 = Lock()
  30
  #创建另外一把锁，并且“锁上”
  31
  lock2 = Lock()
  32
  lock2.acquire()
  33
  #创建另外一把锁，并且“锁上”
  34
  lock3 = Lock()
  35
  lock3.acquire()
  36
  ?
  37
  t1 = Task1()
  38
  t2 = Task2()
  39
  t3 = Task3()
  40
  ?
  41
  t1.start()
  42
  t2.start()
  43
  t3.start()
  

  运行结果:

  1
  ------Task 1 -----
  2
  ------Task 2 -----
  3
  ------Task 3 -----
  4
  ------Task 1 -----
  5
  ------Task 2 -----
  6
  ------Task 3 -----
  7
  ------Task 1 -----
  8
  ------Task 2 -----
  9
  ------Task 3 -----
  10
  ------Task 1 -----
  11
  ------Task 2 -----
  12
  ------Task 3 -----
  13
  ------Task 1 -----
  14
  ------Task 2 -----
  15
  ------Task 3 -----
  16
  ...省略...
  

  总结

  • 可以使用互斥锁完成多个任务，有序的进程工作，这就是线程的同步