前情回顾：
1.进程间通信
管道 Pipe recv send
消息队列 Queue get put qsize full empty
共享内存 效率高 Value shm.value Array shm迭代
信号 ： 异步通信 kill alarm pause
信号量 套接字
2. 进程池 Pool apply_async apply close join
map
3. 创建进程类 重写run
***********************************************
信号处理 ：
signal.signal(signum,handler)
功能 ： 处理一个信号
参数 ： signum ： 要处理的信号
handler ： 对该信号的处理方法
SIG_DFL 采用默认方法
SIG_IGN 忽略这个信号
func 自定义的方法处理
func 格式要求
def func(sig,frame):
....
sig : 接收到的信号
frame ： 信号对象
* signal函数是一个异步处理信号函数，只要执行，在进程中就会按照指定方法处理信号
* signal 不能处理 SIGSTOP SIGKILL信号
信号量 ： 给定一定的信号数量，对多个进程可见，并且多个进程均可操作。进程根据信号量的多少，可以有不同的行为
multiprocess ----》 Semaphore()
sem = Semaphore(num)
功能 ： 定义信号量
参数 ： num ： 给定信号量的初始个数
返回值 ： 返回信号量对象
sem.acquire() 将信号量 减一 信号量为0时调用会阻塞
sem.release() 将信号量 加一
cookie ：
获取当前进程对象
multiprocssing.current_process()
使用处理僵尸进程
在父进程中，忽略子进程的发送信号
signal（SIGCHLD,SIG_IGN）
同步和互斥
目的 ： 对共有资源的操作会产生争夺，同步互斥是一种解决争夺的方案
临界资源 ： 多个进程或者线程都可以操作的资源
临界区 ： 操作临界资源的代码段
同步 ： 同步是一种合作关系，为完成某个任务多进程或者多线程之间形成一种协调 ，按照条件次序执行，传递告知资源情况。 这种协调可能是因为阻塞关系达成的
互斥 ：互斥是一种制约关系，但一个进程或线程进入到临界区会进行加锁操作，此时其他进程（线程）在企图操作临界资源就会阻塞。只有当资源被释放才能进行操作
Event 事件
创建 事件对象
e = Event（）
提供事件阻塞
e.wait()
对事件对象进程设置，此时wait判断如果事件被set则结束阻塞
e.set()
清除对该事件对象的set
e.clear()
监测对象是否被设置 设置返回True
e.is_set()
锁 Lock
multiprocessing ----》 Lock
lock = Lock()
lock.acquire() 上锁
lock.release() 解锁
with lock： ---》 给with代码段上锁
....
....
-----------------> with 代码段结束自动解锁
* 在lock对象处于上锁状态的时候，再企图上锁则会阻塞
直到锁被释放，才能继续执行上锁操作
线程
* 线程也是所任务编程的一种方法，可以使用计算机多核资源。是计算机核心分配的最小单位
* 线程又称为轻量级的进程，在创建和删除时消耗的计算机资源小
线程和进程关系
* 一个进程中可以包含多个线程
* 进程中的所有线程共享进程的空间资源 （空间，全局变量，分配的内存等）
* 线程也有自己的特有属性，比如 指令集 TID等
创建线程
import threading
threading.Tread
Thread()
功能 ： 创建线程
参数 ： target 线程函数
args 元组 给线程函数位置传参
kwargs 字典 给线程函数字典传参
name 给线程取名字 （默认Thread-1）
返回 ： 线程对象
t.start() 启动线程
t.join(timeout) 回收线程
t.is_alive() 查看线程状态
t.name 查看线程名称
threading.currentThread() 得到线程对象
t.setName() 设置线程名称
t.daemon 属性
默认 为False 主线程执行完毕不会影响分支线程的执行
如果设置为True 则主线执行完毕其他线程也会终止
t.isDaemon() : 判断 daemon属性是True or False
设置方法：
t.daemon = True
t.setDaemon(True)
线程的通信
通过全局变量进行通信
进程和线程的区别和联系
1. 两者都是多任务编程方式，均可使用计算机的多核
2. 进程的创建要比线程消耗更多的资源
3. 进程空间独立，数据安全性更好操作，有专门的进程间通信方式
4. 线程使用全局变量通信，往往要和同步互斥机制配合防止产生资源的争夺
5.一个进程可以包含多个线程，线程共享进程资源。
6. 进程线程都有自己的特有资源。
使用场景 ：
需要创建较多的并发，任务比较简单，线程比较合适。
如果程序见数据资源使用重叠比较多，要考虑到线程锁是否需要更复杂的逻辑
如果多个任务并无什么关联性，不易用多线程将其融入到一个进程中
python线程不适用于计算密集型并发
创建自定义线程类 ：
1.继承Thread类
2.重写 run 方法
线程中同步互斥方法
Event 线程事件
e = Event()
e.wait() e.set() e.clear()
Lock 线程锁
lock = Lock() 创建锁
lock.acquire() 加锁
lock.release() 解锁
作业 :
信号通信
司机和售票员的故事
1. 创建父子进程，分别表示司机和售票员
2. 当售票员捕捉到 SIGINT信号时 给司机发送 SIGUSER1信号， 此时司机打印 “老司机开车了”
当售票员捕捉到 SIGQUIT时 给司机发送 SIGUSER2信号，此时司机打印“系好安全带，车速有点快”
当司机捕捉到 SIGTSTP时，发送SIGUSER1给售票员，售票员打印 “到站了，请下车”
3. 到站后 售票员先下车（子进程退出）,然后司机下车
温馨提示 ： 键盘发送信号会给终端所有进程
TFTP文件服务器
文件的上传，下载，和服务端文件库的查看
服务端 客户端
1.查看文件库中有哪些文件
2.下载文件到本地
3.将本地的文件上传到文件库
***************************************************************
from multiprocessing import Event
#创建事件对象
e = Event()
print(e.is_set())
e.set()
e.wait()
print(e.is_set())
#将设置清除 wait又阻塞
e.clear()
e.wait()
****************************************************************
from threading import Thread
from time import ctime,sleep
#编写自己的线程类
class MyThread(Thread):
def __init__(self,func,args,name = "Tedu"):
super().__init__()
self.func = func
self.args = args
self.name = name
# 调用start会自动运行
def run(self):
self.func(*self.args)
def player(file,sec):
for i in range(2):
print("playing %s : %s"%(file,ctime()))
sleep(sec)
t = MyThread(player,('baby.mp3',3))
t.start()
t.join()
******************************************************************
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()
**************************************************************
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()
**************************************************************
from multiprocessing import \
Semaphore,Process,current_process
from time import sleep
#创建信号量初始值为3
sem = Semaphore(3)
def fun():
print("进程 %s 等待信号量"%current_process())
#第四个进程无信号资源会阻塞
sem.acquire()
print("进程 %s 消耗信号量"%current_process())
sleep(3)
print("进程 %s 添加信号量"%current_process())
sem.release()
jobs = []
for i in range(4):
p = Process(target = fun)
p.start()
jobs.append(p)
for i in jobs:
i.join()
**************************************************************
import signal
from time import sleep
signal.alarm(5)
#采用默认的方法处理SIGALRM信号
# signal.signal(signal.SIGALRM,signal.SIG_DFL)
#忽略信号
signal.signal(signal.SIGALRM,signal.SIG_IGN)
signal.signal(signal.SIGINT,signal.SIG_IGN)
while True:
sleep(2)
print("让你摁ctrl + c")
print("等待时钟....")
**************************************************************
from signal import *
import time
#固定格式要求
def handler(sig,frame):
if sig == SIGALRM:
print("收到时钟信号")
elif sig == SIGINT:
print("就不结束")
alarm(7)
#通过自定义方法处理
signal(SIGALRM,handler)
signal(SIGINT,handler)
while True:
print("waiting for a signal")
time.sleep(2)
**************************************************************
import threading
from time import sleep
#线程函数
def music():
while True:
sleep(2)
print("播放葫芦娃")
#创建线程和函数music关联
t = threading.Thread(target = music)
#启动线程
t.start()
while True:
sleep(1.5)
print("想听灌篮高手")
#等待回收线程
t.join()
print("+++++++++++++++++++")
**************************************************************
#线程对象属性
from threading import Thread,currentThread
from time import sleep
def fun(sec):
print("线程属性测试")
sleep(sec)
print(" %s 线程结束"%currentThread().getName())
thread = []
for i in range(3):
t = Thread(name = "tedu" + str(i),\
target = fun,args = (3,))
t.start()
thread.append(t)
for i in thread:
i.join()
print("thread name:",i.name)
print("alive:",i.is_alive())
**************************************************************
#daemon属性
from threading import Thread
from time import sleep
def fun():
print("Daemon 属性测试")
sleep(5)
print("线程结束")
t = Thread(target = fun)
#为线程设置名字
t.setName("tedu")
#daemon属性设置为True
#t.daemon = True
t.setDaemon(True)
print(t.isDaemon())
t.start()
t.join(2)
print("=====主线程结束======")
**************************************************************
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("foo收到:",s)
else:
print("打死他")
e.set()
def fun():
print("呵呵...")
sleep(1)
e.wait()
global s
s = "小鸡炖蘑菇"
t1 = threading.Thread(name = 'bar',target = bar)
t2 = threading.Thread(name = 'foo',target = foo)
t3 = threading.Thread(name = 'fun',target = fun)
t1.start()
t2.start()
t3.start()
t1.join()
t2.join()
t3.join()
**************************************************************
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()
**************************************************************
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()
网络编程(七)
猜你喜欢
转载自www.cnblogs.com/wcin/p/9119117.html
今日推荐
周排行