wordpress后台 登录,公司网站优化去哪里学,哈尔滨seo,如何搭建公司网站进程和线程
今天我们使用的计算机早已进入多CPU或多核时代#xff0c;而我们使用的操作系统都是支持“多任务”的操作系统#xff0c;这使得我们可以同时运行多个程序#xff0c;也可以将一个程序分解为若干个相对独立的子任务#xff0c;让多个子任务并发的执行#xff…进程和线程
今天我们使用的计算机早已进入多CPU或多核时代而我们使用的操作系统都是支持“多任务”的操作系统这使得我们可以同时运行多个程序也可以将一个程序分解为若干个相对独立的子任务让多个子任务并发的执行从而缩短程序的执行时间同时也让用户获得更好的体验。因此在当下不管是用什么编程语言进行开发实现让程序同时执行多个任务也就是常说的“并发编程”应该是程序员必备技能之一。为此我们需要先讨论两个概念一个叫进程一个叫线程。
概念
进程就是操作系统中执行的一个程序操作系统以进程为单位分配存储空间每个进程都有自己的地址空间、数据栈以及其他用于跟踪进程执行的辅助数据操作系统管理所有进程的执行为它们合理的分配资源。进程可以通过fork或spawn的方式来创建新的进程来执行其他的任务不过新的进程也有自己独立的内存空间因此必须通过进程间通信机制IPCInter-Process Communication来实现数据共享具体的方式包括管道、信号、套接字、共享内存区等。
一个进程还可以拥有多个并发的执行线索简单的说就是拥有多个可以获得CPU调度的执行单元这就是所谓的线程。由于线程在同一个进程下它们可以共享相同的上下文因此相对于进程而言线程间的信息共享和通信更加容易。当然在单核CPU系统中真正的并发是不可能的因为在某个时刻能够获得CPU的只有唯一的一个线程多个线程共享了CPU的执行时间。使用多线程实现并发编程为程序带来的好处是不言而喻的最主要的体现在提升程序的性能和改善用户体验今天我们使用的软件几乎都用到了多线程技术这一点可以利用系统自带的进程监控工具如macOS中的“活动监视器”、Windows中的“任务管理器”来证实如下图所示。 当然多线程也并不是没有坏处站在其他进程的角度多线程的程序对其他程序并不友好因为它占用了更多的CPU执行时间导致其他程序无法获得足够的CPU执行时间另一方面站在开发者的角度编写和调试多线程的程序都对开发者有较高的要求对于初学者来说更加困难。
Python既支持多进程又支持多线程因此使用Python实现并发编程主要有3种方式多进程、多线程、多进程多线程。
Python中的多进程
Unix和Linux操作系统上提供了fork()系统调用来创建进程调用fork()函数的是父进程创建出的是子进程子进程是父进程的一个拷贝但是子进程拥有自己的PID。fork()函数非常特殊它会返回两次父进程中可以通过fork()函数的返回值得到子进程的PID而子进程中的返回值永远都是0。Python的os模块提供了fork()函数。由于Windows系统没有fork()调用因此要实现跨平台的多进程编程可以使用multiprocessing模块的Process类来创建子进程而且该模块还提供了更高级的封装例如批量启动进程的进程池Pool、用于进程间通信的队列Queue和管道Pipe等。
下面用一个下载文件的例子来说明使用多进程和不使用多进程到底有什么差别先看看下面的代码。
from random import randint
from time import time, sleepdef download_task(filename):print(开始下载%s... % filename)time_to_download randint(5, 10)sleep(time_to_download)print(%s下载完成! 耗费了%d秒 % (filename, time_to_download))def main():start time()download_task(Python从入门到住院.pdf)download_task(Peking Hot.avi)end time()print(总共耗费了%.2f秒. % (end - start))if __name__ __main__:main()下面是运行程序得到的一次运行结果。
开始下载Python从入门到住院.pdf...
Python从入门到住院.pdf下载完成! 耗费了6秒
开始下载Peking Hot.avi...
Peking Hot.avi下载完成! 耗费了7秒
总共耗费了13.01秒.从上面的例子可以看出如果程序中的代码只能按顺序一点点的往下执行那么即使执行两个毫不相关的下载任务也需要先等待一个文件下载完成后才能开始下一个下载任务很显然这并不合理也没有效率。接下来我们使用多进程的方式将两个下载任务放到不同的进程中代码如下所示。
from multiprocessing import Process
from os import getpid
from random import randint
from time import time, sleepdef download_task(filename):print(启动下载进程进程号[%d]. % getpid())print(开始下载%s... % filename)time_to_download randint(5, 10)sleep(time_to_download)print(%s下载完成! 耗费了%d秒 % (filename, time_to_download))def main():start time()p1 Process(targetdownload_task, args(Python从入门到住院.pdf, ))p1.start()p2 Process(targetdownload_task, args(Peking Hot.avi, ))p2.start()p1.join()p2.join()end time()print(总共耗费了%.2f秒. % (end - start))if __name__ __main__:main()在上面的代码中我们通过Process类创建了进程对象通过target参数我们传入一个函数来表示进程启动后要执行的代码后面的args是一个元组它代表了传递给函数的参数。Process对象的start方法用来启动进程而join方法表示等待进程执行结束。运行上面的代码可以明显发现两个下载任务“同时”启动了而且程序的执行时间将大大缩短不再是两个任务的时间总和。下面是程序的一次执行结果。
启动下载进程进程号[1530].
开始下载Python从入门到住院.pdf...
启动下载进程进程号[1531].
开始下载Peking Hot.avi...
Peking Hot.avi下载完成! 耗费了7秒
Python从入门到住院.pdf下载完成! 耗费了10秒
总共耗费了10.01秒.我们也可以使用subprocess模块中的类和函数来创建和启动子进程然后通过管道来和子进程通信这些内容我们不在此进行讲解有兴趣的读者可以自己了解这些知识。接下来我们将重点放在如何实现两个进程间的通信。我们启动两个进程一个输出Ping一个输出Pong两个进程输出的Ping和Pong加起来一共10个。听起来很简单吧但是如果这样写可是错的哦。
from multiprocessing import Process
from time import sleepcounter 0def sub_task(string):global counterwhile counter 10:print(string, end, flushTrue)counter 1sleep(0.01)def main():Process(targetsub_task, args(Ping, )).start()Process(targetsub_task, args(Pong, )).start()if __name__ __main__:main()看起来没毛病但是最后的结果是Ping和Pong各输出了10个Why当我们在程序中创建进程的时候子进程复制了父进程及其所有的数据结构每个子进程有自己独立的内存空间这也就意味着两个子进程中各有一个counter变量所以结果也就可想而知了。要解决这个问题比较简单的办法是使用multiprocessing模块中的Queue类它是可以被多个进程共享的队列底层是通过管道和信号量semaphore机制来实现的有兴趣的读者可以自己尝试一下。
Python中的多线程
在Python早期的版本中就引入了thread模块现在名为_thread来实现多线程编程然而该模块过于底层而且很多功能都没有提供因此目前的多线程开发我们推荐使用threading模块该模块对多线程编程提供了更好的面向对象的封装。我们把刚才下载文件的例子用多线程的方式来实现一遍。
from random import randint
from threading import Thread
from time import time, sleepdef download(filename):print(开始下载%s... % filename)time_to_download randint(5, 10)sleep(time_to_download)print(%s下载完成! 耗费了%d秒 % (filename, time_to_download))def main():start time()t1 Thread(targetdownload, args(Python从入门到住院.pdf,))t1.start()t2 Thread(targetdownload, args(Peking Hot.avi,))t2.start()t1.join()t2.join()end time()print(总共耗费了%.3f秒 % (end - start))if __name__ __main__:main()我们可以直接使用threading模块的Thread类来创建线程但是我们之前讲过一个非常重要的概念叫“继承”我们可以从已有的类创建新类因此也可以通过继承Thread类的方式来创建自定义的线程类然后再创建线程对象并启动线程。代码如下所示。
from random import randint
from threading import Thread
from time import time, sleepclass DownloadTask(Thread):def __init__(self, filename):super().__init__()self._filename filenamedef run(self):print(开始下载%s... % self._filename)time_to_download randint(5, 10)sleep(time_to_download)print(%s下载完成! 耗费了%d秒 % (self._filename, time_to_download))def main():start time()t1 DownloadTask(Python从入门到住院.pdf)t1.start()t2 DownloadTask(Peking Hot.avi)t2.start()t1.join()t2.join()end time()print(总共耗费了%.2f秒. % (end - start))if __name__ __main__:main()因为多个线程可以共享进程的内存空间因此要实现多个线程间的通信相对简单大家能想到的最直接的办法就是设置一个全局变量多个线程共享这个全局变量即可。但是当多个线程共享同一个变量我们通常称之为“资源”的时候很有可能产生不可控的结果从而导致程序失效甚至崩溃。如果一个资源被多个线程竞争使用那么我们通常称之为“临界资源”对“临界资源”的访问需要加上保护否则资源会处于“混乱”的状态。下面的例子演示了100个线程向同一个银行账户转账转入1元钱的场景在这个例子中银行账户就是一个临界资源在没有保护的情况下我们很有可能会得到错误的结果。
from time import sleep
from threading import Threadclass Account(object):def __init__(self):self._balance 0def deposit(self, money):# 计算存款后的余额new_balance self._balance money# 模拟受理存款业务需要0.01秒的时间sleep(0.01)# 修改账户余额self._balance new_balancepropertydef balance(self):return self._balanceclass AddMoneyThread(Thread):def __init__(self, account, money):super().__init__()self._account accountself._money moneydef run(self):self._account.deposit(self._money)def main():account Account()threads []# 创建100个存款的线程向同一个账户中存钱for _ in range(100):t AddMoneyThread(account, 1)threads.append(t)t.start()# 等所有存款的线程都执行完毕for t in threads:t.join()print(账户余额为: %d元 % account.balance)if __name__ __main__:main()运行上面的程序结果让人大跌眼镜100个线程分别向账户中转入1元钱结果居然远远小于100元。之所以出现这种情况是因为我们没有对银行账户这个“临界资源”加以保护多个线程同时向账户中存钱时会一起执行到new_balance self._balance money这行代码多个线程得到的账户余额都是初始状态下的0所以都是0上面做了1的操作因此得到了错误的结果。在这种情况下“锁”就可以派上用场了。我们可以通过“锁”来保护“临界资源”只有获得“锁”的线程才能访问“临界资源”而其他没有得到“锁”的线程只能被阻塞起来直到获得“锁”的线程释放了“锁”其他线程才有机会获得“锁”进而访问被保护的“临界资源”。下面的代码演示了如何使用“锁”来保护对银行账户的操作从而获得正确的结果。
from time import sleep
from threading import Thread, Lockclass Account(object):def __init__(self):self._balance 0self._lock Lock()def deposit(self, money):# 先获取锁才能执行后续的代码self._lock.acquire()try:new_balance self._balance moneysleep(0.01)self._balance new_balancefinally:# 在finally中执行释放锁的操作保证正常异常锁都能释放self._lock.release()propertydef balance(self):return self._balanceclass AddMoneyThread(Thread):def __init__(self, account, money):super().__init__()self._account accountself._money moneydef run(self):self._account.deposit(self._money)def main():account Account()threads []for _ in range(100):t AddMoneyThread(account, 1)threads.append(t)t.start()for t in threads:t.join()print(账户余额为: %d元 % account.balance)if __name__ __main__:main()比较遗憾的一件事情是Python的多线程并不能发挥CPU的多核特性这一点只要启动几个执行死循环的线程就可以得到证实了。之所以如此是因为Python的解释器有一个“全局解释器锁”GIL的东西任何线程执行前必须先获得GIL锁然后每执行100条字节码解释器就自动释放GIL锁让别的线程有机会执行这是一个历史遗留问题但是即便如此就如我们之前举的例子使用多线程在提升执行效率和改善用户体验方面仍然是有积极意义的。
多进程还是多线程
无论是多进程还是多线程只要数量一多效率肯定上不去为什么呢我们打个比方假设你不幸正在准备中考每天晚上需要做语文、数学、英语、物理、化学这5科的作业每项作业耗时1小时。如果你先花1小时做语文作业做完了再花1小时做数学作业这样依次全部做完一共花5小时这种方式称为单任务模型。如果你打算切换到多任务模型可以先做1分钟语文再切换到数学作业做1分钟再切换到英语以此类推只要切换速度足够快这种方式就和单核CPU执行多任务是一样的了以旁观者的角度来看你就正在同时写5科作业。
但是切换作业是有代价的比如从语文切到数学要先收拾桌子上的语文书本、钢笔这叫保存现场然后打开数学课本、找出圆规直尺这叫准备新环境才能开始做数学作业。操作系统在切换进程或者线程时也是一样的它需要先保存当前执行的现场环境CPU寄存器状态、内存页等然后把新任务的执行环境准备好恢复上次的寄存器状态切换内存页等才能开始执行。这个切换过程虽然很快但是也需要耗费时间。如果有几千个任务同时进行操作系统可能就主要忙着切换任务根本没有多少时间去执行任务了这种情况最常见的就是硬盘狂响点窗口无反应系统处于假死状态。所以多任务一旦多到一个限度反而会使得系统性能急剧下降最终导致所有任务都做不好。
是否采用多任务的第二个考虑是任务的类型可以把任务分为计算密集型和I/O密集型。计算密集型任务的特点是要进行大量的计算消耗CPU资源比如对视频进行编码解码或者格式转换等等这种任务全靠CPU的运算能力虽然也可以用多任务完成但是任务越多花在任务切换的时间就越多CPU执行任务的效率就越低。计算密集型任务由于主要消耗CPU资源这类任务用Python这样的脚本语言去执行效率通常很低最能胜任这类任务的是C语言我们之前提到过Python中有嵌入C/C代码的机制。
除了计算密集型任务其他的涉及到网络、存储介质I/O的任务都可以视为I/O密集型任务这类任务的特点是CPU消耗很少任务的大部分时间都在等待I/O操作完成因为I/O的速度远远低于CPU和内存的速度。对于I/O密集型任务如果启动多任务就可以减少I/O等待时间从而让CPU高效率的运转。有一大类的任务都属于I/O密集型任务这其中包括了我们很快会涉及到的网络应用和Web应用。 说明 上面的内容和例子来自于廖雪峰官方网站的《Python教程》因为对作者文中的某些观点持有不同的看法对原文的文字描述做了适当的调整。 单线程异步I/O
现代操作系统对I/O操作的改进中最为重要的就是支持异步I/O。如果充分利用操作系统提供的异步I/O支持就可以用单进程单线程模型来执行多任务这种全新的模型称为事件驱动模型。Nginx就是支持异步I/O的Web服务器它在单核CPU上采用单进程模型就可以高效地支持多任务。在多核CPU上可以运行多个进程数量与CPU核心数相同充分利用多核CPU。用Node.js开发的服务器端程序也使用了这种工作模式这也是当下并发编程的一种流行方案。
在Python语言中单线程异步I/O的编程模型称为协程有了协程的支持就可以基于事件驱动编写高效的多任务程序。协程最大的优势就是极高的执行效率因为子程序切换不是线程切换而是由程序自身控制因此没有线程切换的开销。协程的第二个优势就是不需要多线程的锁机制因为只有一个线程也不存在同时写变量冲突在协程中控制共享资源不用加锁只需要判断状态就好了所以执行效率比多线程高很多。如果想要充分利用CPU的多核特性最简单的方法是多进程协程既充分利用多核又充分发挥协程的高效率可获得极高的性能。关于这方面的内容在后续的课程中会进行讲解。
应用案例
例子1将耗时间的任务放到线程中以获得更好的用户体验。
如下所示的界面中有“下载”和“关于”两个按钮用休眠的方式模拟点击“下载”按钮会联网下载文件需要耗费10秒的时间如果不使用“多线程”我们会发现当点击“下载”按钮后整个程序的其他部分都被这个耗时间的任务阻塞而无法执行了这显然是非常糟糕的用户体验代码如下所示。
import time
import tkinter
import tkinter.messageboxdef download():# 模拟下载任务需要花费10秒钟时间time.sleep(10)tkinter.messagebox.showinfo(提示, 下载完成!)def show_about():tkinter.messagebox.showinfo(关于, 作者: 骆昊(v1.0))def main():top tkinter.Tk()top.title(单线程)top.geometry(200x150)top.wm_attributes(-topmost, True)panel tkinter.Frame(top)button1 tkinter.Button(panel, text下载, commanddownload)button1.pack(sideleft)button2 tkinter.Button(panel, text关于, commandshow_about)button2.pack(sideright)panel.pack(sidebottom)tkinter.mainloop()if __name__ __main__:main()如果使用多线程将耗时间的任务放到一个独立的线程中执行这样就不会因为执行耗时间的任务而阻塞了主线程修改后的代码如下所示。
import time
import tkinter
import tkinter.messagebox
from threading import Threaddef main():class DownloadTaskHandler(Thread):def run(self):time.sleep(10)tkinter.messagebox.showinfo(提示, 下载完成!)# 启用下载按钮button1.config(statetkinter.NORMAL)def download():# 禁用下载按钮button1.config(statetkinter.DISABLED)# 通过daemon参数将线程设置为守护线程(主程序退出就不再保留执行)# 在线程中处理耗时间的下载任务DownloadTaskHandler(daemonTrue).start()def show_about():tkinter.messagebox.showinfo(关于, 作者: 骆昊(v1.0))top tkinter.Tk()top.title(单线程)top.geometry(200x150)top.wm_attributes(-topmost, 1)panel tkinter.Frame(top)button1 tkinter.Button(panel, text下载, commanddownload)button1.pack(sideleft)button2 tkinter.Button(panel, text关于, commandshow_about)button2.pack(sideright)panel.pack(sidebottom)tkinter.mainloop()if __name__ __main__:main()例子2使用多进程对复杂任务进行“分而治之”。
我们来完成1~100000000求和的计算密集型任务这个问题本身非常简单有点循环的知识就能解决代码如下所示。
from time import timedef main():total 0number_list [x for x in range(1, 100000001)]start time()for number in number_list:total numberprint(total)end time()print(Execution time: %.3fs % (end - start))if __name__ __main__:main()在上面的代码中我故意先去创建了一个列表容器然后填入了100000000个数这一步其实是比较耗时间的所以为了公平起见当我们将这个任务分解到8个进程中去执行的时候我们暂时也不考虑列表切片操作花费的时间只是把做运算和合并运算结果的时间统计出来代码如下所示。
from multiprocessing import Process, Queue
from random import randint
from time import timedef task_handler(curr_list, result_queue):total 0for number in curr_list:total numberresult_queue.put(total)def main():processes []number_list [x for x in range(1, 100000001)]result_queue Queue()index 0# 启动8个进程将数据切片后进行运算for _ in range(8):p Process(targettask_handler,args(number_list[index:index 12500000], result_queue))index 12500000processes.append(p)p.start()# 开始记录所有进程执行完成花费的时间start time()for p in processes:p.join()# 合并执行结果total 0while not result_queue.empty():total result_queue.get()print(total)end time()print(Execution time: , (end - start), s, sep)if __name__ __main__:main()比较两段代码的执行结果在我目前使用的MacBook上上面的代码需要大概6秒左右的时间而下面的代码只需要不到1秒的时间再强调一次我们只是比较了运算的时间不考虑列表创建及切片操作花费的时间使用多进程后由于获得了更多的CPU执行时间以及更好的利用了CPU的多核特性明显的减少了程序的执行时间而且计算量越大效果越明显。当然如果愿意还可以将多个进程部署在不同的计算机上做成分布式进程具体的做法就是通过multiprocessing.managers模块中提供的管理器将Queue对象通过网络共享出来注册到网络上让其他计算机可以访问这部分内容也留到爬虫的专题再进行讲解。
