Python多线程以及线程锁简单理解（代码）

本篇文章给大家带来的内容是关于Python多线程以及线程锁简单理解（代码），有一定的参考价值，有需要的朋友可以参考一下，希望对你有所帮助。

target：线程函数

args：元组，给线程函数按照位置传参

kwargs：字典，给县城函数按照键值传参

功能：创建线程对象

参数

t.start()：启动线程，自动运行线程函数

t.join([timeout])：回收进程

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

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

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

t.daemon属性：默认主线成退出不影响分支线程继续执行,如果设置为True则分支线程随着主线程一起退出

t.daemon = True

t.setDaemon(Ture)

设置方法

#!/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打印结果
主线程结束---------
''' 

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() 

线程通信

通信方法：由于多个线程共享进程的内存空间，所以线程间通信可以使用全局变量完成

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

线程同步互斥方法

event

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

e.wait([timeout])：设置状态，如果已经设置，那么这个函数将阻塞，timeout为超时时间

e.set：将e变成设置状态

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阻塞时线程会主动让出解释器，因此Pyhton线程更加适合高延迟的IO程序并发

解决方案

尽量使用进程完成并发（和没说一样）

不适当用C解释器 （用C# ,JAVA)

尽量使用多种方案组合的方式进行并发操作，线程用作高延迟IO

以上就是Python多线程以及线程锁简单理解（代码）的详细内容，更多请关注Gxl网其它相关文章！

查看更多关于Python多线程以及线程锁简单理解（代码）的详细内容...