#test.py内容
import os,time
print(os.getpid())
time.sleep(1000)#打开终端执行
python3 test.py#在windows下查看
tasklist |findstr python#在linux下下查看
ps aux |grep python

View Code

解释器的代码是所有线程共享的，所以垃圾回收线程也可能访问到解释器的代码而去执行，这就导致了一个问题:对于同一个数据100，可能线程1执行x=100的同时，而垃圾回收执行的是回收100的操作，解决这种问题没有什么高明的方法，就是加锁处理，即GIL,保证python解释器同一时间只能执行一个任务的代码。

1、100个线程去抢GIL锁，即抢执行权限
2、肯定有一个线程先抢到GIL（暂且称为线程1），然后开始执行，一旦执行就会拿到lock.acquire()
3、极有可能线程1还未运行完毕，就有另外一个线程2抢到GIL，然后开始运行，但线程2发现互斥锁lock还未被线程1释放，于是阻塞，被迫交出执行权限，即释放GIL
4、直到线程1重新抢到GIL，开始从上次暂停的位置继续执行，直到正常释放互斥锁lock，然后其他的线程再重复2 3 4的过程

from threading import Thread,Lock
import os,time
def work():global nlock.acquire()temp=ntime.sleep(0.1)n=temp-1lock.release()
if __name__ == '__main__':lock=Lock()n=100l=[]for i in range(100):p=Thread(target=work)l.append(p)p.start()for p in l:p.join()print(n) #结果肯定为0，由原来的并发执行变成串行，牺牲了执行效率保证了数据安全，不加锁则结果可能为99

1、cpu到底是用来做计算的，还是用来做I/O的？2、多cpu，意味着可以有多个核并行完成计算，所以多核提升的是计算性能3、每个cpu一旦遇到I/O阻塞，仍然需要等待，所以多核对I/O操作没什么用处

1、对计算来说，cpu越多越好，但是对于I/O来说，再多的cpu也没用
2、当然对运行一个程序来说，随着cpu的增多执行效率肯定会有所提高（不管提高幅度多大，总会有所提高），这是因为一个程序基本上不会是纯计算或者纯I/O，所以我们只能相对的去看一个程序到底是计算密集型还是I/O密集型，从而进一步分析python的多线程到底有无用武之地

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

如果四个任务是计算密集型，没有多核来并行计算，方案一徒增了创建进程的开销，方案二胜
如果四个任务是I/O密集型，方案一创建进程的开销大，且进程的切换速度远不如线程，方案二胜

如果四个任务是计算密集型，多核意味着并行计算，在python中一个进程中同一时刻只有一个线程执行用不上多核，方案一胜
如果四个任务是I/O密集型，再多的核也解决不了I/O问题，方案二胜

#！/usr/bin/env python3
#-*- coding:utf-8 -*-
# write by congcongfrom multiprocessing import Process
from threading import Thread
import time,osdef task():res = 10for i in range(10000000):res *= iif __name__ == '__main__':t_list = []print(os.cpu_count()) # 显示本机cpu核心数  4start = time.time()for i in range(16):p = Process(target=task) # 耗时 6.345133304595947#p = Thread(target=task) # 耗时：9.412602186203003
        t_list.append(p)p.start()for p in t_list:p.join()stop = time.time()print('Running time is %s'%(stop-start))

View Code

#！/usr/bin/env python3
#-*- coding:utf-8 -*-
# write by congcongfrom multiprocessing import Process
from threading import Thread
import time,osdef work():time.sleep(2)if __name__ == '__main__':w_list = []start = time.time()for i in range(1000):p = Thread(target=work) # 耗时：2.1222898960113525#p = Process(target=work) # 耗时：255.03309321403503 大部分时间都消耗在创建进程上
        w_list.append(p)p.start()for p in w_list:p.join()stop = time.time()print('Running time is %s'%(stop-start))

View Code

#！/usr/bin/env python3
#-*- coding:utf-8 -*-
# write by congcongfrom threading import Thread,Lock,RLock
import timemuteA = Lock()
muteB = Lock()class MyThread(Thread):def run(self): # run方法是固定方法
        self.f1()self.f2()def f1(self):muteA.acquire()print('%s 拿到了锁A'%self.name)muteB.acquire()print('%s 拿到了锁B'%self.name)muteB.release()muteA.release()def f2(self):muteB.acquire()print('%s 拿到了锁B'%self.name)time.sleep(1)muteA.acquire()print('%s 拿到了锁A'%self.name)muteA.release()muteB.release()
if __name__ == '__main__':for t in range(10):t = MyThread()t.start()

Thread-1 拿到了锁A
Thread-1 拿到了锁B
Thread-1 拿到了锁B
Thread-2 拿到了锁A原因分析：此时线程卡住不动，即死锁（原因：Thread-1拿到了锁A，拿到了锁B完全没有竞争，Thread-1把f1执行完，
此时锁A锁B都释放,接着执行f2去拿锁B,则Thread-2此时可以拿到锁A，Thread-2又准备接着拿锁B，但锁B在Thread-1手中
，即使Thread-1 停止休眠了，去取锁A，但锁A在Thread-2手中，所以两个线程都无法继续运行）    

#！/usr/bin/env python3
#-*- coding:utf-8 -*-
# write by congcong# 递归锁from threading import Thread,Lock,RLock
import timemuteA = muteB = RLock() # 此时muteA和muteB是同一个互斥锁，初始锁为0,每acquire一次，自加1，每release一次，自减1，仅当值为0时，其他线程才能再获得锁运行
class MyThread(Thread):def run(self):  # run方法是固定方法
        self.f1()self.f2()def f1(self):muteA.acquire() # 锁为1print('%s 拿到了锁A' % self.name)muteB.acquire() # 锁为2print('%s 拿到了锁B' % self.name)muteB.release() # 锁减1
muteA.release() # 锁减1，变为0，完全释放def f2(self):muteB.acquire()print('%s 拿到了锁B' % self.name)time.sleep(1)muteA.acquire()print('%s 拿到了锁A' % self.name)muteA.release()muteB.release()if __name__ == '__main__':for t in range(5):t = MyThread()t.start()

Thread-1 拿到了锁A
Thread-1 拿到了锁B
Thread-1 拿到了锁B
Thread-1 拿到了锁A
Thread-2 拿到了锁A
Thread-2 拿到了锁B
Thread-2 拿到了锁B
Thread-2 拿到了锁A
Thread-4 拿到了锁A
Thread-4 拿到了锁B
Thread-4 拿到了锁B
Thread-4 拿到了锁A
Thread-3 拿到了锁A
Thread-3 拿到了锁B
Thread-3 拿到了锁B
Thread-3 拿到了锁A
Thread-5 拿到了锁A
Thread-5 拿到了锁B
Thread-5 拿到了锁B
Thread-5 拿到了锁A

View Code