Python线程编程之Thread详解

from threading import Thread
t = Thread()
功能: 创建线程对象
参数: target 绑定线程函数
	args 元组 给线程函数位置传参
	kwargs 字典 给线程函数键值传参

t.start()

"""
thread1.py 线程基础使用
步骤:
1. 封装线程函数
2.创建线程对象
3.启动线程
4.回收线程
"""
import os
from threading import Thread
from time import sleep
a = 1
# 线程函数
def music():
    for i in range(3):
        sleep(2)
        print('播放:黄河大合唱 %s' % os.getpid())
    global  a
    print("a,",a)
    a = 1000
# 创建线程对象
t = Thread(target=music)
# 启动线程
t.start()
for i in range(3):
    sleep(1)
    print('播放:beauty love %s' % os.getpid())
# 回收线程
t.join()
print('程序结束')
print("a,", a)

"""
thread3.py
线程属性演示
"""
from threading import Thread
from time import sleep

def fun():
    sleep(3)
    print('线程属性测试')

t = Thread(target=fun, name='ceshi')
# 主线程退出分支线程也退出 必须在start前使用 与join 没有意义
t.setDaemon(True)
t.start()
print(t.getName())
t.setName('Tedu')
print('is alive:', t.is_alive())
print('daemon', t.daemon)

"""
自定义线程类例子
"""
from threading import Thread

# 自定义线程类
class ThreadClass(Thread):
    # 重写父类 init
    def __init__(self, *args, **kwargs):
        self.attr = args[0]
        # 加载父类init
        super().__init__()
    # 假设需要很多步骤完成功能
    def f1(self):
        print('1')
    def f2(self):
        print(2)
    # 重写run 逻辑调佣
    def run(self):
        self.f1()
        self.f2()

t = ThreadClass()
t.start()
t.join()

from threading import Thread
from time import sleep, ctime

class MyThread(Thread):
    def __init__(self, group=None, target=None, name=None,
                 args=(), kwargs=None, *, daemon=None):
        super().__init__()
        self.fun = target
        self.args = args
        self.kwargs = kwargs
    def run(self):
        self.fun(*self.args, **self.kwargs)

def player(sec, song):
    for i in range(3):
        print("Playing %s : %s" % (song, ctime()))
        sleep(sec)

t = MyThread(target=player, args=(3,), kwargs={'song': '量量'})
t.start()
t.join()

## 9.线程同步互斥方法

from threading import Event
# 创建线程event对象
e = Event()
# 阻塞等待e被set
e.wait([timeout]) 
# 设置e, 使wait结束阻塞
e.set() 
# 使e回到未被设置状态
e.clear() 
# 查看当前e是否被设置
e.is_set() 

"""
event 线程互斥方法演示
"""
from threading import Event, Thread
s = None  # 用于通信
e = Event()
def yzr():
    print('杨子荣前来拜山头')
    global s
    s = '天王盖地虎'
    e.set() #操作完共享资源 e设置

t = Thread(target=yzr)
t.start()
print('说对口令就是自己人')
e.wait() #阻塞等待 e.set()
if s == '天王盖地虎':
    print('宝塔镇河妖')
    print('确认过眼神,你是对的人')
    e.clear()
else:
    print('打死他...')
t.join()
print('程序结束')

from threading import Lock
lock = Lock()创建锁对象
lock.acquire() 上锁 如果lock已经上锁再调用会阻塞
lock.release() 解锁
with lock: 上锁
....
....
with 代码块解锁自动解锁

"""
thread_lock
线程锁演示
"""
from threading import Thread, Lock
a = b = 0
lock = Lock()

def value():
    while True:
        # 上锁
        lock.acquire()
        print('a=%d,b=%d' % (a, b)) if a != b else print('a不等于b')
        # 解锁
        lock.release()

t = Thread(target=value)
t.start()
while True:
    # with 开始上锁
    with lock:
        a += 1
        b += 1
    # with 解锁 自动解锁
t.join()
print('程序结束')

from time import sleep
from threading import Thread, Lock

# 交易类
class Account:
    def __init__(self, _id, balance, lock):
        # 用户
        self._id = _id
        # 存款
        self.balance = balance
        # 锁
        self.lock = lock
    # 取钱
    def withdraw(self, amount):
        self.balance -= amount
    # 存钱
    def deposit(self, amount):
        self.balance += amount
    # 余额
    def get_balance(self):
        return self.balance

Tom = Account('Tom', 5000, Lock())
Alex = Account('Alex', 8000, Lock())

def transfer(from_, to, amount):
    # 锁住自己账户
    if from_.lock.acquire():
        # 账户减少
        from_.withdraw(amount)
        sleep(0.5)
        if to.lock.acquire():
            to.deposit(amount)
            to.lock.release()
        from_.lock.release()
    print('转账完成 %s给%s转账%d' % (from_._id, to._id, amount))

# transfer(Tom, Alex, 1000)
t1 = Thread(target=transfer, args=(Tom, Alex, 2000))
t2 = Thread(target=transfer, args=(Alex, Tom, 3500))
t1.start()
t2.start()
t1.join()
t2.join()
print('程序结束')