官方解释:
'''
In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple
native threads from executing Python bytecodes at once. This lock is necessary mainly
because CPython’s memory management is not thread-safe. (However, since the GIL
exists, other features have grown to depend on the guarantees that it enforces.)
'''释义:
在CPython中，这个全局解释器锁，也称为GIL,是一个互斥锁,防止多个线程在同一时间执行Python字节码,这个锁是非常重要的,因为CPython的内存管理非线程安全的,很多其他的特性依赖于GIL,所以即使它影响了程序效率也无法将其直接去除 总结:
在CPython中,GIL会把线程的并行变成串行,导致效率降低

from threading import  Thread
def task():a = 10print(a)# 开启三个子线程执行task函数
Thread(target=task).start()
Thread(target=task).start()
Thread(target=task).start()

from multiprocessing import Process
from threading import Thread
import timedef task():for i in range(10000000):i += 1if __name__ == '__main__':start_time = time.time()# 多进程p1 = Process(target=task)          # 2.053471565246582p2 = Process(target=task)p3 = Process(target=task)p4 = Process(target=task)# 多线程# p1 = Thread(target=task)         # 3.169567823410034# p2 = Thread(target=task)# p3 = Thread(target=task)# p4 = Thread(target=task)
p1.start()p2.start()p3.start()p4.start()p1.join()p2.join()p3.join()p4.join()print(time.time() - start_time)

from multiprocessing import Process
from threading import Thread
import time
def task():with open("test.txt",encoding="utf-8") as f:f.read()
if __name__ == '__main__':start_time = time.time()# 多进程# p1 = Process(target=task)# p2 = Process(target=task)# p3 = Process(target=task)# p4 = Process(target=task)# 多线程p1 = Thread(target=task)p2 = Thread(target=task)p3 = Thread(target=task)p4 = Thread(target=task)p1.start()p2.start()p3.start()p4.start()p1.join()p2.join()p3.join()p4.join()print(time.time()-start_time)

from threading import Thread,Lock
import timea = 0
def task():global atemp = atime.sleep(0.01) a = temp + 1t1 = Thread(target=task)
t2 = Thread(target=task)
t1.start()
t2.start()t1.join()
t2.join()
print(a)

from threading import Thread,Lock
import timelock = Lock()
a = 0
def task():global alock.acquire()temp = atime.sleep(0.01)a = temp + 1lock.release() t1 = Thread(target=task)
t2 = Thread(target=task)t1.start()
t2.start()t1.join()
t2.join()
print(a)

from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
import time,os# 创建进程池,指定最大进程数为3,此时不会创建进程，不指定数量时，默认为CPU和核数
pool = ProcessPoolExecutor(3)def task():time.sleep(1)print(os.getpid(),"working..")if __name__ == '__main__':for i in range(10):pool.submit(task) # 提交任务时立即创建进程# 任务执行完成后也不会立即销毁进程time.sleep(2)for i in range(10):pool.submit(task) #再有新任务是 直接使用之前已经创建好的进程来执行

from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
from threading import current_thread,active_count
import time,os# 创建进程池,指定最大线程数为3,此时不会创建线程，不指定数量时，默认为CPU和核数*5
pool = ThreadPoolExecutor(3)
print(active_count()) # 只有一个主线def task():time.sleep(1)print(current_thread().name,"working..")if __name__ == '__main__':for i in range(10):pool.submit(task) # 第一次提交任务时立即创建线程# 任务执行完成后也不会立即销毁time.sleep(2)for i in range(10):pool.submit(task) #再有新任务时 直接使用之前已经创建好的线程来执行

from concurrent.futures import ThreadPoolExecutor
from threading import current_thread
import timepool = ThreadPoolExecutor(3)
def task(i):time.sleep(0.01)print(current_thread().name,"working..")return i ** iif __name__ == '__main__':objs = []for i in range(3):res_obj = pool.submit(task,i) # 异步方式提交任务# 会返回一个对象用于表示任务结果
        objs.append(res_obj)# 该函数默认是阻塞的 会等待池子中所有任务执行结束后执行
pool.shutdown(wait=True)# 从结果对象中取出执行结果
for res_obj in objs:print(res_obj.result())
print("over")

