标签：多进程 als 线程调度 blocking 避免 lse tar func ase
创建锁、锁定锁、释放锁
from threading import Lock # 创建锁 mutex = Lock() # 获取锁（上锁） mutex.acquire() # 释放锁（解锁） mutex.release()
在锁定锁的过程中acquire()方法可以接受一个blocking参数，
如果设定blocking为True，则当前线程会堵塞，直到获取到这个锁为止（如果没有 指定，那么默认为True）
如果设定blocking为False，则当前线程不会堵塞
上锁和解锁的过程（假设是多线程调度）：
这个锁一般是为共享资源服务的，即多个线程同时使用共享资源。这个锁同一时间只能有一个线程调度，其他线程阻塞，只有当前调度的线程释放这个锁，阻塞的线程才能调度。
锁的优点：
确保了某段关键代码只能有一个线程从头到尾完整的执行。
锁的缺点：
组织了多线程的并发执行，包含锁的某段代码实际上只能以单线程模式执行，效率就大大的降低了；代码中可能存在多个锁，如果多个线程拥有多个锁，容易造成死锁。
死锁的现象（实例）：
# 死锁 两者都没有释放对方需要的锁，而释放的条件恰好是获取对方释放所需要的锁 # 线程1 class MyThread1(threading.Thread): def __init__(self): super().__init__() def run(self): # 线程1获取A锁 if mutexA.acquire(): print(self.name+"-----do1---up-----") sleep(1) # 此时线程2获取了B锁，需要等待线程2释放B锁 if mutexB.acquire(): print(self.name + "-----do1---down-----") mutexB.release() mutexA.release() # 线程2 class MyThread2(threading.Thread): def __init__(self): super().__init__() def run(self): # 线程2获取B锁 if mutexB.acquire(): print(self.name + "-----do2---up-----") sleep(1) # 此时线程1获取了A锁，需要等待线程1释放A锁 if mutexA.acquire(): print(self.name + "-----do2---down-----") mutexA.release() mutexB.release() mutexA = threading.Lock() mutexB = threading.Lock() if __name__ == ‘__main__‘: # 线程1和线程2同时执行 t1 = MyThread1() t2 = MyThread2() t1.start() t2.start()
避免死锁的方法：（银行家算法，看实例）
# 银行家算法 class Task1(threading.Thread): def __init__(self): super().__init__() def run(self): while True: if lock1.acquire(): print("Task1".center(20, "-")) sleep(0.5) lock2.release() class Task2(threading.Thread): def __init__(self): super().__init__() def run(self): while True: if lock2.acquire(): print("Task2".center(20, "-")) sleep(0.5) lock3.release() class Task3(threading.Thread): def __init__(self): super().__init__() def run(self): while True: if lock3.acquire(): print("Task3".center(20, "-")) sleep(0.5) lock1.release() lock1 = threading.Lock() lock2 = threading.Lock() lock3 = threading.Lock() lock2.acquire() lock3.acquire() t1 = Task1() t2 = Task2() t3 = Task3() t1.start() t2.start() t3.start()
是否采用多任务处理，取决于我们的任务类型
如果是计算密集型，需要大量的CPU资源进行运算，代码的运行效率至关重 要，这样的任务一般不使用多线程进行，因为频繁的任务调度会拖慢CPU的
运算。
如果是IO密集型，涉及到硬盘读写，网络读写等的任务，更多的时间在等待 IO操作完成，这一类任务可以放到多线程或多进程中来进行。
单线程、多线程、多进程（一起实现同一代码的时间）
# 单线程、多线程、多进程的使用及不同 # 简单的求和 def fib(x): res = 0 for i in range(100000000): res += i*x return res # 阶乘 def fac(x): if x < 2: return 1 return x*fac(x-1) # 简单的求和 def sum(x): res = 0 for i in range(50000000): res += i*x return res # 函数列表 funcs = [fib, fac, sum] n = 100 class MyThread(threading.Thread): def __init__(self, func, args, name=""): super().__init__() self.name = name self.func = func self.args = args self.res = 0 def getResult(self): return self.res def run(self): print("starting ", self.name, " at: ", ctime()) self.res = self.func(self.args) print(self.name, "finished at: ", ctime()) def main(): nfuncs = range(len(funcs)) print("单线程".center(30, "*")) start = time() for i in nfuncs: print("start {} at: {}".format(funcs[i].__name__, ctime())) start_task = time() print(funcs[i](n)) end_task = time() print("任务 耗时：", end_task-start_task) print("{} finished at: {}".format(funcs[i].__name__, ctime())) end = time() print("单线程运行时间：", end-start) print("单线程结束：".center(30, "*")) print() print("多线程".center(30, "*")) start = time() threads = [] for i in nfuncs: # 一个线程绑定一个函数 t = MyThread(funcs[i], n, funcs[i].__name__) threads.append(t) for i in nfuncs: # 同时启动线程 threads[i].start() for i in nfuncs: threads[i].join() print(threads[i].getResult()) end = time() print("多线程运行时间：", end-start) print("多线程结束：".center(30, "*")) print() print("多进程".center(30, "*")) start = time() process_list = [] for i in nfuncs: # 一个进程绑定一个函数 t = Process(target=funcs[i], args=(n, )) process_list.append(t) for i in nfuncs: # 同时启动进程 process_list[i].start() for i in nfuncs: process_list[i].join() end = time() print("多进程运行时间：", end - start) print("多进程结束：".center(30, "*")) if __name__ == "__main__": main()
标签：多进程 als 线程调度 blocking 避免 lse tar func ase
原文地址：https://www.cnblogs.com/aitiknowledge/p/11442905.html
