python多个线程全局变量 python多线程全局变量做同步

多线程及线程同步

• 1 简介
• 2 多线程的使用

• 2.1 导入线程模块
• 2.2 创建线程

• 2.2.1普通创建方式+传参
• 2.2.2继承方式创建（未看）

• 2.3 主线程会等待所有的子线程执行结束再结束
• 2.4 .setDaemon() 方法
• 2.5 .join()方法
• 2.6.threading模块提供的方法
• 2.7 其他线程实例方法

• 3 多线程之间共享全局变量
• 4 多线程共享全局变量出现的问题
• 5 线程同步

• 5.1 线程等待join（就不是真正的并发了）
• 5.2 互斥锁

• 5.2.1 互斥锁介绍
• 5.2.2 互斥锁的使用

• 5.3 死锁
• 5.4 信号量（BoundedSemaphore类）
• 5.5 Event事件（查资料自己补充）
• 5.6 其他线程同步措施（查资料补充）
• 5.6 GIL全局解释锁

• 6 进程和线程的对比

• 6.1.进程和线程的对比的三个方向
• 6.2 关系对比
• 6.3 区别对比
• 6.4 优缺点对比
• 6.5.小结

• 7 Python多线程能够做并行计算吗？

1 简介

什么是线程？

• 线程也叫轻量级进程，是操作系统能够进行运算调度的最小单位，它被包涵在进程之中，是进程中的实际运作单位。
• 线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其他线程共享进程所拥有的全部资源。一个线程可以创建和撤销另一个线程，同一个进程中的多个线程之间可以并发执行

为什么要使用多线程？

• 线程在程序中是独立的、并发的执行流。与分隔的进程相比，进程中线程之间的隔离程度要小，它们共享内存、文件句柄 和其他进程应有的状态。
• 因为线程的划分尺度小于进程，使得多线程程序的并发性高。进程在执行过程之中拥有独立的内存单元，而多个线程共享内存，从而极大的提升了程序的运行效率。
• 线程比进程具有更高的性能，这是由于同一个进程中的线程都有共性，多个线程共享一个进程的虚拟空间。线程的共享环境包括进程代码段、进程的共有数据等，利用这些共享的数据，线程之间很容易实现通信。
• 操作系统在创建进程时，必须为改进程分配独立的内存空间，并分配大量的相关资源，但创建线程则简单得多。因此，使用多线程来实现并发比使用多进程的性能高得要多。

总结起来，使用多线程编程具有如下几个优点：

• 进程之间不能共享内存，但线程之间共享内存非常容易。
• 操作系统在创建进程时，需要为该进程重新分配系统资源，但创建线程的代价则小得多。因此使用多线程来实现多任务并发执行比使用多进程的效率高。

python语言内置了多线程功能支持，而不是单纯地作为底层操作系统的调度方式，从而简化了python的多线程编程。

2 多线程的使用

2.1 导入线程模块

导入线程模块

import threading

2.2 创建线程

2.2.1普通创建方式+传参

from threading import Thread
import time
 
 
def sing():
    for i in range(3):
        print('正在唱歌。。。', i)
        time.sleep(2)
 
 
def dance():
    for i in range(3):
        print('正在跳舞。。。', i)
        time.sleep(2)
 
 
def main():
    t1 = Thread(target=sing)
    t2 = Thread(target=dance)
    t1.start()
    t2.start()
 
 
if __name__ == '__main__':
    main()
    print('程序结束。。。')

执行顺序：
首先程序运行时，程序从上往下走，遇到main()函数然后开始执行，执行main()函数的函数体时又创建了两个线程我们称之为子线程，程序运行时的线程我们称之为主线程。

然后子线程根据target=xxx 开始执行指定的函数。

(等子线程结束后主线程结束,程序结束了)

传递参数：

args 表示以元组的方式给执行任务传参
kwargs 表示以字典方式给执行任务传参

import threading
import time


# 带有参数的任务
def task(count):
    for i in range(count):
        print("任务执行中..")
        time.sleep(0.2)
    else:
        print("任务执行完成")


if __name__ == '__main__':
    # 创建子线程
    # args: 以元组的方式给任务传入参数
    sub_thread = threading.Thread(target=task, args=(5,))
    sub_thread.start()

import threading
import time


