python 进程 线程_python-进程、线程

一、解释：

相信百分之百的同学都会用到操作系统，别说不用，不用的话特么你怎么看的我的博客，而我们的操作系统你可以一遍看着我写的博客，又一遍听着音乐，说到音乐给大家推荐一首叫做"Shape of You",而我就是边听着音乐边写博客，哈哈.....；那么这里我们就要想了，我们的计算机又是怎么来运算的呢？怎么同时开启这么多任务的呢？而且还有好多任务偷偷的在后台运行着呢，只是桌面上没有显示而已。

而现在多核心多线程的计算机已经很普及，是的，这样计算的并发可以更多更快，但是在计算机刚流行的时候，很多单核CPU又怎么执行多任务的呢？毕竟CPU执行代码都是按照顺序执行的；而答案就是计算机上的操作系统轮流让各个任务交替执行，任务A执行0.01秒，切换到任务B上执行0.01秒，再切换到任务3上，这样反复下去，表面上看每个任务都是交替执行的，但是，由于CPU的执行速度实在是太快了，我们感觉就像所有任务都在同时执行一样。

所以，我们在日常运行的环境中，并行执行多任务只能在多核心多线程的CPU上实现，但是我们有的时候任务数量远远多于CPU的核心数量，所以，操作系统也会自动把很多任务轮流调度到每个核心上执行。

对于操作系统来说，一个任务就是一个进程(Process)，比如打开一个浏览器就是启动一个浏览器进程，打开一个记事本就启动了一个记事本进程，打开两个记事本就启动了两个记事本进程，打开一个Word就启动了一个Word进程。

有些进程还不止同时干一件事，比如Word，它可以同时进行打字、拼写检查、打印等事情。在一个进程内部，要同时干多件事，就需要同时运行多个“子任务”，我们把进程内的这些“子任务”称为线程(Thread)。

由于每个进程至少要干一件事，所以，一个进程至少有一个线程。当然，像Word这种复杂的进程可以有多个线程，多个线程可以同时执行，多线程的执行方式和多进程是一样的，也是由操作系统在多个线程之间快速切换，让每个线程都短暂地交替运行，看起来就像同时执行一样。当然，真正地同时执行多线程需要多核CPU才可能实现。

总结：

应用程序--->进程--->线程

应用程序最少有一个进程，而一个进程最后有一个主线程，而一个程序可以启多个进程，一个进程可以启动多个线程，而它们都有自己的主进程和主线程，而进程和线程都是有CPU来运算，运算方式就是来回切换运算。

线程和进程Python与其它开发语言的不同，其它语言线程之间可以在多个CPU之间切换，而Python不支持多线程，只能多进程(前提是被CPU调用)，所以出现了以下应用场景

应用场景：

IO密集型：多线程

计算密集型：多进程

GIL，全局解释器锁，保证同一个进程中只有一个线程同时被调用

二、线程的使用

看代码

import threading #导入线程的模块

importtimedef task(a): #进程的函数

time.sleep(1) #等待一秒

print(a)for i in range(30): #同时启动30个线程

t= threading.Thread(target=task,args=[i,]) #创建了进程，target表示要创建的进程

t.start() #进程启动，表示开始工作

print("end") #启动主进程

setDaemon的用法

说明:setDaemon 设置主进程是否等待子线程结束了，再结束自己，默认选项为(False)

例子： (默认选项)

import threading #导入线程的模块

importtimedef task(a): #进程的函数

time.sleep(1) #等待一秒

print(a)for i in range(5):

t= threading.Thread(target=task,args=[i,]) #创建了进程，target表示要创建的进程

t.setDaemon(False) #主进程是否等待子线程，False 是等待 True是不等待

t.start() #进程启动

print("end") #启动主进程###输出如下：

C:\Python35\python.exe D:/linux/python/day-test/day9/test1.py

end

02

1

3

4

非默认选项(True)

import threading #导入线程的模块

import time

def task(a): #进程的函数

time.sleep(1) #等待一秒

print(a)

for i in range(5):

