您现在的位置是：首页 > Python

当前栏目

python线程回顾

Python 状态线程

2023-03-02 11:11:31 时间

# python 线程 #

# threading.Thread
    class Thread:
    	def __init__(self, group=None, target=None, name=None,
                     args=(), kwargs=None, *, daemon=None):
            pass
    """ group : group值，保留参数，供未来使用，为None就对了 target : 启动一个线程时，线程内执行的函数 name : 线程的名字，默认情况下，Thread-N 形式的名字 args : 传递给目标函数一个参数元组 kwargs : 传递关键字字典参数 """

栗子

import threading
    import time
    def function(i):
        time.sleep(1)
        print(f"function called by thread {i} ")
        return
    
    
    threads = []
    
    for i in range(10):
        t = threading.Thread(target=function,args=(i,))  # 传递元组，单个元素时，使用(x,)
        threads.append(t)
        t.start()          # 开始执行
    
    for _t in threads:
        _t.join()          # 阻塞，等待线程执行完成

# **在自类中使用线程** #

from threading import Thread
    from time import sleep
    
    class SayHello(Thread):
        def __init__(self):
            Thread.__init__(self)
            self.message = "Thread : Hello World !"
    
        def print_message(self):
            print(self.message)
    
        def run(self):
            sleep(1)
            print("Thread starting")
            sleep(1)
            self.print_message()
            sleep(1)
            print("Thread Ended")
    
    if __name__ == '__main__':
        print("Process Started")
        hello_thread = SayHello()
        hello_thread.start()
        # hello_thread.join()
        print("Process Ended")

# 使用 `Lock` 和 `RLock` 实现线程同步 #

使用锁 与 不使用锁的区别。

import threading
    
    shared_lock_num = 0    # 使用锁，去计算
    shared_nolock_num = 0  # 未使用锁，去计算
    COUNT = 100000
    share_lock = threading.Lock() # 锁对象
    
    # 下面我们将对上面两个数+100,000 -100,000
    # 熟悉的朋友就会知道，使用锁的数值还是0，而不使用锁就未知了
    
    def increment_with_lock():
        global shared_lock_num
        for i in range(COUNT):
            share_lock.acquire()  # 上锁
            shared_lock_num += 1
            share_lock.release()  #释放锁
            
            """ # 此处还可以使用上下文管理器 with share_lock: shared_lock_num += 1 """
    
    def decrement_with_lock():
        global shared_lock_num
        for i in range(COUNT):
            share_lock.acquire()  # 上锁
            shared_lock_num -= 1
            share_lock.release()  #释放锁
    
    
    def increment_without_lock():
        global shared_nolock_num
        for i in range(COUNT):
            shared_nolock_num+= 1
    
    
    def decrement_without_lock():
        global shared_nolock_num
        for i in range(COUNT):
            shared_nolock_num -= 1
    
    
    if __name__ == '__main__':
        t1 = threading.Thread(target=increment_with_lock)
        t2 = threading.Thread(target=decrement_with_lock)
        t3 = threading.Thread(target=increment_without_lock)
        t4 = threading.Thread(target=decrement_without_lock)
    
        t1.start()
        t2.start()
        t3.start()
        t4.start()
    
        t1.join()
        t2.join()
        t3.join()
        t4.join()
    
        print(shared_lock_num)
        print(shared_nolock_num)
    
        
    """ 可以看到 shared_lock_num 一直都是 0 shared_nolock_num 多运行几次，会出现不是0的情况，而且差别很大。 """

锁的状态和规则

锁有两种状态 : 上锁与未上锁  
两种方法可以操作锁: acquire()和release()

规则如下：  
如果状态为 未上锁， 调用acquire()会将状态改为`上锁`

如果状态为 上锁 ， 调用acquire()会`阻塞`

如果状态为 未上锁， 调用release()会导致RuntimeError`异常`

如果状态为 上锁 ， 调用release()会将状态改为 `未上锁`

**Lock和Rlock**

import threading  
    # Lock
    lock = threading.Lock() 
    lock.acquire()  
    lock.acquire()  #会阻塞，死锁。
    lock.release()  
    lock.release()  
    
    
    
    import threading
    # RLock
    rLock = threading.RLock() 
    rLock.acquire()  
    rLock.acquire() #在同一线程内，程序不会堵塞。 
    rLock.release()  
    rLock.release()

# **使用信号量实现线程同步** #

# coding: utf-8
    import threading
    import time
    import random
    
    semaphore = threading.Semaphore(0)
    
    def consumer():
        print("Consumer is waiting.")
        semaphore.acquire()
        print("Consumer notify: Consumed item number %s" %item)
    
    def producer():
        global item
        time.sleep(2)
        item = random.randint(0, 100)
        print("Producer notify: Produced item number %s" %item)
        semaphore.release()
    
    if __name__ == "__main__":
        for i in range(0, 5):
            t1 = threading.Thread(target=producer)
            t2 = threading.Thread(target=consumer)
            t1.start()
            t2.start()
            t1.join()
            t2.join()
        print("Program terminated")

