python锁死一个参数值 python锁机

转载

mob64ca1418e88d 2023-10-02 11:11:40

文章标签 python锁死一个参数值开发语言 python 多线程死锁 文章分类 Python 后端开发

全局解释器锁（GIL）

同步锁（互斥锁）

死锁

进程锁

全局解释器锁（GIL）

什么是全局解释器锁
每个CPU在同一时间只能执行一个线程，每个线程在执行之前都会拿到一把GIL锁，只有拿到这把锁才能正常执行任务，其他的线程就必须等待该线程的使用权消失后才能使用全局解释器，GIL锁只存在于cpython中，在其他解释器中不存在。

全局解释器锁的好处

避免大量加锁解锁的操作
使数据更加安全，解决多线程间的数据的完整行和同步性

理解记忆

python有GIL锁的原因，同一进程下多个线程，实际上同一时刻，只有一个线程在执行
因为GIL锁的原因，所以在python上开进程的用的比较多，而在其他语言一般不开多进程，只开多线程
cpython解释器开多线程不能利用多核优势，因为GIL只限制线程，所以可以开多进程才能利用多核优势，其他语言不存在这个问题
如果是8核CPU的电脑，想充分利用8核优势，至少要开8个进程，同时运行这8个进程，CPU使用率才是100%
但是如果不存在GIL锁，就可以一个进程下，开启8个线程，也能充分利用CPU资源，跑满CPU
为了充分利用多核CPU，可以使用多进程来实现并行计算，每个进程拥有独立的解释器和GIL锁。另外，每个进程下开启的线程可以被多个CPU调度执行，从而充分利用多核CPU。
cpython解释器：io密集型使用多线程，计算密集型使用多进程

# -io密集型，当线程遇到 I/O 操作时，它会把自己从运行队列中移除，然后让 CPU 执行其他线程，同时等待 I/O 操作完成。这个过程被称为阻塞。当 I/O 操作完成后，操作系统会将线程重新添加到运行队列中，然后让 CPU 执行它。

# -计算密集型，消耗cpu，如果开了8个线程，第一个线程会一直占着cpu，而不会调度到其他线程执行，其他7个线程根本没有机会执行，所以我们可以开8个进程，每个进程有一个线程，8个进程下的线程会被8个cpu执行，从而效率高

同步锁（互斥锁）

开多进程或者多线程虽然可以提高效率，但是会出现安全问题，多线程同时操作一个数据，容易出现数据错乱，产生并发安全问题，可以通过加锁，让原本的并发，变成串行，牺牲效率，保证安全，其次线程的队列也可以避免并发安全问题，所有队列的本质也是锁

例:以下是加锁的代码实现

使用锁的目的是让多个线程之间对共享资源的访问变成串行，避免并发访问时出现数据不一致的问题。在本示例中，由于多个线程都要修改count的值，我们使用锁来保证每次只有一个线程在修改，避免出现错误的结果。

import threading

# 定义一个全局变量counter
counter = 0
# 定义一个全局锁
lock = threading.Lock()

# 定义一个函数，该函数会在多线程中被调用
def increment_counter():
    # 获取锁
    lock.acquire()
    global counter
    # 对全局变量counter加1
    counter += 1
    # 释放锁
    lock.release()

# 创建多个线程，每个线程调用increment_counter函数
for i in range(10):
    t = threading.Thread(target=increment_counter)
    t.start()

# 等待所有线程执行完毕
for t in threading.enumerate():
    if t != threading.current_thread():
        t.join()

# 输出最终结果
print("Counter value: ", counter)

例：下面是不加锁的代码，用于演示多线程操作数据时可能发生的并发安全问题：

这个代码中，全局变量 num 初始值为 0，然后创建了两个线程分别执行自增和自减操作，每个线程执行 10000 次操作。这个操作看起来是并发的，实际上由于没有加锁，两个线程可能会同时访问并修改 num 变量，导致结果不可预测。最后输出 num 的值，预期结果应该是 0，但是实际上可能不是 0，因为线程执行的顺序和调度是不可预测的。

import threading

# 全局变量 num，初始值为 0
num = 0

# 自增函数，执行 10000 次 num += 1 操作
def increment():
    global num
    for i in range(10000):
        num += 1

# 自减函数，执行 10000 次 num -= 1 操作
def decrement():
    global num
    for i in range(10000):
        num -= 1

# 创建两个线程，一个执行自增操作，一个执行自减操作
t1 = threading.Thread(target=increment)
t2 = threading.Thread(target=decrement)

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

# 等待两个线程执行完毕
t1.join()
t2.join()

# 输出 num 的值，预期值为 0，但实际上可能不是 0
print(num)