from concurrent.futures import ThreadPoolExecutor
from threading import current_thread
import timepool = ThreadPoolExecutor(3)
def task(i):time.sleep(0.01)print(current_thread().name,"working..")return i ** iif __name__ == '__main__':objs = []for i in range(3):res_obj = pool.submit(task,i) # 会返回一个对象用于表示任务结果print(res_obj.result()) #result是同步的一旦调用就必须等待 任务执行完成拿到结果
print("over")

import requests,re,os,random,time
from concurrent.futures import ProcessPoolExecutordef get_data(url):print("%s 正在请求%s" % (os.getpid(),url))time.sleep(random.randint(1,2))response = requests.get(url)print(os.getpid(),"请求成功 数据长度",len(response.content))#parser(response) # 3.直接调用解析方法  哪个进程请求完成就那个进程解析数据  强行使两个操作耦合到一起了return responsedef parser(obj):data = obj.result()htm = data.content.decode("utf-8")ls = re.findall("href=.*?com",htm)print(os.getpid(),"解析成功",len(ls),"个链接")if __name__ == '__main__':pool = ProcessPoolExecutor(3)urls = ["https://www.baidu.com","https://www.sina.com","https://www.python.org","https://www.tmall.com","https://www.mysql.com","https://www.apple.com.cn"]# objs = []for url in urls:# res = pool.submit(get_data,url).result() # 1.同步的方式获取结果 将导致所有请求任务不能并发# parser(res)
obj = pool.submit(get_data,url) # obj.add_done_callback(parser) # 4.使用异步回调，保证了数据可以被及时处理，并且请求和解析解开了耦合# objs.append(obj)# pool.shutdown() # 2.等待所有任务执行结束在统一的解析# for obj in objs:#     res = obj.result()#     parser(res)# 1.请求任务可以并发 但是结果不能被及时解析 必须等所有请求完成才能解析# 2.解析任务变成了串行

q =  Queue(3)
q.put(1)
q.put(2)
q.put(3)
print(q.get(timeout=1))
print(q.get(timeout=1))
print(q.get(timeout=1))

lq = LifoQueue()lq.put(1)
lq.put(2)
lq.put(3)print(lq.get())
print(lq.get())
print(lq.get())

pq = PriorityQueue()
# 数字优先级
pq.put((10,"a"))
pq.put((11,"a"))
pq.put((-11111,"a"))print(pq.get())
print(pq.get())
print(pq.get())
# 字符串优先级
pq.put(("b","a"))
pq.put(("c","a"))
pq.put(("a","a"))print(pq.get())
print(pq.get())
print(pq.get())

event.isSet() 　　#：返回event的状态值；
event.wait()　　　#：将阻塞线程；直到event的状态为True
event.set()　　　 #：设置event的状态值为True，所有阻塞池的线程激活进入就绪状态， 等待操作系统调度；
event.clear()    #：恢复event的状态值为False

# 在链接mysql服务器前必须保证mysql已经启动，而启动需要花费一些时间，所以客户端不能立即发起链接 需要等待msyql启动完成后立即发起链接
from threading import Event,Thread
import timeboot = False
def start():global bootprint("正正在启动服务器.....")time.sleep(5)print("服务器启动完成!")boot = Truedef connect():while True:if boot:print("链接成功")breakelse:print("链接失败")time.sleep(1)Thread(target=start).start()
Thread(target=connect).start()
Thread(target=connect).start()

from threading import Event,Thread
import timee = Event()
def start():print("正正在启动服务器.....")time.sleep(3)print("服务器启动完成!")e.set()def connect():e.wait()print("链接成功")Thread(target=start).start()
Thread(target=connect).start()
Thread(target=connect).start()

from threading import Event,Thread
import timee = Event()
def start():global bootprint("正正在启动服务器.....")time.sleep(5)print("服务器启动完成!")e.set()def connect():for i in range(1,4):print("第%s次尝试链接" % i)e.wait(1)if e.isSet():print("链接成功")breakelse:print("第%s次链接失败" % i)else:print("服务器未启动!")Thread(target=start).start()
Thread(target=connect).start()
# Thread(target=connect).start()