2024年网安最全Python的多线程，守护线程，线程安全_python多线程安全

线程是cpu执行调度的最小单元

Python先发明的线程，后来添加的进程。所以线程的使用方法与进程一样

#(1) 一个进程里包含了多个线程,线程之间是异步并发

from threading import Thread
from multiprocessing import Process
import os , time , random


def func(i):
    time.sleep(random.uniform(0.1,0.9))
    print("当前进程号:{}".format(os.getpid()) , i)
    
if __name__ == "\_\_main\_\_":     #线程里面这句话可以不加
    for i in range(10):
        t = Thread(target=func,args=(i,))
        t.start()
        
print(os.getpid())

如下可见，子线程中的进程号与主进程号一样，并且子线程和主进程之间是异步并发的

#(2) 并发的多进程和多线程之间,多线程的速度更快

#多线程速度
def func(i):
    print( "当前进程号:{} , 参数是{} ".format(os.getpid() , i)  )


if __name__ == "\_\_main\_\_":
    lst = []
    startime = time.time()
    for i in range(10000):
        t = Thread(target=func,args=(i,))
        t.start()
        lst.append(t)
    # print(lst)
    for i in lst:
        i.join()
    endtime = time.time()
    print("运行的时间是{}".format(endtime - startime) ) # 运行的时间是1.8805944919586182

#多进程速度

if __name__ == "\_\_main\_\_":
    lst = []
    startime = time.time()
    for i in range(10000):
        p = Process(target=func,args=(i,))
        p.start()
        lst.append(p)
    # print(lst)
    for i in lst:
        i.join()
    endtime = time.time()
    print("运行的时间是{}".format(endtime - startime) ) # 运行的时间是101.68004035949707

多进程：1000个进程耗时9.06秒

多线程：多线程之间，数据共享，可以直接操作数据。1000个线程耗时0.087秒，差距巨大，所以对于IO密集型，还是用多线程较快

多进程执行计算密集型，如果各个进程间各计算各的，不用共享数据，由于可以使用多核，比多线程快。
如果是各个进程间数据共享，同步计算最终结果，多进程反而非常慢，远远慢于多线程

#(3) 多线程之间,数据共享

num = 100
lst = []
def func():
    global num
    num -= 1

for i in range(100):
    t = Thread(target=func)
    t.start()
    lst.append(t)
    
for i in lst:
    i.join()
    
print(num)

多线程之间共享数据，可以直接操作

2、自定义线程类

#用类定义线程，必须手动调用父类__init__方法，必须重载父类run方法，定义自己线程类逻辑
from threading import Thread
import os,time

(1)必须继承父类Thread,来自定义线程类

class MyThread(Thread):

    def \_\_init\_\_(self,name):
        # 手动调用父类的构造方法
        super().__init__()
        # 自定义当前类需要传递的参数
        self.name = name

    def run(self):
        print(  "当前进程号{},name={}".format(os.getpid() , self.name)  )

if __name__ == "\_\_main\_\_":
    t = MyThread("我是线程")
    t.start()
    print( "当前进程号{}".format(os.getpid()) )

新版：
#自定义线程类

from threading import Thread,current_thread
# (1)必须继承父类Thread,来自定义线程类
class MyThread(Thread):
    def \_\_init\_\_(self,name):
        # 手动调用父类的构造方法
        super().__init__()
        # 自定义当前类需要传递的参数
        self.name = name

    def run(self):
        print(f"当前线程的线程号是{current\_thread().ident}")


if __name__ == '\_\_main\_\_':
    for i in range(10):
        t = MyThread(f"线程{i}")
        t.start()

(2)线程中的相关属性

# 线程.is\_alive() 检测线程是否仍然存在
# 线程.setName() 设置线程名字
# 线程.getName() 获取线程名字
# 1.currentThread().ident 查看线程id号 新版用current\_thread().ident
# 2.enumerate() 返回目前正在运行的线程列表
# 3.activeCount() 返回目前正在运行的线程数量

getName,setName被弃用了

新版：

def func():
    time.sleep(1)
if __name__ == "\_\_main\_\_":
    t = Thread(target=func)
    t.start()
    # 检测线程是否仍然存在
    print( t.is_alive() )
    # 线程.getName() 获取线程名字
    print(t.getName())
    # 设置线程名字
    t.setName("抓API接口")
    print(t.getName())



