"""

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.

"""

# 计算密集型

from multiprocessing import Process

from threading  import Thread

import  os,time

def work ():

    res = 0

    for i in range(10000000):

        res *= 1

if __name__ == '__main__':

    l=[]

    print(os.cpu_count()) # 本机电脑的核数

    start = time.time()

    for i in range(6):

        # p= Thread(target=work)  # 开线程  run time is 0.10372185707092285

        p=Process(target=work)    # 开进程   run time is 0.8038477897644043

        l.append(p)

        p.start()

    for p in l:

        p.join()

    stop = time.time()

    print('run time is %s'%(stop-start))

# IO密集型

from  multiprocessing import Process

from threading  import  Thread

import  threading

import os

import time

def work():

    time.sleep(2)

if __name__ == '__main__':

    l=[]

    print(os.cpu_count())

    start = time.time()

    for i in range(40):

        # p = Process(target=work) # 进程耗时 run time is 2.7755727767944336

        p=Thread(target=work ) #线程耗时  2.005638360977173

        l.append(p)

        p.start()

    for p in l :

        p.join()

        stop = time.time()

    print(' run time is %s'%(stop-start))

from threading import Thread

import time

n=100

def task():

    global n

    tmp = n

    time.sleep(2) # IO阻塞等待的 相当于一把锁

    n= tmp -1

t_list = []

for i in range(100):

    t = Thread(target=task)

    t.start()

    t_list.append(t)

for t in t_list:

    t.join()

print(n)

>> 99/0

"""time.sleep(2) # IO操作阻塞等待的 相当于一把锁，

100个中随机第一个抢到锁后，后面的就就进不去了,把这个条件取消掉就能全部依次取完，结果为0 """

from  threading import Thread,Lock,RLock,current_thread

import time

from threading import Thread,Lock,current_thread,RLock

import time

"""

Rlock可以被第一个抢到锁的人连续的acquire和release

每acquire一次锁身上的计数加1

每release一次锁身上的计数减1

只要锁的计数不为0 其他人都不能抢

"""

# mutexA = Lock()

# mutexB = Lock()

mutexA = mutexB = RLock()  # A B现在是同一把锁

class MyThread(Thread):

    def run(self):  # 创建线程自动触发run方法 run方法内调用func1 func2相当于也是自动触发

        self.func1()

        self.func2()

    def func1(self):

        mutexA.acquire()

        print('%s抢到了A锁'%self.name)  # self.name等价于current_thread().name

        mutexB.acquire()

        print('%s抢到了B锁'%self.name)

        mutexB.release()

        print('%s释放了B锁'%self.name)

        mutexA.release()

        print('%s释放了A锁'%self.name)

    def func2(self):

        mutexB.acquire()

        print('%s抢到了B锁'%self.name)

        time.sleep(1)

        mutexA.acquire()

        print('%s抢到了A锁' % self.name)

        mutexA.release()

        print('%s释放了A锁' % self.name)

        mutexB.release()

        print('%s释放了B锁' % self.name)

for i in range(10):

    t = MyThread()

    t.start()

"""

互斥锁:一个厕所(一个坑位)

信号量:公共厕所(多个坑位)

"""

from threading import Semaphore,Thread

import time

import random

sm = Semaphore(5)  # 造了一个含有五个的坑位的公共厕所

def task(name):

    sm.acquire()

    print('%s占了一个坑位'%name)

    time.sleep(random.randint(1,3)) #随机阻塞

    sm.release()

for i in range(40):

    t = Thread(target=task,args=(i,))

    t.start()
四十个循环随机产生枪锁和释放锁

from threading import Event,Thread

import time

# 先生成一个event对象

e = Event()

def light():

    print('红灯正亮着')

    time.sleep(3)

    e.set()  # 发信号

    print('绿灯亮了')

def car(name):

    print('%s正在等红灯'%name)

    e.wait()  # 等待信号

    print('%s加油门飙车了'%name)

t = Thread(target=light)

t.start()

for i in range(10):

    t = Thread(target=car,args=('伞兵%s'%i,))

    t.start()

>>>>:

import queue

q=queue.PriorityQueue()

#put进入一个元组,元组的第一个元素是优先级(通常是数字,也可以是非数字之间的比较),数字越小优先级越高

q.put((20,'a'))

q.put((10,'b'))

q.put((30,'c'))

print(q.get())

print(q.get())

print(q.get())

'''

结果(数字越小优先级越高,优先级高的优先出队):

(10, 'b')

(20, 'a')

(30, 'c')

'''