2024年最新手把手教你做项目多线程篇——基础知识详解_多线程项目(1)

结果：1#我的就一个你的呢？

如果你的进程不为一的话还可以这样查看每一个进程名

import threading
def main():
print(threading.active_count())
print(threading.enumerate())

if name == ‘__main__’:
main()

[<_MainThread(MainThread, started 36004)>]#返回的是一个列表因为我的目前就一个所以就一个主进程

还可以查看正在运行的进程

import threading
def main():
print(threading.active_count())
print(threading.enumerate())
print(threading.current_thread())

if name == ‘__main__’:
main()

1
[<_MainThread(MainThread, started 36004)>]
<_MainThread(MainThread, started 36004)>

### 创建一个简单的线程


首先我们先介绍一下`threading.Thread（）`里面的参数，大家学python每个模块的功能时最好还是看一下源文件内容，这样有助于提高你的编程能力：  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20210716135001794.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1aWFuZHh1ZWh1aQ==,size_16,color_FFFFFF,t_70)


需要注意的点我已经打上标记了

import threading
def first():
print(“frist active”)
print(“frist finish”)

def main():
first_thread=threading.Thread(target=first,name=“T1”)
first_thread.start()#开始的标志
print(“main”)

if name == ‘__main__’:
main()

结果：
第一次运行
frist active
main
frist finish
第二次运行
frist active
frist finish
main

每次的结果不一样就已经表明Frist和main是同时运行的了。  
 如果说效果不太明显的话，我们改进一下接下来我们引入

import time

import threading
import time
def first():
print(“frist active”)
time.sleep(3)
print(“frist finish”)

def main():
first_thread=threading.Thread(target=first,name=“T1”)
first_thread.start()
print(“main”)

if name == ‘__main__’:
main()

结果：
frist active
main
frist finish

因为执行到Frist active的时候Frist线程要睡3秒这个时候main还在执行所以这样每次都是这个结果了。  
 **特别强调**`target=first`不是导入Frist函数从源文件我们就已经看出是通过run（）方法进行的，这里解释我引用一位大佬解释  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20210716141032861.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1aWFuZHh1ZWh1aQ==,size_16,color_FFFFFF,t_70)


[链接](https://bbs.csdn.net/topics/618545628)  
 这位大佬大家应该都熟悉，就是顶顶大名的雷学委各位大佬可以去他的主页看看可能会学到些新知识[雷学委](https://bbs.csdn.net/topics/618545628)  
 当然如果你觉得这样不行的话你也可以重写`threading.Thresd`里的run方法来个自定义线程

class MyThread(threading.Thread):
    def \_\_init\_\_(self,n):
        super(MyThread,self).__init__()   #重构run函数必须写
        self.n = n

    def run(self):
        print('task',self.n)
        time.sleep(1)
        print('2s')
        time.sleep(1)
        print('1s')
        time.sleep(1)
        print('0s')
        time.sleep(1)

if __name__ == '\_\_main\_\_':
    t1 = MyThread('t1')
    t2 = MyThread('t2')
    t1.start()
    t2.start()

结果：
task t1
task t2
2s
2s
1s
1s
0s
0s

### 守护线程

所谓’线程守护’，就是主线程不管该线程的执行情况，只要是其他子线程结束且主线程执行完毕，主线程都会关闭。也就是说:主线程不等待该守护线程的执行完再去关闭。

不好理解的话来看看例子

import threading
import time
def first():
print(“frist active”)
time.sleep(3)
print(“frist finish”)

def second():
print(“second active”)
print(“second finish”)

def main():
first_thread=threading.Thread(target=first,name=“T1”)
second_thresd=threading.Thread(target=second,name=“T2”)
first_thread.setDaemon(True)#一定要在start（）前开始
first_thread.start()
second_thresd.start()
print(“main”)

if name == ‘__main__’:
main()

结果
frist active
second active
second finishjiemeijieshu
main

当主线程和其他子线程都结束不管守护线程`first_thread` 结没结束程序都结束  
 当设`second_thresd`为守护线程的时候情况是这样的

import threading
import time
def first():
print(“frist active”)
time.sleep(3)
print(“frist finish”)

def second():
print(“second active”)
print(“second finish”)

def main():
first_thread=threading.Thread(target=first,name=“T1”)
second_thresd=threading.Thread(target=second,name=“T2”)
second_thresd.setDaemon(True)#一定要在start（）前开始
first_thread.start()
second_thresd.start()
print(“main”)

if name == ‘__main__’:
main()

frist active
second active
second finish
main
frist finish #尽管输出这个要等三秒

### 主进程等待子进程结束


为了让守护线程执行结束之后，主线程再结束，我们可以使用join方法，让主线程等待子线程执行

import threading
import time
def first():
print(“frist active”)
time.sleep(3)
print(“frist finish”)

def second():
print(“second active”)
print(“second finish”)

def main():
first_thread=threading.Thread(target=first,name=“T1”)
second_thresd=threading.Thread(target=second,name=“T2”)
first_thread.start()
second_thresd.start()
first_thread.join()

print("main")

if name == ‘__main__’:
main()

结果：
frist active
second active
second finish
frist finish
main
不加join是这样的结果
frist active
second active
second finish
main
frist finish

### 共享全局变量的特性


这里定义一个全局变量A

import threading
import time
def first():
global A
print(“frist active”)
time.sleep(3)
A=A+3
print(“frist:%d”%A)
print(“frist finish”)

def second():
global A
print(“second active”)
A=A+6
print(“second:%d”%A)
print(“second finish”)

def main():
global A
first_thread=threading.Thread(target=first,name=“T1”)
second_thresd=threading.Thread(target=second,name=“T2”)
first_thread.start()
second_thresd.start()
#first_thread.join()

print("main")
A=A+3
print("mian:%d"%A)

if name == ‘__main__’:
A=0
main()

来看一下结果

frist active
second active
second:6
second finish
main
mian:9
frist:12
frist finish

### 锁


由上面的例子可以看出，输出A的值的时候不同进程之间的资源是共享的这就导致了变量A的值不固定造成了脏数据的情况，不理解的话我们就来个例子。  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20210717201150592.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1aWFuZHh1ZWh1aQ==,size_16,color_FFFFFF,t_70)


在没有互斥锁的情况下，假设账户有一万元钱，存钱和取钱同时进行可能账户余额会有一万一千元。这样我当然高兴只是银行不答应。为了避免这种情况我们引入锁的概念，下面我们简单的介绍几种编程里面常用的。


#### 互斥锁

import threading
import time
def first():
global A,lock
lock.acquire()
print(“frist active”)
time.sleep(3)
A=A+3
print(“frist:%d”%A)
print(“frist finish”)
lock.release()

def second():
global A,lock
lock.acquire()
print(“second active”)
A=A+6
print(“second:%d”%A)
print(“second finish”)
lock.release

def main():
global A,lock
lock=threading.Lock()
first_thread=threading.Thread(target=first,name=“T1”)
second_thresd=threading.Thread(target=second,name=“T2”)
first_thread.start()
second_thresd.start()
#first_thread.join()

print("main")
A=A+3
print("mian:%d"%A)

if name == ‘__main__’:

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

.start()
#first_thread.join()

print("main")
A=A+3
print("mian:%d"%A)

if name == ‘__main__’:

[外链图片转存中…(img-KOmQ23pk-1714690761200)]
[外链图片转存中…(img-mn1eTSdU-1714690761201)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！