Python 多线程和多进程

^ 多线程和多进程

多线程：from threading import Thread

多进程：from multiprocessing import Process

-第一种创建多线程方法 直接创建线程

T = threading.Thread(target=work, args=(“server_one”, )) # 创建线程对象

target：让线程执行什么任务.

args：线程启动之后，target执行时需要传递的参数. # 参数类型为 tuple (元组).

T.start()

T.join()

import threading
import time
import random
from threading import Thread


def work(server):

    begin = time.time()

    print("检查", server)
    use = random.randint(1, 3)
    time.sleep(use)
    print("关闭", server)

    end = time.time()

    print("本次用时大约：{:.5f}秒".format(end - begin))


if __name__ == "__main__":	# 主线程
    t1 = Thread(target=work, args=("server_one", ))		# 子线程
    t2 = Thread(target=work, args=("server_two", ))		# 子线程
    t3 = Thread(target=work, args=("server_three", ))
    t1.start()	# 告诉CPU，该线程可以启动.
    t2.start()
    t3.start()

-概念

进程是资源分配的最小单位，线程是CPU调度的最小单位

线程：一个进程会有多个线程，至少拥有一个线程.

进程：正在进行中的程序. # 资源单位，不是执行单位.

线程：员工

进程：公司

每次运行程序都会至少产生一个单独的进程，该进程中会有一个主线程存在.

-第二种创建线程方法 继承Thread类

并在自己的类中，重写run方法.

import time
import random

from threading import Thread  # 线程


# 继承Thread类，并在自己的类中，重写run方法.
class MyThread(Thread):

    def __init__(self, server):
        self.server = server
        super(MyThread, self).__init__()    # 子类如果重写父类中的__init__()， 必须调用父类的__init__().

    # run()：线程启动之后需要执行的任务.
    def run(self) -> None:  # 表示返回值类型应该是None.	需使用__init__()进行传参.
        print("开始测试：", self.server)
        time.sleep(random.randint(1, 5))
        print("结束测试：", self.server)


# if __name__ == "__main__":
#     b1 = MyThread("server_one")
#     b2 = MyThread("server_two")
#     b3 = MyThread("server_three")
#     # 启动线程使用start().
#     b1.start()
#     b2.start()
#     b3.start()
    
    
    
if __name__ == "__main__":
    for count in range(1, 101):
        variable = "server" + str(count)
        begin = MyThread(variable)
        begin.start()

-join()

需要等待子线程结束后，才会继续执行主线程.

等待过程中，其他线程也在运行.

if __name__ == "__main__":
    b1 = MyThread("server_one")
    b2 = MyThread("server_two")
    
    # 启动线程使用start().
    b1.start()
    b2.start()

    b1.join()
    b2.join()

    print("service")

-注意

不要让多线程变成单线程了

if __name__ == "__main__":
    Thread_list = []
    for count in range(1, 101):
        variable = "server" + str(count)
        begin = MyThread(variable)
        Thread_list.append(begin)

    print(Thread_list)

    for server_begin in Thread_list:
        server_begin.start()

    for server_end in Thread_list[::-1]:
        server_end.join()
        
    print("service")

-创建多进程

创建使用方法类似多线程

– 第一种（最常用）

from multiprocessing import Process


def work():

    for number in range(10000):
        print("子进程", number)


if __name__ == "__main__":

    p = Process(target=work)
    p.start()

    for n in range(10000):
        print("主进程", n)

– 第二种（几乎不用）

from multiprocessing import Process


class MyProcess(Process):

    def run(self) -> None:
        for digit in range(10000):
            print("子进程", digit)


if __name__ == '__main__':

    p = MyProcess()
    p.start()

    for number in range(10000):
        print("主进程", number)