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

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

巴特西

python_进程与线程的补充

最新文章

热门文章