# 带有参数的任务
def task(count):
    for i in range(count):
        print("任务执行中..")
        time.sleep(0.2)
    else:
        print("任务执行完成")


if __name__ == '__main__':
    # 创建子线程
    # kwargs: 表示以字典方式传入参数
    sub_thread = threading.Thread(target=task, kwargs={"count": 3})
    sub_thread.start()

2.2.2继承方式创建（未看）

import threading
from threading import Lock,Thread
import time,os

class MyThread(threading.Thread):
    def __init__(self,n):
         super(MyThread,self).__init__()   #重构run函数必须写
         self.n = n

    def run(self):
         print('task',self.n)
         time.sleep(1)
         print('2s')
         time.sleep(1)
         print('1s')
         time.sleep(1)
         print('0s')
         time.sleep(1)

if __name__ == '__main__':
     t1 = MyThread('t1')
     t2 = MyThread('t2')
     t1.start()
     t2.start()

2.3 主线程会等待所有的子线程执行结束再结束

假如我们现在创建一个子线程，这个子线程执行完大概需要2.5秒钟，现在让主线程执行1秒钟就退出程序，查看一下执行结果，示例代码如下:

import threading
import time


# 测试主线程是否会等待子线程执行完成以后程序再退出
def show_info():
    for i in range(5):
        print("test:", i)
        time.sleep(0.5)


if __name__ == '__main__':
    sub_thread = threading.Thread(target=show_info)
    sub_thread.start()

    # 主线程延时1秒
    time.sleep(1)
    print("over")

执行结果:

test: 0
test: 1
over
test: 2
test: 3
test: 4

说明:
通过上面代码的执行结果，我们可以得知: 主线程会等待所有的子线程执行结束再结束

我们为了保证主线程正常退出，不再等待子线程，该怎么办？

我们可以将子线程设置为守护线程

2.4 .setDaemon() 方法

setDaemon()将当前线程设置成守护线程来守护主线程:

• 当主线程结束后，守护线程也就结束，不管是否执行完成。
• 应用场景：qq 多个聊天窗口，就是守护线程，qq主界面退出，聊天窗口就结束。

注意:需要在子线程开启的时候设置成守护线程，否则无效。

from threading import Thread
import time
 
 
def sing(num):
    for i in range(num):
        print('正在唱歌。。。', i)
        time.sleep(2)
 
 
def dance(num):
    for i in range(num):
        print('正在跳舞。。。', i)
        time.sleep(2)
 
 
def main():
    t1 = Thread(target=sing, args=(3,))
    t2 = Thread(target=dance, args=(3,))
    t1.setDaemon(True)   # 设置成守护线程
    t2.setDaemon(True)
    t1.start()
    t2.start()
 
 
if __name__ == '__main__':
    main()
    print('程序结束了')

输出：

正在唱歌。。。 0
正在跳舞。。。 0
程序结束了

所谓线程守护，就是主线程不管该线程的执行情况，只要是其他子线程结束且主线程执行完毕，主线程都会关闭。也就是说：主线程不等待该守护线程的执行完再去关闭。

2.5 .join()方法

当前线程执行完后其他线程才会继续执行。主线程会在这里阻塞，直到这个线程结束！

def run(n):
     print('task',n)
     time.sleep(2)
     print('5s')
     time.sleep(2)
     print('3s')
     time.sleep(2)
     print('1s')
 if __name__ == '__main__':
     t=threading.Thread(target=run,args=('t1',))
     t.setDaemon(True)    #把子线程设置为守护线程，必须在start()之前设置
     t.start()
     t.join()     #设置主线程等待子线程结束
     print('end')

为了让守护线程执行结束之后，主线程再结束，我们可以使用join方法，让主线程等待子线程执行。不光是用在守护线程上，平时也可以用。

2.6.threading模块提供的方法

threading.currentThread(): 返回当前的线程变量。

threading.enumerate(): 返回一个包含正在运行的线程的list。

正在运行指线程启动后、结束前，不包括启动前和终止后的线程。

threading.activeCount():

返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

import threading
import time
 
 
def sing(num):
    for i in range(num):
        print('正在唱歌。。。', i)
        time.sleep(2)
    print(threading.current_thread())  # <Thread(Thread-1, started 9032)>
 
 
