Python实现多线程（一）

Python实现多线程（一）

目录

一、概念

线程和进程

二、多线程的实现

1、创建线程

2、多线程的特性

3、线程锁

4、递归锁

5、代码实例实战

三、资源学习与参考 

---

一、概念 线程和进程

1．线程是程序执行的最小单位，而进程是 *** 作系统分配资源的最小单位;

2.一个进程由一个或多个线程组成，线程是一个进程中代码的不同执行路线

3．进程之间相互独立，但同一进程下的各个线程之间共享程序的内存空间(包括代码段，数据集，维等)及一些进程级的资源(如打开文伟阿维的号等)，某进程内的线程在其他进程不可见;

4．调度和切换:线程上下文切换比进程上下文切换要快得多

二、多线程的实现 1、创建线程

普通创建方式(法1）和自定义线程（法2:继承threading.Thread来定义线程类，其本质是重构Thread类中的run方法）两种方法

#创建线程的两种方法
#法1
def test(x):
    print(x)
    time.sleep(3)

t1=threading.Thread(target=test,args=(1,))
t2=threading.Thread(target=test,args=(2,))
t1.start()
t2.start()
# 法2
cLass MyThread(threading.Thread):
    def __ init__ (seLf, n):
		super (MyThread, seLf).__ init__()
		self.n = n
	def run(self):
		print('以类的方式创建多线程',self.n)
		time.sleep(3)
r1 = MyThread(1)
r2 = MyThread(2)
r1.start()
r2.start()

2、多线程的特性

守护线程：
    使用setDaemon(True)把所有的子线程都变成了主线程的守护线程，
    因此当主线程结束后，子线程也会随之结束，所以当主线程结束后，整个程序就退出了。
    所谓’线程守护’，就是主线程不管该线程的执行情况，只要是其他子线程结束且主线程执行完  毕，主线程都会关闭。也就是说:主线程不等待该守护线程的执行完再去关闭。

可参照此文：(54条消息) python多线程详解（超详细）_世俗的眼光-CSDN博客_python 多线程

def run(n):
    print('task',n)
    time.sleep(2)
    print('5s')
    time.sleep(2)
    print('3s')
    time.sleep(2)
    print('1s')
if __name__ == '__main__':
    t=threading.Thread(target=run,args=('t1',))
    t.setDaemon(True)    #把子线程设置为守护线程，必须在start()之前设置
    t.start()
    t.join()     #设置主线程等待子线程结束
    print('end')

3、线程锁

由于线程之间是进行随机调度，并且每个线程可能只执行n条执行之后，当多个线程同时修改同一条数据时可能会出现脏数据，所以出现了线程锁，即同一时刻允许一个线程执行 *** 作。线程锁用于锁定资源，可以定义多个锁，像下面的代码，当需要独占某一个资源时，任何一个锁都可以锁定这个资源，就好比你用不同的锁都可以把这个相同的门锁住一样。（代码如示）

def work():
    global n
    lock.acquire()
    temp = n
    time.sleep(0.1)
    n = temp-1
    lock.release()
if __name__ == '__main__':
    lock = Lock()
    n = 100
    l = []
    for i in range(100):
        p = Thread(target=work)
        l.append(p)
        p.start()
    for p in l:
        p.join()

4、递归锁

'''
    递归锁：RLcok类的用法和Lock类一模一样，但它支持嵌套，在多个锁没有释放的时候一般会使用RLock类
'''
def func(lock):
    global gl_num
    lock.acquire()
    gl_num += 1
    time.sleep(1)
    print(gl_num)
    lock.release()
if __name__ == '__main__':
    gl_num = 0
    lock = threading.RLock()
    for i in range(10):
        t = threading.Thread(target=func,args=(lock,))
        t.start()

5、代码实例实战

例子：在一个线程中，每秒循环输出当前的年月日时分秒;于此同时，在另一个线程中，实现张三的姓名每2秒打印输出4次结束。注意∶都需要使用类和继承实现功能

代码模块：

import threading
import time
'''
  自定义线程：继承threading.Thread来定义线程类，其本质是重构Thread类中的run方法
'''
#在一个线程中，每秒循环输出当前的年月日时分秒
class Thread1(threading.Thread):
    def run(self):
        while (True):
            #获取即时时间并打印
            ltime = time.asctime(time.localtime(time.time()))
            print(ltime)
            #实现每秒即时打印
            time.sleep(1)
#在另一个线程中，实现张三的姓名每2秒打印输出4次结束
class Thread2(threading.Thread):
    #构造方法，继承threading.Thread，并实例化
    def __init__(self,name):
        #继承父类的方法实现继承threading.Thread
        super(Thread2, self).__init__()
        #实例化对象属性
        self.name=name
    #重写Thread类中的run方法
    def run(self):
        #用for语句循环实现4次打印张三的名字
        for i in range(4):
            print(self.name)
            #实现线程每隔两秒打印
            time.sleep(2)
#主函数
if __name__ == '__main__':
    #分别启动线程1和线程2
    #创建线程对象t1，然后用start方法启动线程
    t1 = Thread1()
    t1.start()
    # 创建线程对象t1，传入参数name=张三，然后用start方法启动线程
    t2 = Thread2("张三")
    t2.start()

输出样例：

Sat Jan  8 17:29:16 2022
张三
Sat Jan  8 17:29:17 2022
张三
Sat Jan  8 17:29:18 2022
Sat Jan  8 17:29:19 2022
张三
Sat Jan  8 17:29:20 2022
Sat Jan  8 17:29:21 2022
张三
Sat Jan  8 17:29:22 2022
Sat Jan  8 17:29:23 2022
Sat Jan  8 17:29:24 2022

三、资源学习与参考 

参考文档：​​​​​​(54条消息) python多线程详解（超详细）_世俗的眼光-CSDN博客_python 多线程

参考视频：67-Python多线程-多线程特性_哔哩哔哩_bilibili