线程锁

from threading import Thread,Lock

x= 0

mutex = Lock()

def task():

global x

mutex.acquire()

for i in range(1000000):

x = x+1

mutex.release()

# 开启线程锁线程就只能一个一个去执行，执行完了再去执行下一个线程，保证数据安全

if name == 'main':

t1 = Thread(target=task)

t2 = Thread(target=task)

t3 = Thread(target=task)

t1.start()

t2.start()

t3.start()

t1.join()

t2.join()

t3.join()

print(x)

from threading import Thread,Lock
x = 0
mutex = Lock()
def task():
global x
mutex.acquire()
for i in range(100000):
x = x+1
mutex.release()
if name == 'main':
t1 = Thread(target=task)
t2 = Thread(target=task)
t3 = Thread(target=task)
t1.start()
t2.start()
t3.start()

t1.join()
t2.join()
t3.join()

print(x)

信号量

from threading import Thread,currentThread,Semaphore

import time

def task():

sm.acquire()

print(f'{currentThread().name}在执行')

time.sleep(3)

sm.release()

sm = Semaphore(5)

for i in range(15):

t = Thread(target=task)

t.start()

from threading import Thread,currentThread,Semaphore
import time
sm = Semaphore(5) # 一次最多可以执行5个线程
def task():
# sm = Semaphore(5)
sm.acquire()
print(f'{currentThread().name}在执行')
time.sleep(3)
sm.release()

sm = Semaphore(5)

for i in range(15):
t = Thread(target=task)
t.start()

GIL锁Cpython

在Cpython解释器中有一把GIL锁（全局解释器锁），Gil锁本质是一把互斥锁

导致了同一进程下，同一时间只能运行一个程序，无法利用多核优势

同一进程下多个程序只能实现并发不能实现并行

为什么有GIL？

因为cpython自带垃圾回收机制不是线程安全的，所以要有GIL锁

导致了同一进程下，同一时间只能运行一个线程，无法利用多核优势

分析：

我们有四个任务需要处理，处理方式肯定要玩出并发的效果，解决方案可以是：

方案一：开启四个进程

方案二：一个进程下，开启四个线程

计算密集型 推荐使用多进程

每个都要计算10s

多线程

在同一时刻只有一个线程会被执行，也就意味着每个10s都不能省，分开每个都要计算10s,共40s

多进程

可以并行的执行多个线程，10s+开启进程的时间

io 密集型 推荐多线程

4个任务每个任务90%大部分时间都在io

每个任务io 10s,0.5s

多线程

可以实现并发，每个线程io的时间不咋占用cpu,10s + 4个任务的计算时间

多进程

可以实现并行，10s+1个任务执行的时间+ 开启进程的时间

多进程VS多线程

from threading import Thread
from multiprocessing import Process
import time

计算密集型

def work1():

res=0

for i in range(100000000): #1+8个0

res*=i

if name == 'main':

t_list = []

start = time.time()

for i in range(4):

# t = Thread(target=work1)

t = Process(target=work1)

t_list.append(t)

t.start()

for t in t_list:

t.join()

end = time.time()

# print('多线程',end-start) # 多线程 15.413789510726929

print('多进程',end-start) # 多进程 4.711405515670776

# io密集型

def work1():

x = 1+1

time.sleep(5)

if name == 'main':

t_list = []

start = time.time()

for i in range(4):

t = Thread(target=work1)

# t = Process(target=work1)

t_list.append(t)

t.start()

for t in t_list:

t.join()

end = time.time()

print('多线程',end-start) # 多线程 5.002625942230225

# print('多进程',end-start) # 多进程 5.660863399505615

转载于:https://www.cnblogs.com/1012zlb/p/11545069.html