python_进程与线程的补充

进程与线程的标识

知识点一：进程id 与 线程ident

import time
import multiprocessing
import threading
time.sleep(10)
print(multiprocessing.current_process().pid)  # 进程

def func():
    time.sleep(5)

p = threading.Thread(target=func)
p.start()
print(p.ident)  # 线程

xshell

ps aux | grep python3

 

知识点二：进程名 与 线程名

import time
import multiprocessing
import threading

def func():
    time.sleep(1)

p = threading.Thread(target=func, name='李木子')
p.start()
print(p)
print(p.name)

print('- - ' *20)
p.name = '李希'
print(p)

 

知识点三：获取当前线程/进程信息

提示！
可以在任何一个进程或者线程里搞清楚自己是谁

import time
import multiprocessing
print(multiprocessing.current_process())   # 获取主进程中的当前进程对象


def fun():
    print("- - "*10)
    print(multiprocessing.current_process()) # 获取子进程中的当前进程对象


p = multiprocessing.Process(target=fun, name='李希一号')
print(p)
p.start()

 

 

进程与线程的其余相关操作

知识点一：等待结束

等待进程或线程结束

提示！进程和线程是一样的同学们课后自己尝试

import time
import multiprocessing

print("外层start", time.asctime())

def func():
    print("里层start", time.asctime())
    time.sleep(5)
    print("里层end", time.asctime())
p = multiprocessing.Process(target=func)
p.start()
time.sleep(5)
print("外层end", time.asctime())

可以看到，并行结果，主子同时进行

 

加上join，等待子进程结束，再执行主进程

import time
import multiprocessing

print("外层start", time.asctime())

def func():
    print("里层start", time.asctime())
    time.sleep(5)
    print("里层end", time.asctime())
p = multiprocessing.Process(target=func)
p.start()

p.join()  # 主进程 等待子进程结束

time.sleep(5)
print("外层end", time.asctime())

 

中止进程

注意！线程并不能被中途中止只能等待其运行结束

import time
import multiprocessing
print(multiprocessing.current_process())


def fun():
    print("里层start", time.asctime())
    time.sleep(5)
    print("里层end", time.asctime())

p = multiprocessing.Process(target=fun, name='李希一号')
p.start()
time.sleep(2)
p.terminate()  # 不管你执行多久，同时结束主进行和子进程

 

进程与线程的生存与状态

import time
import multiprocessing

def func():
    time.sleep(5)

p = multiprocessing.Process(target=func, name='李木子')
print(p)
print("状态:",p.is_alive())

p.start()
print(p)
print("状态:",p.is_alive())

 

 

 守护模式

提示！多线程中的守护线程与守护进程类似

通俗的讲，皇帝死后(主进程)，妃子陪葬(子进程)

import time
import multiprocessing

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

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

 

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

面向对象使用线程/进程
步骤一： 继承 Process或Thread 类
步骤二： 重写 __init__方法
步骤三： 重写 run方法

import time
import multiprocessing

class MyProcess(multiprocessing.Process):

    def __init__(self, *args, **kwargs):
        super().__init__()  # super重写
        self.args = args
        self.kwargs = kwargs

    def run(self):
        print('我是重写的')
        print(multiprocessing.current_process())    # 子进程的当前进程对象
        print(self.args)
        print(self.kwargs)

print(multiprocessing.current_process())  # 主进程的当前进程对象
p = MyProcess(1, 2, 3, a=1, b=2)  # 实例化
p.start()

 

面向对象使用的思路

 

 

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

import time
import socket
import threading

server = socket.socket()
server.bind(('0.0.0.0', 8888))
server.listen()

class MyThread(threading.Thread):

    def __init__(self, conn):
        super().__init__()  # super重写
        self.conn = conn
        print(self.conn)

    def run(self):
        while True:
            data = self.conn.recv(1024)

            if data == b'':
                self.conn.close()
                break
            else:
                print("接收到的消息: {}".format(data.decode()))
                self.conn.send(data)



while True:
    conn, addr = server.accept()
    print("{}正在连接".format(addr))

    p = MyThread(conn)  # 实例化
    p.start()

客户端：

import socket

click = socket.socket()
click.connect(('127.0.0.1', 8888))

while True:
     data = input("请输入你要发送的数据：")
     click.send(data.encode())
     print("接收到的消息: {}".format(click.recv(1024).decode()))

 

 总结完毕！

 

作者：含笑半步颠√

博客链接：https://www.cnblogs.com/lixy-88428977

声明：本文为博主学习感悟总结，水平有限，如果不当，欢迎指正。如果您认为还不错，欢迎转载。转载与引用请注明作者及出处。