from threading import currentThread
from threading import enumerate
from threading import activeCount
def func():
    time.sleep(0.1)
    print("当前子线程号id是{},进程号{}".format( currentThread().ident ,os.getpid()) )

if __name__ == "\_\_main\_\_":
    t = Thread(target=func)
    t.start()
    print("当前主线程号id是{},进程号{}".format( currentThread().ident ,os.getpid()) )

    
    for i in range(5):
        t = Thread(target=func)
        t.start()
    # 返回目前正在运行的线程列表
    lst = enumerate()
    print(lst,len(lst))
    # 返回目前正在运行的线程数量 (了解)
    print(activeCount())

新版：

# ### 线程中的相关属性
import time
from threading import Thread,current_thread
from threading import enumerate
from threading import active_count

def func():
    time.sleep(1)
    print(f"当前子线程的线程号{current\_thread().ident}")

if __name__ == '\_\_main\_\_':
    for i in range(5):
        t = Thread(target=func)
        t.start()
        #设置线程名
        t.name = f"抓API接口{i}"

    # 返回目前正在运行的线程列表
    lst = enumerate()
    print(lst,len(lst))
    # 返回目前正在运行的线程数量 (了解)
    print(active_count())

当前运行线程数量，一个主线程，5个子线程

3、守护线程

等待所有线程全部执行完毕之后,自己再终止程序,守护所有线程

from threading import Thread
import time
def func1():
    while True:
        time.sleep(1)        
        print("我是函数func1")
        
def func2():
    print("我是func2 start ... ")
    time.sleep(3)
    print("我是func2 end ... ")
    
def func3():
    print("我是func3 start ... ")
    time.sleep(6)    
    print("我是func3 end ... ")
    
    
if __name__ == "\_\_main\_\_":
    t = Thread(target=func1)
    t2 = Thread(target=func2)
    t3 = Thread(target=func3)
    
    # 设置守护线程 (启动前设置) 新版本该方法已弃用
    t.setDaemon(True)
    
    t.start()
    t2.start()
    t3.start()
    
    print("主线程执行结束.... ")

新版本设置守护线程的setDaemon()方法已弃用，改为了通过属性设置

守护线程是等所有线程执行结束，自己再终止程序，守护所有线程

4、线程中的数据安全问题

#多线程之间共享全局变量，出现数据错误问题

import threading

#全局变量
g_sum = 0


def sum1():
    for i in range(1000000):
        # 不可变类型用方法修改数据，要声明为全局变量
        global g_sum
        g_sum += 1
    print('sum1', g_sum)


def sum2():
    for i in range(1000000):
        global g_sum
        g_sum += 1
    print('sum2', g_sum)


if __name__ == '\_\_main\_\_':
    sum1_thread = threading.Thread(target=sum1)
    sum2_thread = threading.Thread(target=sum2)
    sum1_thread.start()
    sum2_thread.start()

sum1 911662
sum2 1434503

出现的结果不是2百万，由于两个线程是随机执行的，有可能几乎同时对数据进行操作，导致少加的问题
解决办法：上锁
互斥锁：

还有兄弟不知道网络安全面试可以提前刷题吗？费时一周整理的160+网络安全面试题，金九银十，做网络安全面试里的显眼包！

王岚嵚工程师面试题（附答案），只能帮兄弟们到这儿了！如果你能答对70%，找一个安全工作，问题不大。

对于有1-3年工作经验，想要跳槽的朋友来说，也是很好的温习资料！

【完整版领取方式在文末！！】

93道网络安全面试题

内容实在太多，不一一截图了

黑客学习资源推荐

最后给大家分享一份全套的网络安全学习资料，给那些想学习 网络安全的小伙伴们一点帮助！

对于从来没有接触过网络安全的同学，我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线，大家跟着这个大的方向学习准没问题。

1️⃣零基础入门

① 学习路线

对于从来没有接触过网络安全的同学，我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线，大家跟着这个大的方向学习准没问题。

② 路线对应学习视频

同时每个成长路线对应的板块都有配套的视频提供：

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

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

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