进程与线程的标识
进程pid
import multiprocessing
import time
def func():
time.sleep(5)
process = multiprocessing.Process(target=func)
print(process.pid)
process.start()
print(process.pid)
None
1350
线程ident
import threading
import time
def func():
time.sleep(5)
process = threading.Thread(target=func)
print(process.ident)
process.start()
print(process.ident)
None
-1223427264
进程名
import multiprocessing
import time
def func():
time.sleep(5)
process = multiprocessing.Process(target=func,name='句号')
print(process)
process.start()
<Process(句号, initial)>
线程名
import threading
import time
def func():
time.sleep(5)
process = threading.Thread(target=func)
print(process)
print(threading.Thread(target=func))
print(threading.Thread(target=func))
print(process.name)
process.start()
<Thread(Thread-1, initial)>
<Thread(Thread-2, initial)>
<Thread(Thread-3, initial)>
Thread-1
import threading
import time
def func():
time.sleep(5)
process = threading.Thread(target=func,name='juhao')
print(process)
process.name='hh'
print(process)
process.start()
<Thread(juhao, initial)>
<Thread(hh, initial)>
当前进程
import multiprocessing
import time
print(multiprocessing.current_process()) # 在主进程里获取当前进程
def func():
time.sleep(5)
print(multiprocessing.current_process()) # 在子进程里获取当前进程
process = multiprocessing.Process(target=func,name='句号')
process.start()
<_MainProcess(MainProcess, started)>
<Process(句号, started)>
当前线程
import threading
import time
print(threading.current_thread())
def func():
time.sleep(5)
print(threading.current_thread())
print(threading.current_thread().ident)
process = threading.Thread(target=func,name='句号')
process.start()
<_MainThread(MainThread, started -1219622528)>
<Thread(句号, started -1223296192)>
-1223296192
线程在主进程里开启的
import threading
import time
import multiprocessing
print(multiprocessing.current_process())
def func():
time.sleep(5)
print(multiprocessing.current_process())
print(threading.current_thread())
process = threading.Thread(target=func,name='句号')
process.start()
<_MainProcess(MainProcess, started)>
<_MainProcess(MainProcess, started)> #线程在主进程里开启的
<Thread(句号, started -1223132352)>
进程与线程的其余相关操作
中止进程 terminate
主进程开始 子进程start 主进程子进程同时继续运行 主进程2s结束 子进程需要5s继续运行 子进程结束
import time
import multiprocessing
def func():
print('start')
time.sleep(5)
print('end')
print('main start')
process =multiprocessing.Process(target=func)
process.start()
time.sleep(2)
print('main end')
main start
start
main end
end
中止 terminate子进程
import time
import multiprocessing
def func():
print('start')
time.sleep(5)
print('end')
print('main start')
process =multiprocessing.Process(target=func)
process.start()
time.sleep(2)
print('main end')
process.terminate()
main start
start
main end
注意!
线程并不能被中途中止只能等待其运行结束
主进程等待子进程结束 join
import time
import datetime
import multiprocessing
def func():
time.sleep(5)
print(datetime.datetime.now())
process = multiprocessing.Process(target=func)
process.start()
time.sleep(5)
print(datetime.datetime.now())
2018-07-05 13:36:18.188339
2018-07-05 13:36:23.209150
5s 主进程子进程同时运行
join
import time
import datetime
import multiprocessing
def func():
time.sleep(5)
print(datetime.datetime.now())
process = multiprocessing.Process(target=func)
process.start()
process.join() # 阻塞 等待子进程运行结束再继续运行
time.sleep(5)
print(datetime.datetime.now())
2018-07-05 13:37:14.611805
2018-07-05 13:37:24.644123
10s 主进程等待子进程运行结束再继续运行
主线程等待子线程结束 join
import time
import datetime
import threading
def func():
time.sleep(5)
print(datetime.datetime.now())
process = threading.Thread(target=func)
process.start()
process.join() # 阻塞 等待子线程运行结束再继续运行
time.sleep(5)
print(datetime.datetime.now())
2018-07-05 13:40:27.059646
2018-07-05 13:40:37.069619
进程与线程的生存与状态
is_alive() 是否正在运行
import time
import threading
def func():
time.sleep(5)
process = threading.Thread(target=func)
print(process,process.is_alive()) # initial 初始化的状态
process.start()
print(process,process.is_alive()) # started 运行的状态
process.join()
print(process,process.is_alive()) # stopped 停止的状态(子进程运行结束了)
<Thread(Thread-1, initial)> False
<Thread(Thread-1, started -1223718080)> True
<Thread(Thread-1, stopped -1223718080)> False
import time
import multiprocessing
def func():
time.sleep(5)
process = multiprocessing.Process(target=func)
print(process,process.is_alive())
process.start()
print(process,process.is_alive())
process.join()
print(process,process.is_alive())
<Process(Process-1, initial)> False
<Process(Process-1, started)> True
<Process(Process-1, stopped)> False
守护模式 daemon=True
守护进程
正常没开守护时,主进程结束后 子进程会继续运行
import time
import multiprocessing
def func():
print('start')
time.sleep(5)
print('end')
print('main start')
process = multiprocessing.Process(target=func)
process.start()
time.sleep(2)
print('main end')
main start
start
main end
end
守护进程,daemon=True
2s 后主进程结束 会把守护进程杀死
(2s 后主进程死了 守护进程也去死)
退出qq 聊天窗口也会自动关闭(守护线程)
import time
import multiprocessing
def func():
print('start')
time.sleep(5)
print('end')
print('main start')
process = multiprocessing.Process(target=func,daemon=True) # 设置守护模式
process.start()
time.sleep(2)
print('main end')
main start
start
main end
守护线程
退出qq 聊天窗口也会自动关闭(守护线程)
import time
import threading
def func():
print('start')
time.sleep(5)
print('end')
print('main start')
process = threading.Thread(target=func,daemon=True)
process.start()
time.sleep(2)
print('main end')
main start
start
main end
僵尸进程
一个进程使用fork创建子进程,如果子进程退出,而父进程并没有调用wait或waitpid获取子进程的状态信息,那么子进程的进程描述符仍然保存在系统中。这种进程称之为僵死进程。
不能再活动(start)了
僵尸不能再复活了
import time
import threading
def func():
print('start')
time.sleep(5)
print('end')
print('main start')
process = threading.Thread(target=func)
process.start()
time.sleep(10)
print('main end')
main start
start
end
main end
不能再活动(start)了
import time
import threading
def func():
print('start')
time.sleep(5)
print('end')
print('main start')
process = threading.Thread(target=func)
process.start()
process.start()
time.sleep(10)
print('main end')
main start
Traceback (most recent call last):
File "/home/pyvip/py_case/jinjie/six_4.py", line 15, in <module>
process.start()
File "/usr/lib/python3.5/threading.py", line 840, in start
start
raise RuntimeError("threads can only be started once")
RuntimeError: threads can only be started once
孤儿进程
一个父进程退出,而它的一个或多个子进程还在运行,那么那些子进程将成为孤儿进程。孤儿进程将被init进程(进程号为1)所收养,并由init进程对它们完成状态收集工作。
没爹了
import time
import threading
def func():
print('start')
time.sleep(5)
print('end')
print('main start')
process = threading.Thread(target=func)
process.start()
time.sleep(2)
print('main end')
main start
start
main end
end
开守护 回收僵尸进程 杀死守护进程并回收
import time
import threading
def func():
print('start')
time.sleep(5)
print('end')
print('main start')
process = threading.Thread(target=func,daemon=True)
process.start()
time.sleep(2)
print('main end')
main start
start
main end
主进程开始 子进程start 主进程执行2s 退出时回收僵尸进程(这里没有)、杀死守护进程 process,
process1 执行完了(打印end) 变成僵尸进程 主进程最后会回收僵尸进程 主进程退出了。。
import time
import threading
def func():
print('start')
time.sleep(5)
print('end')
print('main start')
process = threading.Thread(target=func)
process1 = threading.Thread(target=func,daemon=True)
process.start()
process1.start()
time.sleep(2)
print('main end')
main start
start
start
main end
end
import multiprocessing
import time
print('main start')
def func():
print('start')
time.sleep(5)
a = multiprocessing.Process() # 子进程里可以再开进程
a.join()
print('end')
# 守护进程 里不可以再开
process = multiprocessing.Process(target=func,daemon=True)
process1 = multiprocessing.Process(target=func)
process.start()
process1.start()
time.sleep(5)
print('main end')
main start
start
start
main end
end
以面向对象的形式使用进程与线程
面向对象化使用进程
关键点一: 继承 Process类
关键点二: 重写 _init_方法
关键点三: 重写 run方法
import time
import multiprocessing
class MyProcess(multiprocessing.Process):
def __init__(self):
super().__init__() # 创建一个进程
def run(self):
print('start')
time.sleep(5)
print('end')
process = MyProcess()
process.start()
start
end
import time
import multiprocessing
class MyProcess(multiprocessing.Process):
def __init__(self):
super().__init__(name='juhao') # 创建一个进程
def run(self):
print('start')
time.sleep(5)
print('end')
print(multiprocessing.current_process())
process =MyProcess()
process.start()
start
end
<my_process(juhao, started)>
设置守护进程 (主进程死了 杀死守护进程)
import time
import multiprocessing
print('main start')
class MyProcess(multiprocessing.Process):
def __init__(self,name):
super().__init__(name=name,daemon=True) # 创建一个进程
def run(self):
print('start')
time.sleep(2)
print('end')
print(multiprocessing.current_process())
process =MyProcess('句号')
process.start()
time.sleep(1)
print('main end')
main start
start
main end
面向对象化使用线程
import time
import threading
print('main start')
class MyProcess(threading.Thread):
def __init__(self,name):
super().__init__(name=name) # 创建一个进程
def run(self):
print('start')
time.sleep(2)
print('end')
print(threading.current_thread())
process = MyProcess('句号')
process.start()
time.sleep(1)
print('main end')
main start
start
main end
end
<my_process(句号, started -1223500992)>
作业
用面向对象的方式来实现多线程并发服务器
服务端
import threading
import socket
server = socket.socket()
server.bind(('0.0.0.0',8886))
server.listen(5)
class MyThread(threading.Thread):
def __init__(self,conn,addr):
super().__init__()
self.conn=conn # 将conn绑定到实例对象上 不会被下一次连接的conn覆盖
self.addr=addr
def run(self):
while True:
data = self.conn.recv(1024)
if data:
print('收到: ',data.decode())
self.conn.send(data)
else:
print('用户断开连接',self.addr)
self.conn.close()
break
while True:
conn,addr = server.accept()
print('用户连接', addr)
my_thread = MyThread(conn,addr)
my_thread.start()
客户端
import socket
client = socket.socket()
client.connect(('127.0.0.1',8886))
while True:
data = input('请输入: ')
if data:
client.send(data.encode())
print(client.recv(1024).decode())
else:
break
client.close()