Python的多线程,守护线程,线程安全

简介: Python的多线程,守护线程,线程安全

1、线程

在python中,想要实现多任务除了使用进程,还可以使用线程来完成,线程是实现多任务的另一种形式

线程是进程中执行代码的一个分支,每个执行分支(线程),要想工作执行代码,需要CPU进行调度。

线程是CPU调度的基本单位,每个进程都最少有一个线程,而这个线程就是我们常说的主线程

(1)线程的作用

多线程可以完成多任务

程序默认会有一个主线程,程序员自己创建的线程可以成为子线程,多线程可以完成多任务

多线程,多个线程是在一个进程里创建的,多线程资源共享,共享全局变量

#线程的缘起

资源分配需要分配内存空间,分配cpu:

分配的内存空间存放着临时要处理的数据等,比如要执行的代码,数据

而这些内存空间是有限的,不能无限分配

目前配置高的主机,5万个并发已是上限.线程概念应用而生.

(2)线程的特点

线程是比较轻量级,能干更多的活,一个进程中的所有线程资源是共享的.

一个进程至少有一个线程在工作

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

进程实际上是不干活的,线程才是干活的那一位

进程既可以并发,也可以并行

线程只能并发,不能并行

同一时间,一个进程中的多条线程只能被一个CPU执行

(3)线程的缺陷

#python中的线程可以并发,但是不能并行(同一个进程下的多个线程不能分开被多个cpu同时执行)

#原因:

全局解释器锁(Cpython解释器特有) GIL锁:

同一时间,一个进程下的多个线程只能有一个被cpu执行,不能实现线程的并行操作

python是解释型语言,执行一句编译一句,而不是一次性全部编译成功,不能提前规划,都是临时调度

容易造成cpu执行调度异常.所以加了一把锁叫GIL

#想要并行的解决办法:

(1)用多进程间接实现线程的并行,并不理想,开辟空间消耗资源

(2)换一个Pypy,Jpython解释器 也不好用,兼容性问题

#程序分为计算密集型和io密集型

对于计算密集型程序会过度依赖cpu,但网页,爬虫,OA办公,这种io密集型的程序里,python多线程绰绰有余

计算密集型,Python比较吃力

1、GIL锁不是python的特点。而是cpython的特点。

2、在cpython解释器中,GIL是一把互斥锁,用来保证进程中同一个时刻只有一个线程在执行。

3、在没有GIL锁的情况下,有可能多线程在执行一个代码的同时,垃圾回收机制对所执行代码的变量直接进行回收,其他的线程再使用该变量时会导致运行错误。

4、总结

对于IO密集型应用,即便有GIL存在,由于IO操作会导致GIL释放,其他线程能够获得执行权限。由于多线程的通讯成本低于多进程,因此偏向使用多线程。

对于计算密集型应用,由于CPU一直处于被占用状态,GIL锁直到规定时间才会释放,然后才会切换状态,导致多线程处于绝对的劣势,此时可以采用多进程+协程。

进程是资源分配的最小单元

线程是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百万,由于两个线程是随机执行的,有可能几乎同时对数据进行操作,导致少加的问题

解决办法:上锁

互斥锁:

互斥锁:对共享数据进行锁定,保证同一时刻只能有一个线程去操作

注意:

互斥锁是多个线程一起去抢,抢到锁的线程先执行,没抢到锁的线程需要等待,等互斥锁使用完释放后,

其他等待的线程再去抢这个锁

线程不安全,执行结果不对

多个线程可能同时操作数据,拿到的数据一样,操作后的结果不一样。造成混乱。比如几乎同时拿到1,运算需要时间,但不同线程读取得到的数据是一样的。

线程1拿到数据加1,得到2,线程2拿到数据减1,得到0

线程1往原来数据存2,线程2往原来存0,以后面放的为准,下次操作又会出现同样的混乱。

上锁:不同的线程采用同步计算,当一个线程运算完,才释放锁,让另一个线程运算

from threading import  Thread  , Lock
import time

n = 0

def func1(lock):
    global n
    
    lock.acquire() 
    for i in range(1000000):        
        n += 1
    lock.release()

def func2(lock):
    global n
    # with语法可以简化上锁+解锁的操作,自动完成
    with lock:
        for i in range(1000000):
            n -= 1

        
