进程与线程补充

喜欢ヅ旅行 2022-05-16 01:13 153阅读 0赞

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