0401-进程与线程的补充

进程与线程的标识

进程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()