讲解
    sem = threading.Semaphore(0)
    # threading.Semaphore(3) 初始值还可以设置为3，初始小于0会报错
    # 创建了一个信号量的对象，它有2个方法
    sem.acquire()和 sem.release()
    sem.acquire() # 会将值 -1 ，如果当前是0，会阻塞住
    sem.release() # 会将当前值 +1

# 使用条件 实现线程同步 #

import threading
    
    class XiaoAi(threading.Thread):
        def __init__(self, cond):
            super().__init__(name="小爱同学")
            self.cond = cond
    
        def run(self):
            with self.cond:
                self.cond.wait()
                print("{} : 在 ".format(self.name))  # 第二句
                self.cond.notify()
    
                self.cond.wait()
                print("{} : 好啊 ".format(self.name))
                self.cond.notify()
    
                self.cond.wait()
                print("{} : 君住长江尾 ".format(self.name))
                self.cond.notify()
    
                self.cond.wait()
                print("{} : 共饮长江水 ".format(self.name))
                self.cond.notify()
    
                self.cond.wait()
                print("{} : 此恨何时已 ".format(self.name))
                self.cond.notify()
    
                self.cond.wait()
                print("{} : 定不负相思意 ".format(self.name))
                self.cond.notify()
    
    class TianMao(threading.Thread):
        def __init__(self, cond):
            super().__init__(name="天猫精灵")
            self.cond = cond
    
        def run(self):
            with self.cond:
                print("{} : 小爱同学 ".format(self.name))   # 第一句 1
                self.cond.notify()
                self.cond.wait()
    
                print("{} : 我们来对古诗吧 ".format(self.name)) # 3
                self.cond.notify()
                self.cond.wait()
    
                print("{} : 我住长江头 ".format(self.name)) # 5
                self.cond.notify()
                self.cond.wait()
    
                print("{} : 日日思君不见君 ".format(self.name)) #7
                self.cond.notify()
                self.cond.wait()
    
                print("{} : 此水几时休 ".format(self.name)) #9
                self.cond.notify()
                self.cond.wait()
    
                print("{} : 只愿君心似我心 ".format(self.name)) # 11
                self.cond.notify()
                self.cond.wait()
    
    
    
    if __name__ == "__main__":
        cond = threading.Condition()
        xiaoai = XiaoAi(cond)
        tianmao = TianMao(cond)
        xiaoai.start()
        tianmao.start()

注意事项
    1.需要将 cond传递到线程内。
    2.建议使用 with self.cond: 或者 子线程开始self.cond.acquire() 结束时调用self.cond.release()
    3. self.cond.notify() # 发出通知
       self.cond.wait()   # 阻塞，等待cond.notify继续执行

# 使用事件实现线程同步 #

""" 同上面条件类似，代码略 """
    from threading import Event
    event = Event() # 可以将event传入到 子线程中去。
    
    event.set()   # 会将标志设置为 True
    event.clear() # 会将标志重置为 False
    event.wait()  # 会一直阻塞住，知道标志位True才向下执行

# 使用队列实现 线程间通信 #

from queue import Queue
    # 设置最大值
    q = Queue(maxsize=1000)
    # 将q当参数传入
    
    # 放入
    q.put(obj) # block=True,timeout=None 、 如果block=False
    # 如果为空，会阻塞到这里，q是线程安全的。
    q.get()
    
    q.qsize()#长度
    q.empty()#判断是否为空
    q.full()#判断是否满
    
    # 异步的方法
    put_nowait()
    get_nowait()
    
    q.task_done() # 会取消join阻塞
    q.join() # 会一直阻塞住，如果想退出，必须在某个地方使用task_done方法

# 以前的笔记 #

python多进程多线程的使用

[https://blog.csdn.net/sunt2018/article/details/88725851][https_blog.csdn.net_sunt2018_article_details_88725851]

[https_blog.csdn.net_sunt2018_article_details_88725851]: https://blog.csdn.net/sunt2018/article/details/88725851

猜你喜欢

最长无重复子串
写技术博客的一些心得分享
Java 多线程（七）：线程池
Java 多线程（五）：锁（三）
Java 多线程（四）：锁（二）
Java 多线程（三）：锁（一）
Java 多线程（二）：并发编程的三大特性
线性时间非比较类排序
Java 多线程（一）：基础
合并k个已排序的链表
HDFS 高可用分布式环境搭建
合并两个有序数组
连续子数组的最大和
HDFS 分布式环境搭建
容器盛水问题
大数加法
HDFS 伪分布式环境搭建
设计LRU缓存结构
两数之和
使用单调栈来解决的一些问题

zl程序教程

当前栏目

python线程回顾

相关文章