Python 多进程多线程-编程知识

Python 多进程多线程

多任务

并发：在一段时间内交替执行多个任务

并行：在一段时间内同事一起执行多个任务

进程 Process

进程：一个程序运行在系统之上，便称这个程序喂一个运行进程，并分配进程ID方便系统管理。操作系统进行资源分配和调度运行的基本单位

单进程 vs 多进程

+/ 如果程序向利用计算机的多核优势，让CPU同时处理一些任务，适合用多进程开发

先挖个坑后面学

线程 thread

线程是属于进程的，一个进程可以开启多个线程，执行不同工作，是进程实际工作最小单位

同属一个进程的多个线程共享进程所拥有的全部资源

性质

执行顺序

无序，通过CPU调度决定某个线程先执行

结束顺序

主线程会等待所有子线程执行结束后再结束

基本使用

创建线程对象

thread_obj = thread.Thread(target=func)

启动线程执行

thread_obj.start()

import threading
import timedef thread1():while True:print('thread 1')time.sleep(1)def thread2():while True:print('thread 2')time.sleep(1)if __name__ == '__main__':# create threadt1 = threading.Thread(target=thread1)t2 = threading.Thread(target=thread2)# start threadt1.start()t2.start()

等待当前线程任务执行完毕后再向下继续执行

thread_obj.join()

执行带有参数的任务

args：以元组方式进行传参 *参数顺序保持一致

kwargs：以字典的方式给任务传参 *字典key和参数名保持一致

守护线程

主线程不等待子线程执行完成，主线程执行完毕后，子线程也自动关闭

me，thod1

threading.Thread(target = work, daemon = True)

method2

线程对象.setDaemon(True)

获取线程信息

current_thread = threading.current_thread()

print(current_thread)

设置/获取名称

name = 线程对象.current_thread().getName()

线程对象.setName()

自定义线程

class Mythread(threading.Thread):def run(self):print('执行此线程', self.args)t = Mythread(args = (100, ))
t.start()

线程安全

多个线程操作可能会出现数据混乱的情况

*有些数据类型（如列表）是线程安全的

GIL锁

全局解释器锁（Global Interpreter Lock），让一个进程中同一个时刻只能有一个线程可以被CPU调用

Lock 同步锁

创建锁

lock_object = threading.RLock()

加锁

线程对象.acquire()

释放锁

线程对象.release()

e.g

import  threadinglock_object = threading.Lock()loop = 1000
number = 0def _add(count):lock_object.acquire() #加锁global numberfor i in range(count):number += 1print("t1")lock_object.release() #解锁def _sub(count):lock_object.acquire() #申请锁global numberfor i in range(count):number -= 1print("t2")lock_object.release() #解锁t1 = threading.Thread(target=_add,args=(loop,))
t2 = threading.Thread(target=_sub,args=(loop,))
t1.start()
t2.start()t1.join()
t2.join()print(number)

RLock 递归锁

Lock不支持锁的嵌套，RLock支持，就是可以加多次锁

Dead Lock 死锁

由于资源竞争或者彼此通信造成阻塞

线程池

线程不是开的越多越好，开的多了可能导致系统性能降低（线程中的上下文切换），因此不建议无限制的创建线程，建议使用线程池

创建

from concurrent.futures import ThreadPoolExecutor
pool = ThreadPoolExecutor(100) #100个线程的线程池

提交任务

pool.submit(task, sug)

等待线程池执行完毕

pool.shutdown(True)

空闲线程处理额外任务

线程池中提交一个任务，如果有空闲线程，则分配一个线程去执行，执行完毕后再将线程交还给线程池，如果没有空闲线程，则等待

future =pool.submit(task,url)

future.add_done_callback(done)

单例模式

import threading
import timeclass Singleton:instance = Nonelock = threading.RLock()def __init__(self,name):self.name = namedef __new__(cls, *args, **kwargs):  #*args,**kwargs 代表任意多个参数# 这两行提高效率，可要可不要if cls.instance:return cls.instancewith cls.lock:if cls.instance:return cls.instancecls.instance = object.__new__(cls)return cls.instancedef task():obj = Singleton('x')print(obj)for i in range(10):t = threading.Thread(target=task)t.start()