进程与线程补充

1.进程与线程的标识

进程pid

顾名思义，pid是进程的身份标志

import multiprocessing
import time

def func():
    time.sleep(2)

p = multiprocessing.Process(target=func)
print('pid before start:',p.pid) #start之前无pid
p.start()
print('pid after start:',p.pid) #start之后才分配pid

pid before start: None
pid after start: 1857

线程ident

同进程的pid

import time
import threading
def func():
    time.sleep(2)

t = threading.Thread(target=func)
print('ident before start:',t.ident) #start之前无ident
t.start()
print('ident after start:',t.ident) #start之后才分配ident

ident before start: None
ident after start: -1223161024

进程名与线程名

进程与线程都存在name属性

import multiprocessing
import time
import threading

p = multiprocessing.Process(name='sakura')
print(p)
print(p.name)
print('-'*20)

p.name='小樱花' #可通过name属性来设置进程名
print(p)

<Process(sakura, initial)> #未start前状态为initial
sakura
--------------------
<Process(小樱花, initial)>

当前线程与当前进程

multiprocessing.current_process() 显示当前进程对象

import multiprocessing
import time

def func():
    print('-'*10)
    print(multiprocessing.current_process()) #在子进程中显示当前进程
    time.sleep(3)

print(multiprocessing.current_process()) #主进程中显示当前进程
print('-'*10)
p = multiprocessing.Process(target=func,name='sakura')
print(p)
p.start()

<_MainProcess(MainProcess, started)>
----------
<Process(sakura, initial)>
----------
<Process(sakura, started)>

 2.进程与线程其余操作

进程终止

terminate()

import multiprocessing

def func():
    print('subprocess start')
    time.sleep(3)  # 延时3s
    print('subprocess end')

p = multiprocessing.Process(target=func)
p.start()
time.sleep(2) 
p.terminate() #p进程启动2s后终止进程

subprocess start

注：线程不能被终止，只能等待其运行结束。

等待进程或线程结束

join() 阻塞

import multiprocessing
import time
import datetime

def func():
    time.sleep(2)  # 延时2s

print('main process start')
print(datetime.datetime.now())
p = multiprocessing.Process(target=func)
p.start()
p.join() #阻塞住主进程的运行，等待子进程运行完再继续

time.sleep(2)
print(datetime.datetime.now())
print('main process end')

main process start
2018-08-13 23:08:19.247949
2018-08-13 23:08:23.289233
main process end

线程与进程使用方法相同。

进程与线程的生存状态

is_alive()

import multiprocessing

p = multiprocessing.Process(name='sakura')
print(p)
print(p.is_alive())

p.start()
print(p)
print(p.is_alive())

<Process(sakura, initial)> #未启动之前为initial
False
<Process(sakura, started)> #启动之后是started
True

线程与进程使用方法相同。

3.守护进程

守护进程含义：主进程结束时首先会回收僵尸进程（进程运行结束但仍占有资源未释放的进程），然后杀死所有子进程。

如关闭浏览器时，会关闭所有的标签页。

方法：参数列表中设置 daemon=True

           也可通过属性：进程名.daemon=True 

import multiprocessing
import time

def func():
    print('sub-process start')
    time.sleep(5)
    print('sub-process end:')

p = multiprocessing.Process(target=func,name='sakura',daemon=True) #设置守护进程
                              #或者p.daemon=True设置守护进程
p.start()
time.sleep(2)

sub-process start #主进程在2s结束时杀死守护进程，所以没有end

4.以面向对象的形式使用线程与进程

• 继承 Process或Thread 类
• 重写__init__方法
• 重写run方法

import multiprocessing

class Myprocess(multiprocessing.Process):
    def __init__(self,*args,**kwargs):
        super().__init__()
        self.args = args
        self.kwargs = kwargs
    def run(self):
        print(multiprocessing.current_process())
        print(self.args)
        print(self.kwargs)
print(multiprocessing.current_process())
print('-'*10)
p = Myprocess(1,2,3,a=1,b=2,c=3)
p.start()

<_MainProcess(MainProcess, started)>
----------
<Myprocess(Myprocess-1, started)>
(1, 2, 3)
{'a': 1, 'c': 3, 'b': 2}

用面向对象方式来实现多线程并发服务器

import threading
import socket
import  multiprocessing

server = socket.socket()
server.bind(('0.0.0.0', 8081))
server.listen(10)

class MyThread(multiprocessing.Process):
    def __init__(self, conn):
        super().__init__()
        self.conn = conn


    def run(self):
        while True:
            data = self.conn.recv(1024)
            if data:
                print('收到的消息', data.decode())
                self.conn.send(data)
            else:
                print('用户退出', addr)
                self.conn.close()
                break

while True:
    conn,  = server.accept()
    thraed = MyThread(conn)
    thraed.start()

import socket

client = socket.socket()

client.connect(('127.0.0.1',8800))

while True:
    data = input('please write the message:')
    client.send(data.encode())
    print(client.recv(1024).decode())
    if data == 'Q' or data == 'q':
        break

client.close()