多线程

Posted 2022-10-02 whileke

1、线程是在进程里面控制工作的

2、同一进程里的线程的进程id是一样的

3、同一进程里的线程的内存空间是共享的

4、线程是在已有的进程里进行开启的，所以开启线程开销较小，几乎一请求开启就会立即开启

一、开启线程的两种方法：

from threading import Thread

import time
def tak(name):
    print(‘%s 进程‘ % name)
    time.sleep(2)
    print(‘%s 子进程 ‘ % name)

if __name__ ==‘__main__‘:
    p1 = Thread(target=tak,args=(1,))
    p2 = Thread(target=tak,args=(2,))
    p3 = Thread(target=tak,args=(3,))
    p4 = Thread(target=tak,args=(4,))
    p5 = Thread(target=tak,args=(5,))

    p1.start()
    p2.start()
    p3.start()
    p4.start()
    p5.start()
    print(‘主‘)

第一种

from threading import Thread
import time
class Tak(Thread):
    def __init__(self,name):
        super().__init__()
        self.name = name

    def run(self):
        print(‘%s 进程‘ %  self.name)
        time.sleep(3)
        print(‘%s 子进程‘ %  self.name)

if __name__ == ‘__main__‘:
    p1 = Tak(‘1‘)
    p2 = Tak(‘2‘)
    p3 = Tak(‘3‘)
    p4 = Tak(‘4‘)
    p5 = Tak(‘5‘)

    p1.start()
    p2.start()
    p3.start()
    p4.start()
    p5.start()
    print(‘主‘)

第二种：自己创建类继承Thread

二、Thread的其他属性

Thread实例化对象的一些属性：

　　isAlive(): 返回线程是否存活

　　getName(): 查看当前线程的线程名

　　setName(): 设置线程名

threading模块提供的一些方法:

　　threading.currentThread():  返回当前线程的变量

　　threading.enumerate(): 返回一个包含正在运行的线程list，不包含未运行与已终止的线程

　　threading.activeCount(): 返回正在运行的线程的数量

def act():
    print(‘ 子线程ID： %s   ‘ % current_thread().getName())  # 当前线程名
    time.sleep(2)
    print(‘子线程 ID %s ‘ % current_thread())

if __name__ == ‘__main__‘:
    t1 = Thread(target= act )
    t1.start()    # 这里因为线程开启资源较小，请求后会立即开启所以未设置之前默认名字是Thread-1

    t1.setName(‘666‘)
    print(t1.getName())
    

    print( t1.isAlive())   # 查看线程是否是活动的
    print(activeCount())  # 正在运行的线程的数量
    print(enumerate())  # 正在运行，运行时到运行结束的线程放到一个列表里面进行返回
    print(t1.getName())

运行结果：

 子线程ID： Thread-1   # 默认线程名
666

True
2
[<_MainThread(MainThread, started 6760)>, <Thread(666, started 14288)>]

子线程 ID <Thread(666, started 14288)> 

三、守护线程

守护线程与守护进程不一样，守护进程是主进程结束后守护进程会跟随进行结束，守护线程是主线程结束后需要等待非守护进程全部运行结束了，进程才结束，线程的结束就是进程的结束

注意：一个进程里在没有创建新的线程的时候，进程里面默认会有一个线程

在自己创建一个线程的时候：

from threading import Thread
import time

def sayhi(name):
    time.sleep(2)
    print(‘%s say hi‘ % name)

if __name__ == ‘__main__‘:
    t = Thread(target=sayhi,args=(‘alxe‘,))
    # t.setDaemon(True)  # 守护线程
    t.daemon=True  # 这样也可以
    t.start()

    print(‘主线程‘)   # 这里有两个线程，一个主线程，一个子线程，守护的是子线程，进程必须保证非守护线程运行完毕才能结束
    # 当主线程运行完后，也就是非守护线程运行结束了，所以子线程就直接终止了

<<<<主线程

创建多个线程的时候：

from threading import Thread,activeCount
import time

def sayhi(name):
    time.sleep(2)
    print(‘%s say hi‘ % name)

if __name__ == ‘__main__‘:
    t1 = Thread(target=sayhi,args=(‘alxe‘,))
    t2 = Thread(target=sayhi,args=(‘123‘,))
    t3 = Thread(target=sayhi,args=(‘wert‘,))
    # t.setDaemon(True)  # 守护线程
    t1.daemon=True  # 这样也可以
    t1.start()
    t2.start()
    t3.start()

    # 这里只守护了一个线程，守护线程会等其他非守护线程运行完后才结束线程
    print(‘主线程‘)
    print(activeCount())

结果：

主线程
4
123 say hi
wert say hi
alxe say hi