python多线程

Cpython解释器本身就不是线程安全的，因此有全局解释器锁（GIL），一次只允许使用一个线程执行Python字节码。因此，一个python进程通常不能同时使用多个CPU核心。 Python标准库中的所有阻塞性I/O函数都会释放GIL，允许其他线程运行，time.sleep()都会释放GIL。因此，尽管有GIL，Python线程，还是能在I/O密集型应用中发挥作用。 如果场景为CPU密集型场景，可以尝试PyPy。 来源： https://www.cnblogs.com/liuer-mihou/p/11909835.html

定义1、进程：就是一组资源的集合。一个程序就是一个进程。 线程是用来干活的，只有进程的话是没办法运行的，进程里其实是线程在具体干活的。 线程和线程之间是互相独立的。 import threading #引入线程模块 import time def run(): time.sleep(5) print('over') start_time=time.time() run() run() run() run() end_time=time.time() print('run_time', end_time-start_time) #结果：run_time=20.38954234234 上面这个例子是单线程执行的，运行时间是20多秒，如果使用多线程，则会并行执行，执行结果应该是5秒左右。 import threading import time def run(): time.sleep(5) print('over') start_time=time.time() thread_list = [] for i in range(5): t=threading.Thread(target=run) #实例化一个线程 t.start() #启动这个线程 thread_list.append(t) for thread in thread_list: thread.join()

Gevent官网文档地址： http://www.gevent.org/contents.html 进程、线程、协程区分 我们通常所说的协程Coroutine其实是corporate routine的缩写，直接翻译为协同的例程，一般我们都简称为协程。 在linux系统中，线程就是轻量级的进程，而我们通常也把协程称为轻量级的线程即微线程。 进程和协程 下面对比一下进程和协程的相同点和不同点： 相同点： 相同点存在于，当我们挂起一个执行流的时，我们要保存的东西： 栈， 其实在你切换前你的局部变量，以及要函数的调用都需要保存，否则都无法恢复 寄存器状态,这个其实用于当你的执行流恢复后要做什么 而寄存器和栈的结合就可以理解为上下文，上下文切换的理解： CPU看上去像是在并发的执行多个进程，这是通过处理器在进程之间切换来实现的，操作系统实现这种交错执行的机制称为上下文切换 操作系统保持跟踪进程运行所需的所有状态信息。这种状态，就是上下文。 在任何一个时刻，操作系统都只能执行一个进程代码，当操作系统决定把控制权从当前进程转移到某个新进程时，就会进行上下文切换，即保存当前进程的上下文，恢复新进程的上下文，然后将控制权传递到新进程，新进程就会从它上次停止的地方开始。 不同点： 执行流的调度者不同，进程是内核调度，而协程是在用户态调度，也就是说进程的上下文是在内核态保存恢复的

#创建线程 #encoding=utf-8 from threading import Thread #引入线程的包 import time def run(a = None, b = None) : print(a, b ) time.sleep(1) t = Thread(name = "g1",target = run, args = ("g1", "thread")) #此时线程是新建状态 print(t.getName()) #获得线程对象名称 print(t.isAlive()) #判断线程是否还活着，在start后，在执行完毕前调用isAlive()才会返回True t.start() #启动线程 t.join() #主线程等待子线程t执行结束 print("Done!") D:\>py -3 a.py g1 False g1 thread Done! #通过继承Thread类创建线程 #encoding=utf-8 import threading import time class timer(threading.Thread): #The timer class is derived from the class threading.Thread def __init__(self, num, interval): threading.Thread.__init

一：多线程和多进程 进程是多个资源的集合。 线程是就是进程里面具体干活的。 线程和线程之间是互相独立的。 二：多线程使用threading模块 启用多线程： import threading def down_load(): time.sleep(5) print("运行完了") t = threading.Thread(target=down_load,args=('name','abfd')) #生成一个线程实例 t.start 启动线程 线程等待： import threading import time def down_load(): time.sleep(5) print("运行完了") start_time = time.time() for i in range(5): t = threading.Thread(target=down_load) t.start() while threading.activeCount()!=1: pass print(threading.activeCount()) #查看当前线程数 print(threading.current_thread())#查看当前线程 end_time = time.time() print(end_time - start_time) 下载图片： import requests,time

进程是多个资源的集合 线程就是进程里面具体干活的 线程和线程之间是相互独立的 多线程：适用于IO密集型任务 多进程：适用于CPU密集型任务 一、多线程 线程需要使用threading模块 启动线程的方法： threading.Thread(target=XXX,args=('xxx','xxx')) #target接的是函数名，args接的是传递的参数，如果只有一个参数要这么写args=('xxx',) 通过threading.Thread实例出来的线程都是子线程，只有最先开始的一个线程是主线程 写一个简单的多线程 import threading def down_load(): time.sleep(1) print('运行完了') for i in range(5): #循环5次，即启动5个线程 t=threading.Thread(target=down_load) #实例化一个线程 t.start() #启动线程 print(threading.active_count()) #查看当前线个程数 print(threading.current_thread())#查看当前线程 如果说我现在想看一下启动的线程全部执行完要多久，这就涉及到线程等待，线程等待是用join，使用jion会比较麻烦，可以用一个while循环的方式来处理。 import threading