def dance(num):
    for i in range(num):
        print('正在跳舞。。。', i)
        time.sleep(2)
        # 返回当前线程的变量
    print(threading.current_thread())  # <Thread(Thread-2, started 10152)>
 
 
def main():
    t1 = threading.Thread(target=sing, args=(3,))
    t2 = threading.Thread(target=dance, args=(3,))
    t1.start()
    # 返回正在运行的线程的列表
    print(threading.enumerate())
    # [<_MainThread(MainThread, started 5024)>, <Thread(Thread-1, started 8392)>]
 
    print(threading.active_count())  # 2  返回正在进行的线程数量
    t2.start()
    print(threading.current_thread())  # <_MainThread(MainThread, started 7496)>
 
 
if __name__ == '__main__':
    main()
    print('程序结束了')

2.7 其他线程实例方法

线程对象的一些实例方法，了解即可

• getName(): 获取线程的名称。
• setName(): 设置线程的名称。
• isAlive(): 判断当前线程存活状态。

from threading import Thread
import time
import threading

def sing(num):
    for i in range(num):
        print("z唱歌中。。。",1)
        time.sleep(2)

def dance(num):
    for i in range(num):
        print("跳舞中。。。",1)
        time.sleep(2)
def main():
    t1=Thread(target=sing,args=(3,))
    t2=Thread(target=dance,args=(3,))
    t1.setName("zhangfei")
    t2.setName("guanyu")
    print(t1.getName())
    print(t2.getName())
    t1.start()
    print(t1.is_alive)
    t2.start()
    print(t2.is_alive())

if __name__=='__main__':
    main()
    print("over")

3 多线程之间共享全局变量

线程时进程的执行单元，进程时系统分配资源的最小执行单位，所以在同一个进程中的多线程是共享资源的。

看个例子：

import threading
import time


# 定义全局变量
my_list = list()

# 写入数据任务
def write_data():
    for i in range(5):
        my_list.append(i)
        time.sleep(0.1)
    print("write_data:", my_list)


# 读取数据任务
def read_data():
    print("read_data:", my_list)


if __name__ == '__main__':
    # 创建写入数据的线程
    write_thread = threading.Thread(target=write_data)
    # 创建读取数据的线程
    read_thread = threading.Thread(target=read_data)

    write_thread.start()
    # 延时
    # time.sleep(1)
    # 主线程等待写入线程执行完成以后代码在继续往下执行
    write_thread.join()
    print("开始读取数据啦")
    read_thread.start()

输出结果：

write_data: [0, 1, 2, 3, 4]
开始读取数据啦
read_data: [0, 1, 2, 3, 4]

4 多线程共享全局变量出现的问题

需求:

1 定义两个函数，实现循环100万次，每循环一次给全局变量加1
2 创建两个子线程执行对应的两个函数，查看计算后的结果

import threading

# 定义全局变量
g_num = 0


# 循环一次给全局变量加1
def sum_num1():
    for i in range(1000000):
        global g_num
        g_num += 1

    print("sum1:", g_num)


# 循环一次给全局变量加1
def sum_num2():
    for i in range(1000000):
        global g_num
        g_num += 1
    print("sum2:", g_num)


if __name__ == '__main__':
    # 创建两个线程
    first_thread = threading.Thread(target=sum_num1)
    second_thread = threading.Thread(target=sum_num2)

    # 启动线程
    first_thread.start()
    # 启动线程
    second_thread.start()

结果：

sum1: 1210949
sum2: 1496035

注意点: 多线程同时对全局变量操作数据发生了错误

错误分析:

两个线程first_thread和second_thread都要对全局变量g_num(默认是0)进行加1运算，但是由于是多线程同时操作，有可能出现下面情况：

• 在g_num=0时，first_thread取得g_num=0。此时系统把first_thread调度为”sleeping”状态，把second_thread转换为”running”状态，t2也获得g_num=0
• 然后second_thread对得到的值进行加1并赋给g_num，使得g_num=1
• 然后系统又把second_thread调度为”sleeping”，把first_thread转为”running”。线程t1又把它之前得到的0加1后赋值给g_num。
• 这样导致虽然first_thread和first_thread都对g_num加1，但结果仍然是g_num=1

5 线程同步

线程同步: 保证同一时刻只能有一个线程去操作全局变量 同步: 就是协同步调，按预定的先后次序进行运行。如:你说完，我再说, 好比现实生活中的对讲机。

