商城站人工售票时间表,东南融通网站建设,开发app的网站,有关电子商务网站建设与维护的书籍并发编程介绍_串行_并行_并发的区别
串行、并行与并发的区别
串行(serial)#xff1a;一个CPU上#xff0c;按顺序完成多个任务并行(parallelism)#xff1a;指的是任务数小于等于cpu核数#xff0c;即任务真的是一起执行的并发(concurrency)#xff1a;一个CPU采用时间…并发编程介绍_串行_并行_并发的区别
串行、并行与并发的区别
串行(serial)一个CPU上按顺序完成多个任务并行(parallelism)指的是任务数小于等于cpu核数即任务真的是一起执行的并发(concurrency)一个CPU采用时间片管理方式交替的处理多个任务。一般是是任务数多余cpu核数通过操作系统的各种任务调度算法实现用多个任务“一起”执行实际上总有一些任务不在执行因为切换任务的速度相当快看上去一起执行而已
线程是程序执行的最小单位而进程是操作系统分配资源的最小单位一个进程由一个或多个线程组成线程是一个进程中代码的不同执行路线进程之间相互独立但同一进程下的各个线程之间共享程序的内存空间(包括代码段、数据集、堆等)及一些进程级的资源(如打开文件和信号)某进程内的线程在其它进程不可见调度和切换线程上下文切换比进程上下文切换要快得多。 进程(Process)拥有自己独立的堆和栈既不共享堆也不共享栈进程由操作系统调度进程切换需要的资源很最大效率低线程(Thread)拥有自己独立的栈和共享的堆共享堆不共享栈标准线程由操作系统调度线程切换需要的资源一般效率一般当然了在不考虑GIL的情况下协程(coroutine)拥有自己独立的栈和共享的堆共享堆不共享栈协程由程序员在协程的代码里显示调度协程切换任务资源很小效率高 进程是什么
进程Process是一个具有一定独立功能的程序关于某个数据集合的一次运行活动 现代操作系统比如Mac OS XLinuxWindows等都是支持“多任务”的操作系统叫“多任务”呢简单地说就是操作系统可以同时运行多个任务。打个比方你一边在用逛淘宝一边在听音乐一边在用微信聊天这就是多任务至少同时有3个任务正在运行。还有很多任务悄悄地在后台同时运行着只是桌面上没有显示而已。 对于操作系统来说一个任务就是一个进程Process比如打开一个浏览器就是启动一个浏览器进程就启动了一个记事本进程打开两个记事本就启动了两个记事本进程打开一个Word就启动了一个Word进程。
线程是什么
线程Thread是操作系统能够进行运算调度的最小单位。它被包含在进程之中是进程中的实际运作单位。 有些进程还不止同时干一件事比如微信它可以同时进行打字聊天视频聊天朋友圈等事情。在一个进程内部要同时干多件事就需要同时运行多个“子任务”我们把进程内的这些“子任务”称为线程Thread。 并发编程解决方案
多任务的实现有3种方式
多进程模式多线程模式多进程多线程模式 启动多个进程每个进程虽然只有一个线程但多个进程可以一块执行多个任务启动一个进程在一个进程内启动多个线程这样多个线程也可以一块执行多个任务启动多个进程每个进程再启动多个线程这样同时执行的任务就更多了当然这种模型更复杂实际很少采用。 协程是什么
协程Coroutines也叫作纤程(Fiber)是一种在线程中比线程更加轻量级的存在由程序员自己写程序来管理。
当出现IO阻塞时CPU一直等待IO返回处于空转状态。这时候用协程可以执行其他任务。当IO返回结果后再回来处理数据。充分利用了IO等待的时间提高了效率。
同步和异步介绍
同步和异步强调的是消息通信机制 (synchronous communication/ asynchronous communication)。
同步(synchronous)A调用B等待B返回结果后A继续执行
异步(asynchronous )A调用BA继续执行不等待B返回结果B有结果了通知AA再做处理。
线程_方法包装创建线程
什么是线程
线程(Thread)特点 线程Thread是操作系统能够进行运算调度的最小单位。它被包含在进程之中是进程中的实际运作单位线程是程序执行的最小单位而进程是操作系统分配资源的最小单位一个进程由一个或多个线程组成线程是一个进程中代码的不同执行路线拥有自己独立的栈和共享的堆共享堆不共享栈标准线程由操作系统调度调度和切换线程上下文切换比进程上下文切换要快得多。 线程的创建方式
Python的标准库提供了两个模块_thread和threading_thread是低级模块threading是高级模块对_thread进行了封装。绝大多数情况下我们只需要使用threading这个高级模块。
线程的创建可以通过分为两种方式
1. 方法包装
2. 类包装
线程的执行统一通过start()方法
线程的创建方式(方法包装)
#encodingutf-8
#方法方式创建线程
from threading import Thread
from time import sleep
def func1(name):for i in range(3):print(fthread:{name} :{i})sleep(1)
if __name__ __main__:print(主线程start)#创建线程t1 Thread(targetfunc1,args(t1,))t2 Thread(targetfunc1,args(t2,))#启动线程t1.start()t2.start()print(主线程end)
运行结果可能会出现换行问题是因为多个线程抢夺控制台输出的IO流。
比如如下的输出换行就没有按照预想的显示
主线程start
thread:t1 :0
thread:t2 :0
主线程end
thread:t2 :1thread:t1 :1
thread:t2 :2
thread:t1 :2线程的创建方式(类包装)
#encodingutf-8
#类的方式创建线程
from threading import Thread
from time import sleep
class MyThread(Thread):def __init__(self,name):Thread.__init__(self)self.name namedef run(self):for i in range(3):print(fthread:{self.name} :{i})sleep(1)
if __name__ __main__:print(主线程start)#创建线程(类的方式)t1 MyThread(t1)t2 MyThread(t2)#启动线程t1.start()t2.start()print(主线程end)线程_join()和守护线程
join()
之前的代码主线程不会等待子线程结束。
如果需要等待子线程结束后再结束主线程可使用join()方法。
#encodingutf-8
from threading import Thread
from time import sleep
def func1(name):for i in range(3):print(fthread:{name} :{i})sleep(1)
if __name__ __main__:print(主线程start)#创建线程t1 Thread(targetfunc1,args(t1,))t2 Thread(targetfunc1,args(t2,))#启动线程t1.start()t2.start()#主线程会等待t1,t2结束后再往下执行t1.join()t2.join()print(主线程end)守护线程
在行为上还有一种叫守护线程主要的特征是它的生命周期。主线程死亡它也就随之死亡。在python中线程通过setDaemon(True|False)来设置是否为守护线程。
守护线程的作用
守护线程作用是为其他线程提供便利服务守护线程最典型的应用就是 GC (垃圾收集器)。
#encodingutf-8
from threading import Thread
from time import sleep
class MyThread(Thread):def __init__(self,name):Thread.__init__(self)self.name namedef run(self):for i in range(3):print(fthread:{self.name} :{i})sleep(1)
if __name__ __main__:print(主线程start)#创建线程(类的方式)t1 MyThread(t1)#t1设置为守护线程t1.setDaemon(True)#3.10后被废弃可以直接t1.daemonTrue#启动线程t1.start()print(主线程end)
线程_全局解释器锁GIL问题
全局锁GIL问题
在python中无论你有多少核在Cpython解释器中永远都是假象。无论你是4核8核还是16核.......不好意思同一时间执行的线程只有一个线程它就是这个样子的。这个是python的一个开发时候设计的一个缺陷所以说python中的线程是“含有水分的线程”。
Python GIL(Global Interpreter Lock)
Python代码的执行由Python 虚拟机(也叫解释器主循环CPython版本)来控制Python 在设计之初就考虑到要在解释器的主循环中同时只有一个线程在执行即在任意时刻只有一个线程在解释器中运行。对Python 虚拟机的访问由全局解释器锁GIL来控制正是这个锁能保证同一时刻只有一个线程在运行。 ⚠️GIL并不是Python的特性它是在实现Python解析器(CPython)时所引入的一个概念,同样一段代码可以通过CPythonPyPyPsyco等不同的Python执行环境来执行,就没有GIL的问题。然而因为CPython是大部分环境下默认的Python执行环境。所以在很多人的概念里CPython就是Python也就想当然的把GIL归结为Python语言的缺陷 线程_线程同步和互斥锁_资源
线程同步和互斥锁
线程同步的概念 处理多线程问题时多个线程访问同一个对象并且某些线程还想修改这个对象。 这时候我们就需要用到“线程同步”。 线程同步其实就是一种等待机制多个需要同时访问此对象的线程进入这个对象的等待池形成队列等待前面的线程使用完毕后下一个线程再使用。 【示例】多线程操作同一个对象(未使用线程同步)
#encodingutf-8
from threading import Thread
from time import sleep
class Account:def __init__(self,money,name):self.money moneyself.name name
#模拟提款操作
class Drawing(Thread):def __init__(self,drawingNum,account):Thread.__init__(self)self.drawingNum drawingNumself.account accountself.expenseTotal 0def run(self):if self.account.money-self.drawingNum0:returnsleep(1) #判断完后阻塞。其他线程开始运行。self.account.money - self.drawingNum;self.expenseTotal self.drawingNum;print(f账户{self.account.name},余额是{self.account.money})print(f账户{self.account.name},总共取了{self.expenseTotal})
if __name__ __main__:a1 Account(100,gaoqi)draw1 Drawing(80,a1) #定义取钱线程对象draw2 Drawing(80,a1) #定义取钱线程对象draw1.start() #你取钱draw2.start() #你老婆取钱没有线程同步机制两个线程同时操作同一个账户对象竟然从只有100元的账户轻松取出80*2160元账户余额竟然成为了-60。这么大的问题显然银行不会答应的。 我们可以通过“锁机制”来实现线程同步问题锁机制有如下几个要点
必须使用同一个锁对象互斥锁的作用就是保证同一时刻只能有一个线程去操作共享数据保证共享数据不会出现错误问题使用互斥锁的好处确保某段关键代码只能由一个线程从头到尾完整地去执行使用互斥锁会影响代码的执行效率同时持有多把锁容易出现死锁的情况
互斥锁是什么
互斥锁: 对共享数据进行锁定保证同一时刻只能有一个线程去操作。
注意: 互斥锁是多个线程一起去抢抢到锁的线程先执行没有抢到锁的线程需要等待等互斥锁使用完释放后其它等待的线程再去抢这个锁。
threading模块中定义了Lock变量这个变量本质上是一个函数通过调用这个函数可以获取一把互斥锁。
【示例】多线程操作同一个对象(增加互斥锁使用线程同步)
#encodingutf-8
from threading import Thread,Lock
from time import sleep
class Account:def __init__(self,money,name):self.money moneyself.name name
#模拟提款操作
class Drawing(Thread):def __init__(self,drawingNum,account):Thread.__init__(self)self.drawingNum drawingNumself.account accountself.expenseTotal 0def run(self):lock1.acquire() if self.account.money-self.drawingNum0:returnsleep(1) #判断完后阻塞。其他线程开始运行。self.account.money - self.drawingNum;self.expenseTotal self.drawingNum;lock1.release()print(f账户{self.account.name},余额是{self.account.money})print(f账户{self.account.name},总共取了{self.expenseTotal})
if __name__ __main__:a1 Account(100,gaoqi)lock1 Lock()draw1 Drawing(80,a1) #定义取钱线程对象draw2 Drawing(80,a1) #定义取钱线程对象draw1.start() #你取钱draw2.start() #你老婆取钱acquire和release方法之间的代码同一时刻只能有一个线程去操作如果在调用acquire方法的时候 其他线程已经使用了这个互斥锁那么此时acquire方法会堵塞直到这个互斥锁释放后才能再次上锁。 线程_死锁问题和解决方案
死锁
在多线程程序中死锁问题很大一部分是由于一个线程同时获取多个锁造成的。
from threading import Thread, Lock
from time import sleep
def fun1():lock1.acquire()print(fun1拿到菜刀)sleep(2)lock2.acquire()print(fun1拿到锅)
lock2.release()print(fun1释放锅)lock1.release()print(fun1释放菜刀)
def fun2():lock2.acquire()print(fun2拿到锅)lock1.acquire()print(fun2拿到菜刀)lock1.release()print(fun2释放菜刀)lock2.release()print(fun2释放锅)
if __name__ __main__:lock1 Lock()lock2 Lock()
t1 Thread(targetfun1)t2 Thread(targetfun2)t1.start()t2.start()死锁的解决方法
死锁是由于“同步块需要同时持有多个锁造成”的要解决这个问题思路很简单就是同一个代码块不要同时持有两个对象锁。