有时候join()我们是用来连接字符串的, 但就在今天我学习进程的时候, 看见 join(), 居然不是用来连接字符串了, 而是用来阻塞进程, 兴趣大增, 便深入了解了一下, join()的作用: 在进程中可以阻塞主进程的执行, 直到等待子线程全部完成之后, 才继续运行主线程后面的代码 我们先来看下面的代码, 这段代码没有使用join() 代码段A import threading import time def test(num): time.sleep(1) print(num) #定义一个用来装子线程的列表 threads = [] for i in range(5): #target 指定子线程要执行的funtion, args 指定该funtion需要传入的参数 thread = threading.Thread(target = test, args = [i]) #上面的 thread 是一个个参数i都不同的线程, 现在把它一个个装进列表 threads 里面 threads.append(thread) for i in tsreads: #for 循环执行 threads 列表里面的全部线程, 没有用 join()线程是无序执行的, # 就连最后一句print('end')可能比所有子线程都要先执行 i.start() print('end') 执行结果,

一、进程 进程的概念 1.进程是一个实体。每个进程都有自己的地址空间(CPU分配)。实体空间包括三部分： * 文本区域：存储处理器执行的代码。 * 数据区域：存储变量或进程执行期间使用的动态分配的内存。 * 堆栈：进程执行时调用的指令和本地变量。 2.进程是一个“执行中的程序”。 程序是指令与数据的有序集合,程序本身是没有生命的,只有CPU赋予程序生命时(CPU执行程序),它才能成为一个活动的实体,称为“进程”。 概括来说，进程就是一个具有独立功能的程序在某个数据集上的一次运行活动 进程的特点 * 动态性：进程是程序的一次执行过程，动态产生，动态消亡。 * 独立性：进程是一个能独立运行的基本单元。是系统分配资源与调度的基本单元。 * 并发性：任何进程都可以与其他进程并发执行。 二、并发与并行 并发：在操作系统中，某一时间段，几个程序在同一个CPU上运行，但在任意一个时间点上，只有一个程序在CPU上运行。 当有多个线程时，如果系统只有一个CPU，那么CPU不可能真正同时进行多个线程，CPU的运行时间会被划分成若干个时间段，每个时间段分配给各个线程去执行，一个时间段里某个线程运行时，其他线程处于挂起状态，这就是并发。并发解决了程序排队等待的问题，如果一个程序发生阻塞，其他程序仍然可以正常执行。 并行：当操作系统有多个CPU时，一个CPU处理A线程，另一个CPU处理B线程

目录 实现多线程 直接调用 继承 多线程的一些方法 显示当前线程信息 获取线程ID 获取当前活跃线程数 获取全部线程对象 守护线程 锁 锁的作用 互斥锁 死锁问题 递归锁 信号量 事件 数据库连接模型 红路灯模型 定时器 条件 队列 线程池 多进程与多线程的效率对比 特点 全局解释器锁(GIL) 数据安全性问题 全局解释器锁是什么 全局解释器锁会造成的问题 既然有全局解释器锁的限制那python的多线程就没用了吗？ 实现多线程 直接调用 from threading import Thread import time def func(n): # 子线程要做的事情 time.sleep(1) print(n) for i in range(10): t = Thread(target=func,args=(i,))# 实例化线程，并且传递参数 t.start()# 启动线程 继承 from threading import Thread import time class MyThread(Thread): def __init__(self, arg): super().__init__() self.arg = arg def run(self): time.sleep(1) print(self.arg) for i in range(10): t = MyThread(i)

python高级 和is的使用 is 判断地址 比较两个引用是否指向了同一个对象（引用比较） 判断值 比较两个对象是否相等 深拷贝和浅拷贝 深拷贝 返回拷贝过的新对象 是对于一个对象所有层次的拷贝（递归） 浅拷贝 两个变量指向同一地址 是对于一个对象的顶层拷贝 拷贝的是引用 动态语言 运行时可以修改类和对象的内容，有__slots__约束属性值 生成器 generator 定义 在Python中，这种一边循环一边计算的机制，称为生成器 生成式 可对返回的值进行加工 yield 返回当前值，暂停 send 发送一个值 协程 两个方法交替执行，模拟多任务实现方式之一 迭代器 iterator 定义 迭代是访问集合元素的一种方式。 迭代器是一个可以记住遍历的位置的对象。 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。 可以使用for循环和next() 生成器是迭代器，迭代器不一定是生成器 判断是否可以迭代 引用一个集合的模块 from collections.abc import Iterable,Iterator isinstance(listA, Iterator) iter函数 可迭代对象转换为迭代器 装饰器 decorator 闭包 方法内部声明方法，内部方法引用外部方法的变量，外部方法返回内部的引用 定义 拓展函数功能的一种函数，