线程同步，可以理解为线程A和B一块配合工作，A执行到一定程度时要依靠B的某个结果，于是停下来示意B执行，B执行完将结果给A,然后A继续执行。A强依赖B(对方)，A必须等到B的回复，才能做出下一步响应。即A的操作(行程)是顺序执行的，中间少了哪一步都不可以，或者说中间哪一步出错都不可以。

由于线程之间是进行随机调度的，如果有多个线程同时操作一个对象，如果没有很好地保护该对象，会造成程序结果的不可预期，我们因此也称为“线程不安全”。

线程同步有很多种方法：join可以实现，此外还有互斥锁，自旋锁等各种锁，还有信号量等等。

5.1 线程等待join（就不是真正的并发了）

import threading

# 定义全局变量
g_num = 0


# 循环1000000次每次给全局变量加1
def sum_num1():
    for i in range(1000000):
        global g_num
        g_num += 1

    print("sum1:", g_num)


# 循环1000000次每次给全局变量加1
def sum_num2():
    for i in range(1000000):
        global g_num
        g_num += 1
    print("sum2:", g_num)


if __name__ == '__main__':
    # 创建两个线程
    first_thread = threading.Thread(target=sum_num1)
    second_thread = threading.Thread(target=sum_num2)

    # 启动线程
    first_thread.start()
    # 主线程等待第一个线程执行完成以后代码再继续执行，让其执行第二个线程
    # 线程同步： 一个任务执行完成以后另外一个任务才能执行，同一个时刻只有一个任务在执行
    first_thread.join()
    # 启动线程
    second_thread.start()

5.2 互斥锁

5.2.1 互斥锁介绍

当多个线程几乎同时修改一个共享数据的时候，需要进行同步控制，线程同步能够保证多个线程安全的访问竞争资源(全局内容)，最简单的同步机制就是使用互斥锁。

某个线程要更改共享数据时，先将其锁定，此时资源的状态为锁定状态，其他线程就能更改，直到该线程将资源状态改为非锁定状态，也就是释放资源，其他的线程才能再次锁定资源。互斥锁保证了每一次只有一个线程进入写入操作。从而保证了多线程下数据的安全性。互斥锁是多个线程一起去抢，抢到锁的线程先执行，没有抢到锁的线程需要等待，等互斥锁使用完释放后，其它等待的线程再去抢这个锁。

5.2.2 互斥锁的使用

threading模块中定义了Lock变量，这个变量本质上是一个函数，通过调用这个函数可以获取一把互斥锁。

互斥锁使用步骤:

# 创建锁
mutex = threading.Lock()

# 上锁
mutex.acquire()

...这里编写代码能保证同一时刻只能有一个线程去操作, 对共享数据进行锁定...

# 释放锁
mutex.release()

注意点:

• acquire和release方法之间的代码同一时刻只能有一个线程去操作。
• 如果在调用acquire方法的时候 其他线程已经使用了这个互斥锁，那么此时acquire方法会堵塞，直到这个互斥锁释放后才能再次上锁。
• 所以，对想实现线程同步的所有进程都要用这两个方法进行锁住。如果有线程不使用互斥锁，那么他还是可以和锁住的进程实现并发的。

示例：
使用互斥锁完成2个线程对同一个全局变量各加100万次的操作

import threading


# 定义全局变量
g_num = 0

# 创建全局互斥锁
lock = threading.Lock()


# 循环一次给全局变量加1
def sum_num1():
    # 上锁
    lock.acquire()
    for i in range(1000000):
        global g_num
        g_num += 1

    print("sum1:", g_num)
    # 释放锁
    lock.release()


# 循环一次给全局变量加1
def sum_num2():
    # 上锁
    lock.acquire()
    for i in range(1000000):
        global g_num
        g_num += 1
    print("sum2:", g_num)
    # 释放锁
    lock.release()


if __name__ == '__main__':
    # 创建两个线程
    first_thread = threading.Thread(target=sum_num1)
    second_thread = threading.Thread(target=sum_num2)
    # 启动线程
    first_thread.start()
    second_thread.start()

提示：

• 加上互斥锁，哪个线程抢到这个锁我们决定不了，哪个线程抢到锁哪个线程先执行，没有抢到的线程需要等待
• 加上互斥锁多任务瞬间变成单任务，性能会下降，也就是说同一时刻只能有一个线程去执行