t = threading.Thread(target=task,args=[i,]) #创建了进程，target表示要创建的进程

t.setDaemon(True) #主进程是否等待子线程，False 是等待 True是不等待

t.start() #进程启动

print("end") #启动主进程

输出如下:

import threading #导入线程的模块

importtimedef task(a): #进程的函数

time.sleep(1) #等待一秒

print(a)for i in range(5):

t= threading.Thread(target=task,args=[i,]) #创建了进程，target表示要创建的进程

t.setDaemon(True) #主进程是否等待子线程，False 是等待 True是不等待

t.start() #进程启动

print("end") #启动主进程

##下面没有等子线程就结束

C:\Python35\python.exe D:/linux/python/day-test/day9/test1.py

end

Process finished with exit code 0

join用法

import threading #导入线程的模块

importtimedef task(a): #进程的函数

time.sleep(3) #等待一秒

print(a)for i in range(5):

t= threading.Thread(target=task,args=[i,]) #创建了进程，target表示要创建的进程

t.setDaemon(False) #主进程是否等待子线程，False 是等待 True是不等待

t.start() #进程启动

t.join() #等待的最大时间，等待的是子线程的运行时间，默认为一直等

print("end") #启动主进程#输出：

C:\Python35\python.exe D:/linux/python/day-test/day9/test1.py

01

2

3

4end

线程的锁

单个锁

importthreadingimporttime

v= 10

#1、只能一个人使用锁#lock = threading.Lock() #此锁只能锁一次

lock = threading.RLock() #此锁可以锁多层

deftask(arg):

time.sleep(2)#申请使用锁，其他人等待

lock.acquire()

lock.acquire()

lock.acquire()globalv

v-= 1

print(v)#释放

lock.release()

lock.release()

lock.release()for i in range(10):

t= threading.Thread(target=task,args=(i,))

t.start()

多个人的锁

importthreadingimporttime

v= 10

#1、多个人使用锁

lock= threading.BoundedSemaphore(3) #此锁可以被多人使用3代表3个人同时使用

deftask(arg):#time.sleep(2)

#申请使用锁，其他人等待

lock.acquire()

time.sleep(1)globalv

v-= 1

print(v)#释放

lock.release()for i in range(10):

t= threading.Thread(target=task,args=(i,))

t.start()

事件锁

importrequestsimportthreadingimporttime

lock= threading.Event() #进程锁的方式

deftask(arg):

time.sleep(1)

lock.wait()#进程等候命令，开锁

print(arg)for i in range(5):

t= threading.Thread(target=task,args=(i,))

t.start()whileTrue:

value= input(">>>>>")if value == "1":

lock.set()#开锁

#输出：

C:\Python35\python.exe D:/linux/python/day-test/day9/事件锁.py>>>>>

>>>>>2

>>>>>1 #输入1之后开锁

>>>>>04

3

1

2

自定义锁，自己设置线程的锁的个数

importthreadingimporttime

lock=threading.Condition()deftask(arg):

time.sleep(1)#锁住所有线程

lock.acquire() #获得锁

lock.wait() #锁等候

#申请使用锁，其他人等待

print("线程",arg)

lock.release()#释放锁

for i in range(10):

t= threading.Thread(target=task,args=(i,))

t.start()whileTrue:

value= input(">>>>>>>>")

lock.acquire()#获得锁

lock.notify(int(value)) #设置释放的线程，你写几个上面线程释放几个

lock.release() #释放锁

输出：

>>>>>>>>6

>>>>>>>>线程 2线程4线程3线程1线程 0

线程8

连接池

from concurrent.futures import ThreadPoolExecutor #导入链接池模块

importtimeimportrequestsdeftask(url1):

response= requests.get(url) #获取请求

print("得到结果：",url,len(response.content)) #pool= ThreadPoolExecutor(2) #创建个链接池 括号里的2是链接池可以同时接两个连接

url_list =["http://www.oldboyedu.com","http://www.baidu.com","http://www.17ugo.com",

]for url inurl_list:print("开始请求",url)

pool.submit(task,url)#链接池使用submit方法获取；去链接池中获取链接