if __name__ == "__main__":
    lst = []
    lock = Lock()
    
    start = time.time()
    for i in range(10):
        t1 = Thread(target=func1 ,args=(lock,) )
        t1.start()
        
        t2 = Thread(target=func2 ,args=(lock,) )
        t2.start()
        
        lst.append(t1)
        lst.append(t2)

    for i in lst:
        i.join()
    # print(lst,len(lst))
    end = time.time()
    print("主线程执行结束... 当前n结果为{} ,用时{}".format(n , end-start))

给线程上锁,执行结果准确 。with语法,可以简化上锁,解锁操作,自动完成


相关文章
|
2天前
|
安全 Python
在Python中,实现多线程
【7月更文挑战第16天】在Python中,实现多线程
17 6
|
4天前
|
消息中间件 安全 数据处理
Python中的并发编程:理解多线程与多进程的区别与应用
在Python编程中,理解并发编程是提高程序性能和响应速度的关键。本文将深入探讨多线程和多进程的区别、适用场景及实际应用,帮助开发者更好地利用Python进行并发编程。
|
5天前
|
缓存 并行计算 监控
了解 Python 线程
【7月更文挑战第8天】在Python多线程编程中,`threading`模块允许我们获取当前线程名字,通过`current_thread().name`获取。线程名字有助于调试、日志和资源管理。示例代码展示了如何创建线程并打印其名字。在实际应用中,线程命名应清晰、唯一且避免特殊字符,以提高代码可读性和维护性。多线程编程需注意线程安全、死锁、性能优化等问题。通过合理设计和测试,可以利用多线程提高程序并发性和效率。
9 1
|
4天前
|
网络协议 安全 Python
我们将使用Python的内置库`http.server`来创建一个简单的Web服务器。虽然这个示例相对简单,但我们可以围绕它展开许多讨论,包括HTTP协议、网络编程、异常处理、多线程等。
我们将使用Python的内置库`http.server`来创建一个简单的Web服务器。虽然这个示例相对简单,但我们可以围绕它展开许多讨论,包括HTTP协议、网络编程、异常处理、多线程等。
|
8天前
|
设计模式 SQL 安全
Java面试题:设计一个线程安全的内存管理器,使用观察者模式来通知所有线程内存使用情况的变化。如何确保在添加和移除内存块时的线程安全?如何确保任务的顺序执行和调度器的线程安全?
Java面试题:设计一个线程安全的内存管理器,使用观察者模式来通知所有线程内存使用情况的变化。如何确保在添加和移除内存块时的线程安全?如何确保任务的顺序执行和调度器的线程安全?
11 0
|
8天前
|
存储 设计模式 监控
Java面试题:如何在不牺牲性能的前提下,实现一个线程安全的单例模式?如何在生产者-消费者模式中平衡生产和消费的速度?Java内存模型规定了变量在内存中的存储和线程间的交互规则
Java面试题:如何在不牺牲性能的前提下,实现一个线程安全的单例模式?如何在生产者-消费者模式中平衡生产和消费的速度?Java内存模型规定了变量在内存中的存储和线程间的交互规则
18 0
|
8天前
|
设计模式 安全 NoSQL
Java面试题:结合单例模式与Java内存管理,设计一个线程安全的单例类?分析Java多线程工具类ExecutorService与Java并发工具包中的工具类,设计一个Java并发框架的分布式锁实现
Java面试题:结合单例模式与Java内存管理,设计一个线程安全的单例类?分析Java多线程工具类ExecutorService与Java并发工具包中的工具类,设计一个Java并发框架的分布式锁实现
15 0
|
9天前
|
安全 Python
告别低效编程!Python线程与进程并发技术详解,让你的代码飞起来!
【7月更文挑战第9天】Python并发编程提升效率:**理解并发与并行,线程借助`threading`模块处理IO密集型任务,受限于GIL;进程用`multiprocessing`实现并行,绕过GIL限制。示例展示线程和进程创建及同步。选择合适模型,注意线程安全,利用多核,优化性能,实现高效并发编程。
23 3
|
11天前
|
开发者 Python
Python元类实战:打造你的专属编程魔法,让代码随心所欲变化
【7月更文挑战第7天】Python的元类是编程的变形师,用于创建类的“类”,赋予代码在构建时的变形能力。
33 1