小结：

• 互斥锁的作用就是保证同一时刻只能有一个线程去操作共享数据，保证共享数据不会出现错误问题
• 使用互斥锁的好处确保某段关键代码只能由一个线程从头到尾完整地去执行
• 使用互斥锁会影响代码的执行效率，多任务改成了单任务执行
• 互斥锁如果没有使用好容易出现死锁的情况

5.3 死锁

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

如果锁之间相互嵌套，就有可能出现死锁。因此尽量不要出现锁之间的嵌套。

import threading
import time

def test1():
    lock1.acquire()
    print("test1....")
    time.sleep(2)
    lock2.acquire()
    print("test1....")
    lock2.release()
    lock1.release()

def test2():
    lock2.acquire()
    print("test2....")
    lock1.acquire()
    print("test2....")
    lock1.release()
    lock2.release()

lock1=threading.Lock()
lock2=threading.Lock()

def main():
    t1=threading.Thread(target=test1)
    t2=threading.Thread(target=test2)
    t1.start()
    t2.start()

if __name__='main__':
    main()

上述代码中的test1和test2中都存在互斥锁的嵌套，所以是死锁，实际中要避免。

5.4 信号量（BoundedSemaphore类）

互斥锁同时只允许一个线程更改数据，而Semaphore是同时允许一定数量的线程更改数据，比如厕所有3个坑，那最多只允许3个人上厕所，后面的人只能等里面有人出来了才能再进去。
（查网上资料自己补充）

5.5 Event事件（查资料自己补充）

5.6 其他线程同步措施（查资料补充）

5.6 GIL全局解释锁

6 进程和线程的对比

6.1.进程和线程的对比的三个方向

关系对比
区别对比
优缺点对比

6.2 关系对比

1 线程是依附在进程里面的，没有进程就没有线程。

2 一个进程默认提供一条线程，进程可以创建多个线程。

6.3 区别对比

• 进程之间不共享全局变量
• 线程之间共享全局变量，但是要注意资源竞争的问题，解决办法: 互斥锁或者线程同步
• 创建进程的资源开销要比创建线程的资源开销要大
• 进程是操作系统资源分配的基本单位，线程是CPU调度的基本单位
• 线程不能够独立执行，必须依存在进程中
• 多进程开发比单进程多线程开发稳定性要强

6.4 优缺点对比

进程优缺点:

• 优点：可以用多核
• 缺点：资源开销大
• 
  

线程优缺点:

• 优点：资源开销小
• 缺点：不能使用多核

6.5.小结

• 进程和线程都是完成多任务的一种方式
• 多进程要比多线程消耗的资源多，但是多进程开发比单进程多线程开发稳定性要强，某个进程挂掉不会影响其它进程。
• 多进程可以使用cpu的多核运行，多线程可以共享全局变量。
• 线程不能单独执行必须依附在进程里面

7 Python多线程能够做并行计算吗？

在Python的原始解释器CPython中存在着GIL(Global Interpreter Lock，全局解释器锁)，因此在解释执行Python代码时，会产生互斥锁来限制线程对共享资源的访问，直到解释器遇到I/O操作或者操作次数达到一定数目时才会释放GIL。

所以有GIL效果就是：一个进程内同一时间只能允许一个线程进行运算 （这尼玛不就是单线程吗？）所以Python的多线程是伪的。

Python怎样实现并行计算：

答案是使用多进程，Python的多进程比多线程计算速度要更快。原因也很好理解，因为多线程其实单线程执行的并且增加了线程切换的开销。
那Python的多线程还有什么意义呢。
当然是有意义的，如果线程存在IO操作就有意义了。使用多线程的话，如果一个线程进行IO操作了，由于IO操作比较耗时，就会启动另一个线程。
总结：
针对python而言：

• 纯运算情况下单线程比多线程更快
• 多线程在IO操作较多情况下才能很好的发挥作用，但效率还是低于多进程
• 单进程运行比单线程慢，但当多进程数够多情况下会超越单线程的速度
• 多进程比单进程运行快
• 对于多进程而言，有return会比没有return慢很多很多，对于多线程却只会慢一点点

疑惑】不管开多少个进程或者线程，各个核占用情况几乎是均匀的，猜测是系统底层有优化