标签：map mmu from nic 返回结果 进程与线程的区别 一段 lob 不可
内容概览：
进程
数据共享
进程池--回调函数
线程
线程的基础理论
什么是线程？
线程与进程的关系
GIL锁
线程的开启：
Threading模块
1，用多进程开启socket创建聊天
server端写了input函数会报错？因为服务器是高速运行的，自动化的为来访问的客户端提供服务，
不可能停下来等待管理员的输入，然后发送给客户。这就失去了自动化的意义。
2,进程池Pool()方法创建的进程,map()方法是否有返回值？
p.map()得到的是迭代对象
import time
from multiprocessing import Pool,Queue,Pipe
def func(q):
print(q)
time.sleep(1)
return q
if __name__ == ‘__main__‘:
p = Pool()
ret = p.map(func,range(10))
for i in ret:
print(‘-->‘,i)
0 1 2 3 4 5 6 7 8 9 --> 0 --> 1 --> 2 --> 3 --> 4 --> 5 --> 6 --> 7 --> 8 --> 9
import time,os
from multiprocessing import Pool,Queue,Pipe
def func(q):
print(q)
time.sleep(1)
print(os.getpid())#打印进程的pid
return q
if __name__ == ‘__main__‘:
p = Pool()
ret = p.map(func,range(10))
for i in ret:
print(‘-->‘,i)
#CPU是4核的，进程池默认最多开4个进程 0 1 2 3#这4个几多几乎同时得到 8156#进程PID1 4 7768#进程PID2 5 1780#进程PID3 6 7180#进程PID4 7 8156 8 7768 9 1780 7180 8156 7768 --> 0#进程的返回值 --> 1 --> 2 --> 3 --> 4 --> 5 --> 6 --> 7 --> 8 --> 9
内容回顾：
# p = Pool()默认是CPU的个数
#使用进程池提交任务
#p.apply()
同步提交，
函数直接可返回结果
ret = p.apply(函数名，参数)
#p.apply_async 异步提交
#不会直接返回函数的结果，返回的是一个对象,可以通过get()方法取值
#ret = p.apply_async(函数名，参数)
#ret_list.append(ret)
#for i in ret_list:
print(i.get())
#p.close()关闭进程池
#p.join()
#map方法
#得到的是返回值的可迭代对象
#通过for循环就可以取值
多进程与进程池的区别：
多进程：
由操作系统统一来调度
常见的进程越多，占用的资源就越多
操作系统的效率就会下降
进程池：
进程池中运行的进程数量是非常有限的
用户量比较大的时候就会导致，服务器的响应变慢
数据共享：
from multiprocessing import Manager,Process,Lock
def work(dic,lock):
dic[‘count‘] -= 1
if __name__ == ‘__main__‘:
lock = Lock()
m = Manager()
dic = m.dict({‘count‘:100})#Manager类中的dic()方法，传入参数将字典设置成共享数据
p_list = []
for i in range(20):
p = Process(target=work,args=(dic,lock))
p_list.append(p)
p.start()
for p in p_list:
p.join()
print(dic)
{‘count‘: 80}
说明：
开启20个进程，异步的哦，对共享的字典进行修改，本来，进程去取数据，修改之后再放回去，
但是由于进程额执行是需要一段时间的，有可能两个进程同时取到的都是99，然后修改再放进去，
这样就会出现偏差。
解决问题的办法就是加锁，只能允许一个进程进来取数据，
from multiprocessing import Manager,Process,Lock
def work(dic,lock):
lock.acquire()
dic[‘count‘] -= 1
lock.release()
if __name__ == ‘__main__‘:
lock = Lock()
m = Manager()
dic = m.dict({‘count‘:100})#Manager类中的dic()方法，传入参数将字典设置成共享数据
p_list = []
for i in range(20):
p = Process(target=work,args=(dic,lock))
p_list.append(p)
p.start()
for p in p_list:
p.join()
print(dic)
{‘count‘: 80}
有时间的话研究一下：
with 的用法
dis模块
面向对象的魔术方法：__enter__ __exit__
cpu的时间观念
回调函数：
回调函数的作用，以及应用场景：
子进程有大量的计算，或者访问网页，需要一定的时间才能完成，
回调函数等待子进程的结果，然后做简单的处理，得到结果
例如：例如子进程访问网页，主进程将网页写入文档
url_list = [
‘http://www.baidu.com‘,
‘http://www.sohu.com‘,
‘http://www.sogou.com‘,
‘http://www.cnblogs.com‘,
]
import re
from urllib.request import urlopen
from multiprocessing import Pool
def get_url(url):
respons = urlopen(url)
pattern = ‘www\.(.*?)\.com‘
ret = re.search(pattern,url)
print(‘%s finished‘%ret.group(1))
return ret.group(1),respons.read()
def write(content):
url,con = content
with open(url+‘.html‘,‘wb‘) as f:
f.write(con)
if __name__ == ‘__main__‘:
p = Pool()
for url in url_list:
p.apply_async(get_url,args=(url,),callback=write)
#采用异步提交的方法p.apply_async，不能忘记写上close、join
p.close()
p.join()
baidu finished sohu finished sogou finished cnblogs finished
正式进入线程
先回顾一下进程
程序是不能单独的自己运行，只有将程序加载到内存，有操作系统分配资源，在能运行，这种执行中额程序就叫做进程
进程与程序的区别：
程序是指令的集合，是程序运行的静态描述文本，
进程是程序的一次执行活动，
多道编程中，允许多个程序同时加载到内存中，在操作系统的调度下，，可以实现并发的执行，这样大大的提高了CPU的效率，
进程的出现，让用户感觉自己是独享CPU
线程的出现
60年代，操作系统中，能够拥有资源和独立运行的基本单位是进程，进程出现一些弊端：
进程是资源的拥有者，创建，撤销和切换会消耗大量的时间，多个进程并行开销过大
于是出现了能够独立运行的基本单位---线程thread
注意两点：
进程是资源分配的基本单位
线程是调度的最小单位
每个进程至少有一个线程
进程与线程的区别：
#资源共享：
进程之间是相互独立的，同一个进程的各个线程之间资源共享，
#通讯：
线程间是可以直接读取所在的进程中的数据段（比如：全局变量）来进行通讯，
进程之间的通讯：队列，管道。。
#切换速度：
线程的上下文切换，比进程快得多
线程的特点：
通常情况下，一个进程包含多个线程，么个线程作为利用CPU的基本单位，是花费自小开销的实体，
1）轻型实体
线程中的实体基本不拥有系统资源，只拥有：
程序，数据，TCB包，线程是动态概念，动态特性有线程控制模块TCB（thread control block）描述：
TCB包含以下信息：
线程状态
线程不运行时，线程数据
一组执行堆栈
线程的局部变量
访问同一个进程的主存 和 其他资源
2）独立调度和分派的基本单位
在多线程操作系统中，线程是能够独立运行的基本单位，因而也是能够独立调度和分派的基本单位，
由于线程的很轻，因此线程的切换非常迅速，开销很小
3）共享进程的资源
在同一进程中的各个线程，可以共享该进程所拥有的资源，具有相同的pid，因此可以访问进程的每一个内存资源，
此外还可以访问进程所拥有的已打开文件，定时器，信号量机构等。
4）可并发性
在一个进程的多个线程之间，可以并发执行，
全局解释器锁GIL
虽然python解释器中可以运行多个线程，但是在任意时刻只有一个线程在解释器在解释器中运行，
对python虚拟机的访问，由全局解释器锁GIL控制，正是这个锁保证同一时刻只能一个线程在运行，
线程之间的切换，python虚拟机按一下方式执行：
设置GIL
切换到一个线程去运行
运行指定数量的字节码指令，或者线程主动让出控制
把线程设置成睡眠状态
解锁GIL
重复以上的步骤
Thread模块：
子线程的开启
import time,os
from threading import Thread
def func(i):
time.sleep(0.5)
print(‘子线程：‘,i,os.getpid())
for i in range(10):
print(‘进程：‘,i ,os.getpid())
t = Thread(target=func,args=(i,))
t.start()
进程： 0 8740 进程： 1 8740 进程： 2 8740 进程： 3 8740 进程： 4 8740 进程： 5 8740 进程： 6 8740 进程： 7 8740 进程： 8 8740 进程： 9 8740 子线程： 0 8740 子线程： 1 8740 子线程： 2 8740 子线程： 3 8740 子线程： 4 8740 子线程： 5 8740 子线程： 6 8740 子线程： 9 8740 子线程： 8 8740 子线程： 7 8740
进程与线程，线程与线程之间数据共享
变量可以相互的调用
from threading import Thread
num = 100
def func():
global num
num -= 1
print(‘线程‘,num)
t_list = []
for i in range(100):
t = Thread(target=func)
t.start()
t_list.append(t)
for i in t_list:
t.join()
print(‘进程‘,num)
线程的几个方法：
t.setName()
t.getName()
t.is_alive()
currentThread()
currentThread().ident
from threading import Thread
import time
def func():
time.sleep(3)
t = Thread(target=func)
t.start()
print(t.is_alive())
print(t.getName())
t.setName(‘alex‘)
print(t.getName())
True Thread-1 alex
from threading import Thread,currentThread
import time
def func():
print(‘子线程：‘,currentThread().ident)
time.sleep(3)
print(‘主线程‘,currentThread().ident)
t = Thread(target=func)
t.start()
主线程 6752 子线程： 9324
#from threading import Thread,currentThread,enumerate,activeCount
查看当前的进程，
查看进程数，
import time
from threading import Thread,currentThread,enumerate,activeCount
def func():
print(‘子线程：‘,currentThread().ident)
time.sleep(3)
print(‘主线程‘,currentThread().ident)
for i in range(10):
t = Thread(target=func)
t.start()
print(len(enumerate()))
print(activeCount())
守护线程：
t1.setDaemon(True)
import time
from threading import Thread
def func1():
while True:
time.sleep(0.5)
print(‘子线程1‘)
def func2():
print(‘func2 start‘)
time.sleep(2)
print(‘func2 end‘)
t1 = Thread(target=func1)
t2 = Thread(target=func2)
t1.setDaemon(True)#设置成守护线程
t1.start()
t2.start()
print(‘主线程结束‘)
func2 start
主线程结束
子线程1
子线程1
子线程1
func2 end
守护线程：
主代码结束之后，会等待子线程执行结束之后 才会结束
使用threading模块 写一个TCP通讯
sever端：
import socket
from threading import Thread
def communicate(conn):
while True:
conn.send(b‘hello‘)
print(conn.recv(1024))
if __name__ == ‘__main__‘:
sk = socket.socket()
sk.bind((‘127.0.0.1‘,8989))
sk.listen()
while True:
conn,addr = sk.accept()
t = Thread(target=communicate,args=(conn,))#采用线程开启
t.start()
client端：
import socket
sk = socket.socket()
sk.connect((‘127.0.0.1‘,8989))
while True:
print(sk.recv(1024))
sk.send(b‘bye‘)
第36篇 多进程的数据共享，进程池的回调函数，线程 什么是GIL锁，Threading模块记
标签：map mmu from nic 返回结果 进程与线程的区别 一段 lob 不可
原文地址：https://www.cnblogs.com/cavalier-chen/p/9691658.html
