一、进程和线程
1、特征
a、进程特征
* 进程是操作系统资源分配的最小单位
* 每个进程单独占有4G虚拟内存
* 进程之间相互独立，运行互不影响
b、线程特征
* 线程是计算机核心分配的最小单位
* 一个进程可以包含多个线程
* 线程也是一个运行过程，也要消耗计算机资源。多个线程共享其进程的资源和空间
* 线程也拥有自己特有的资源属性，比如指令集，TID等
* 线程无论创建还是删除还是运行资源消耗都小于进程
* 多个线程之间并行执行，互不干扰
2、区别和联系
* 两者都是多任务编程的方式，都能够使用计算机多核资源
* 进程创建和删除要比线程消耗更多计算机资源
* 进程空间独立数据安全性好，有专门的通信方法
* 线程使用全局变量通信，更加简单，但是往往需要同步互斥操作
* 一个进程可以包含多个线程，线程共享进程资源
* 进程、线程都有自己的特有属性资源，如命令、id等
3、使用场景
线程使用场景:
如果需要创建较多的并发，任务比较简单，线程比较适合
如果数据操作和功能比较独立，此时使用进程比较合适
使用线程时需要考虑到同步互斥复杂程度
python线程要考虑到GIL问题
池的使用场景:
线程池应用较少，用的最多的是进程池。
二、同步互斥机制
解决对共有资源操作产生的争夺
1、基础概念
临界资源 ：多个进程或者线程都能够操作的资源
临界区：操作临界资源的代码段
同步：是一种合作关系，为完成某个任务，多进程或者多线程之间形成一种协调。按照约定依次执行对临界资源的操作，相互告知相互促进。
互斥：互斥是一种制约关系，当一个进程占有临界资源就会进行加锁的操作，此时其他进程就无法操作该临界资源。知道使用的进程进行解锁操作后才能使用。
2、进程的同步互斥
a、进程的Event事件
from multiprocessing import Event
创建事件对象
e = Event()
事件阻塞
e.wait([timeout])
事件设置
e.set()
功能 ： 当e被set() 后 e.wait()不再阻塞
事件清除
e.clear()
功能 ： 当e被clear()后 e.wait()又会阻塞
事件判断 判断当前事件对象是否被设置
e.is_set()
b、进程的锁Lock
from multiprocessing import Lock
创建对象
lock = Lock()
lock.acquire() 上锁
lock.release() 解锁
上锁状态 ： 执行acquire（）操作会阻塞
解锁状态 ： 执行acquire（）不阻塞
with lock： ---> 上锁
...
...
----》 with代码段结束即解锁
* 在lock对象处于上锁状态的时候，再企图上锁则会阻塞，直到锁被释放，才能继续执行上锁操作
3、线程的同步互斥
线程的资源访问，除了可以通过同步互斥机制来确保数据的安全一致性，也可以通过全局变量进行限制。
a、线程的Event事件
import threading
e = threading.Event()
e.wait([timeout]) 如果e为设置状态则不阻塞，未设置则阻塞
e.set() 将e变为设置状态
e.clear() 将e设置去除
b、线程的锁Lock
import threading
lock = threading.Lock() 创建锁
lock.acquire() 上锁
lock.release() 解锁
操作原理 ： 重复上锁 acquire()会阻塞
c、线程的条件变量Condition
import threading
创建条件变量对象
con = threading.Condition()
con.acquire() : 对资源加锁，加锁后其他位置再加锁则阻塞
con.release() : 解锁
con.wait() : wait函数只能在 加锁的状态下使用。 wait函数会先解锁（release），然后让线程处于等待通知的阻塞状态
con.notify() : 发送通知，线程接收到通知后 结束wait阻塞，并且执行 acquire 加锁操作
4、示例
a、进程的Event
from multiprocessing import Event,Process
from time import sleep
'''
三个进程都要操作共享资源
要求必须主进程先操作
子进程中谁先操作都可以，但是有一个子进程不能长期阻塞
'''
def wait_event():
print("process1也想操作临界区,但是要阻塞等待主进程")
e.wait()
print("主进程操作完了,轮到我了",e.is_set())
def wait_event_timeout():
print("process2也想操作临界区,但是要阻塞等待主进程")
e.wait(2)
print("我等不了了,还是执行别的吧",e.is_set())
e = Event()
p1 = Process(name = 'block',target = wait_event)
p2 = Process(name = 'non-block',\
target = wait_event_timeout)
p1.start()
p2.start()
print("假设正在忙碌的操作临界资源")
sleep(3)
e.set()
print("主进程操作完了,开放临界区")
p1.join()
p2.join()
b、进程的Lock
from multiprocessing import Process,Lock
import sys
from time import sleep
#sys.stdout为共享资源，所有进程都可以操作
def worker1():
lock.acquire() #上锁
for i in range(5):
sleep(1)
sys.stdout.write("worker1 输出\n")
lock.release() #解锁
def worker2():
#with方式上锁
with lock:
for i in range(5):
sleep(1)
sys.stdout.write("worker2 输出\n")
#创建Lock对象
lock = Lock()
w1 = Process(target = worker1)
w2 = Process(target = worker2)
w1.start()
w2.start()
w1.join()
w2.join()c、线程的global
from threading import Thread
from time import sleep
#通过全局变量进行线程通信
a = 1
def foo():
global a
a = 1000
def bar():
sleep(1)
print("a =",a) # a = 1000
t1 = Thread(target = foo)
t2 = Thread(target = bar)
t1.start()
t2.start()
t1.join()
t2.join()
d、线程的Event
import threading
from time import sleep
s = None
#创建事件对象
e = threading.Event()
def bar():
print("呼叫foo")
global s
s = "天王盖地虎"
def foo():
print("等待口令")
sleep(2)
if s == "天王盖地虎":
print("自己人")
else:
print("打死他")
e.set()
def fun():
print("呵呵．．．．")
sleep(1)
e.wait()
global s
s = "小鸡炖蘑菇"
t1 = threading.Thread(target = bar)
t2 = threading.Thread(target = foo)
t3 = threading.Thread(target = fun)
t1.start()
t2.start()
t3.start()
t1.join()
t2.join()
t3.join()d、线程的Lock
import threading
a = b = 0
lock = threading.Lock()
def value():
while True:
lock.acquire()
if a != b:
print("a = %d,b = %d"%(a,b))
lock.release()
t = threading.Thread(target = value)
t.start()
while True:
lock.acquire()
a += 1
b += 1
lock.release()
t.join()e、线程的Condition
import threading
import time
import datetime
num = 0
#条件变量
con = threading.Condition()
class Gov(threading.Thread):
def run(self):
global num
con.acquire()
while True:
print("开始拉升股市")
num += 1
print("拉升到 %d 个点"%num)
time.sleep(2)
if num == 5:
print('暂时安全!')
con.notify()
print("不操作状态")
con.wait()
con.release()
class Consumers(threading.Thread):
def run(self):
global num
con.acquire()
while True:
if num > 0:
print("开始打压股市")
num -= 1
print("下降到%d个点"%num)
time.sleep(2)
if num == 0:
print("天台在哪")
con.notify()
print("不能在下降了")
con.wait()
con.release()
t1 = Gov()
t2 = Consumers()
t1.start()
t2.start() 三、socket 服务器的集成模块
python2 SocketServer
python3 socketserver
功能：通过模块的接口完成基于多进程/多线程的tcp/udp的socket并发程序
| 意思 | 等同效果 | |
| StreamRequestHandler | 处理tcp请求 | |
| DatagramRequestHandler | 处理udp请求 | |
| ForkingMixIn | 建立多进程 | |
| ForkingTCPServer | 建立多进程tcp server | ForkingMixIn + TCPServer |
| ForkingUDPServer | 建立多进程udp server | ForkingMixIn + UDPServer |
| ThreadingMixIn | 建立多线程 | |
| ThreadingTCPServer | 建立多线程tcp server | ThreadingMixIn + TCPServer |
| ThreadingUDPServer | 建立多线程udp server | ThreadingMixIn + UDPServer |
| TCPServer | 建立tcp server | |
| UDPServer | 建立udp server |
1、多进程TCP并发
from socketserver import *
#多进程tcp并发
#创建指定类型的服务器
# class Server(ForkingMixIn,TCPServer):
class Server(ForkingTCPServer):
pass
#处理具体请求
class Handler(StreamRequestHandler):
def handle(self):
#self.request 相当于accept 返回的套接字
print("Connect from",\
self.request.getpeername())
while True:
data = self.request.recv(1024).decode()
if not data:
break
print(data)
self.request.send(b"Receive your message")
#生成服务器对象
server = Server(('0.0.0.0',9999),Handler)
#启动服务器
server.serve_forever()2、多进程UDP并发
from socketserver import *
#多进程udp并发
class Server(ForkingUDPServer):
pass
class Handler(DatagramRequestHandler):
def handle(self):
#接受消息
while True:
data = self.rfile.readline().decode()
if not data:
break
print(data)
self.wfile.write(b'Receive message')
server = Server(("0.0.0.0",8888),Handler)
server.serve_forever()
87
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
