当前位置: 主页 > Python语言

python 多线程并发锁-ace ace_task_base并发线程

发布时间:2023-02-09 11:38   浏览次数:次   作者:佚名

本文内容是关于Python多线程线程锁的简单理解(代码)。 具有一定的参考价值。 有需要的朋友可以参考一下。 希望对您有所帮助。

多线程线程模块create thread创建自己的线程类线程通信线程同步互斥方法线程锁@需要知道的! ! !

多线程

什么是线程?

线程也是一种多任务编程方式,可以利用计算机的多核资源来完成程序的并发运行。

线程也称为轻量级进程

螺纹特性

线程是计算机多核分配的最小单位

一个进程可以包含多个线程

线程也是一个正在运行的消耗计算机资源的进程,多个线程共享进程的资源和空间

线程的创建和删除消耗的资源远远少于进程

多线程执行互不干扰

线程也有自己独特的属性,比如指令集ID

线程模块创建线程

t = 线程。 线()

name:线程名称python 多线程并发锁,为空默认值,Tread-1,Tread-2,Tread-3

目标:线程函数

args:元组,根据位置向线程函数传递参数

kwargs:字典,根据key值向county函数传递参数

功能:创建线程对象

范围

t.start():启动线程,自动运行线程函数

t.join([timeout]): 回收过程

t.is_alive():查看线程状态

t.name():查看线程名称

t.setName():设置线程名称

t.daemon属性:默认主线程退出不影响分支线程继续执行,如果设置为Truepython 多线程并发锁,分支线程随主线程一起退出

t.daemon = 真

吨。 setDaemon(真)

设定方法

#!/usr/bin/env python3
from threading import Thread
from time import sleep
import os
# 创建线程函数
def music():
    sleep(2)
    print("分支线程")
t = Thread(target = music)
# t.start()   # ******************************
print("主线程结束---------")
'''没有设置的打印结果
主线程结束---------
分支线程
'''
'''设置为True打印结果
主线程结束---------
'''

登录复制

threading.currentThread:获取当前线程对象

@这里的代码表示子线程在同一个进程中共享变量

#!/usr/bin/env python3

从线程导入线程

从时间导入睡眠

导入操作系统

# 创建线程函数

定义音乐():

全球的

打印(“一个=”,一个)

一 = 10000

对于我在范围内(5):

睡觉(1)

打印(“1212”)

一 = 1

t = 线程(目标 = 音乐)

吨。 开始()

吨。 加入()

print("a of the main thread = ", a) 创建自己的线程类

检查点:类的使用,调用父类的__init__方法,函数*参数传递和**参数传递

from threading import Thread
import time
class MyThread(Thread):
    name1 = 'MyThread-1'
    def __init__(self,target,args=(), kwargs={}, name = 'MyThread-1'):
        super().__init__()
        self.name = name
        self.target = target
        self.args = args
        self.kwargs = kwargs
    def run(self):
        self.target(*self.args,**self.kwargs)
def player(song,sec):
    for i in range(2):
        print("播放 %s:%s"%(song,time.ctime()))
        time.sleep(sec)
t =MyThread(target = player, args = ('亮亮',2))
t.start()
t.join()

登录复制

线程通信

通信方式:由于多个线程共享进程的内存空间,线程间通信可以使用全局变量来完成

注意:线程间使用全局变量往往需要同步互斥机制来保证通信的安全

线程同步互斥方法

事件

e = threading.Event():创建一个事件对象

e.wait([timeout]):设置状态,如果已经设置了,那么这个函数就会阻塞,timeout就是超时时间

e.set:将e变为set状态

e.clear:删除设置状态

import threading
from time import sleep
def fun1():
    print("bar拜山头")
    global s
    s = "天王盖地虎"
def fun2():
    sleep(4)
    global s
    print("我把限制解除了")
    e.set()     # 解除限制,释放资源
def fun3():
    e.wait() # 检测限制
    print("说出口令")
    global s
    if s == "天王盖地虎":
        print("宝塔镇河妖,自己人")
    else:
        print("打死他")
    s = "哈哈哈哈哈哈"
# 创建同步互斥对象
e = threading.Event()
# 创建新线程
f1 = threading.Thread(target = fun1)
f3 = threading.Thread(target = fun3)
f2 = threading.Thread(target = fun2)
# 开启线程
f1.start()
f3.start()
f2.start()
#准备回收
f1.join()
f3.join()
f2.join()

登录复制

线程锁

lock = threading.Lock():创建一个锁对象

lock.acquire(): 锁定

lock.release(): 解锁

也可以用with来加锁

1 with lock:
2     ...
3     ...

登录复制

需要知道! ! !

Python 线程的 GIL 问题(全局解释器):

python---->支持多线程---->同步互斥问题---->加锁解决方案---->超级锁(给解释器加锁)---->解释器只能占一个线程- --> 导致效率低下

后果:

一个解释器一次只能解释执行一个线程,导致Python线程效率低下,但是遇到IO阻塞时,线程会主动放弃解释器,所以Python线程更适合高延迟IO程序并发

解决方案

尝试使用进程来完成并发(等于没说)

C解释器使用不当(使用C#、JAVA)

并发操作尽量使用多种方案组合,高延迟IO使用线程

以上就是Python多线程与线程锁简单理解的详细内容(代码)。 更多内容请关注php中文网其他相关文章!