python 多线程（二）

系统管理员 2022-05-21 07:19 197阅读 0赞

# 共享变量 #

- 概念： 当多个线程同时访问一个变量的时候，会产生共享变量的问题

# 不启用多线程，正常执行结果
    import threading
    
    sum = 0
    loopSum = 100000
    
    
    def myAdd():
        global sum, loopSum
        for i in range(1, loopSum):
            sum += 1
    
    
    def myMinu():
        global sum, loopSum
        for i in range(1, loopSum):
            sum -= 1
    
    
    if __name__ == '__main__':
        myAdd()
        print(sum)
        myMinu()
        print(sum)

99999
    0

# 多线程执行两个方法
    
    import threading
    
    sum = 0
    loopSum = 100000
    
    
    def myAdd():
        global sum, loopSum
        for i in range(1, loopSum):
            sum += 1
    
    
    def myMinu():
        global sum, loopSum
        for i in range(1, loopSum):
            sum -= 1
    
    
    if __name__ == '__main__':
        print("Stating ....{0}".format(sum))
        # 启用多线程实例，查看执行结果
        t1 = threading.Thread(target=myAdd, args=())
        t2 = threading.Thread(target=myMinu, args=())
        t1.start()
        t2.start()
        t1.join()
        t2.join()
        print("Done .... {0}".format(sum))

Stating ....0
    Done .... -31331

*  解决方案： 锁，  
    
    
     *  锁（LOCK）:  
        
        
         *  是一个标志，表示一个线程在占用一些资源
         *  使用方法：  
            
            
             *  上锁
             *  使用共享资源
             *  释放锁
         *  琐谁：  
            
            
             *  那个资源需要多线程共享，锁那个
         *  理解锁：  
            
            
             *  锁其实是一个令牌，并且这个令牌只有一个，访问共享资源时需要去申请这个令牌，只有申请到令牌的线程才能操作共享资源，操作完成后，需将令牌归还

import threading
    
    sum = 0
    loopSum = 100000
    # 定义锁
    lock = threading.Lock()
    
    
    def myAdd():
        global sum, loopSum
        for i in range(1, loopSum):
            # 加锁，申请锁
            lock.acquire()
            sum += 1
            # 释放锁
            lock.release()
    
    
    def myMinu():
        global sum, loopSum
        for i in range(1, loopSum):
            # 加锁，申请锁
            lock.acquire()
            sum -= 1
            # 释放锁
            lock.release()
    
    
    if __name__ == '__main__':
        print("Stating ....{0}".format(sum))
        # 启用多线程实例，查看执行结果
        t1 = threading.Thread(target=myAdd, args=())
        t2 = threading.Thread(target=myMinu, args=())
        t1.start()
        t2.start()
        t1.join()
        t2.join()
        print("Done .... {0}".format(sum))

Stating ....0
    Done .... 0

*  线程安全问题：  
    \- 如果一个资源/变量，它对于多线程来讲，不用加锁也不会引起任何问题，则称为线程安全。  
    \- 线程不安全变量类型：list,set,dict  
    \- 线程安全变量类型：queue  
    
    
     *  生产者消费者问题  
        
        
         *  一个模型，用来搭建消息队列
         *  queue 是一个用来存放变量的数据结构，特点是先进先出，内部元素排队，可以理解成一个特殊的list

import threading
    import time
    import queue
    
    
    # python2
    # from Queue import Queue
    
    # python3
    class Produer(threading.Thread):
        def run(self):
            global queue
            count = 0
            while True:
                if queue.qsize() < 1000:
                    for i in range(100):
                        count = count + 1
                        msg = "生成产品" + str(count)
                        queue.put(msg)
                        print(msg)
                time.sleep(0.5)
    
    
    class Consumer(threading.Thread):
        def run(self):
            global queue
            while True:
                if queue.qsize() > 100:
                    for i in range(3):
                        msg = self.name + "消费了" + queue.get()
                        print(msg)
                time.sleep(1)
    
    
    if __name__ == "__main__":
        queue = queue.Queue()
        for i in range(500):
            queue.put("初始产品："+str(i))
        for i in range(2):
            p = Produer()
            p.start()
        for i in range(5):
            c = Consumer()
            c.start()

# 死锁 #

import threading
    import time
    
    lock_1 = threading.Lock()
    lock_2 = threading.Lock()
    
    def funca():
        print("A 函数启动....")
        print("A 申请了锁1...")
        lock_1.acquire()
        print("A 等待申请锁2...")
        time.sleep(2)
        lock_2.acquire()
        print("A 释放了锁2...")
        lock_2.release()
        print("A 释放了锁1")
        lock_1.release()
        print("A 函数执行结束...")
    
    
    def funcb():
        print("B 函数启动...")
        print("B 函数申请锁2...")
        lock_2.acquire()
        print("B 函数等待申请锁1...")
        time.sleep(4)
        print("B 函数申请申请锁1...")
        lock_1.acquire()
    
        print("B 函数释放锁1...")
        lock_1.release()
        print("B 函数释放锁2...")
        lock_2.release()
        print("B 函数执行结束...")
    
    
    if __name__ == '__main__':
        t1 = threading.Thread(target=funca, args=())
        t2 = threading.Thread(target=funcb, args=())
        t1.start()
        t2.start()
        t1.join()
        t2.join()

*  锁的等待时间

import threading
    import time
    
    lock_1 = threading.Lock()
    lock_2 = threading.Lock()
    
    
    def funca():
        print("A 函数启动....")
        print("A 申请了锁1...")
        lock_1.acquire(timeout=4)
        print("A 等待申请锁2...")
        time.sleep(2)
        res = lock_2.acquire(timeout=2)
        if res:
            print("A 得到了锁2...")
            lock_2.release()
            print("A 释放了锁2...")
        else:
            print("A 没有申请到锁2...")
        print("A 释放了锁1")
        lock_1.release()
        print("A 函数执行结束...")
    
    
    def funcb():
        print("B 函数启动...")
        print("B 函数申请锁2...")
        lock_2.acquire()
        print("B 函数等待申请锁1...")
        time.sleep(4)
        print("B 函数申请申请锁1...")
        lock_1.acquire()
    
        print("B 函数释放锁1...")
        lock_1.release()
        print("B 函数释放锁2...")
        lock_2.release()
        print("B 函数执行结束...")
    
    
    if __name__ == '__main__':
        t1 = threading.Thread(target=funca, args=())
        t2 = threading.Thread(target=funcb, args=())
        t1.start()
        t2.start()
        t1.join()
        t2.join()

*  semphore  
    \- 允许一个资源最多由几个线程同时使用

import threading
    import time
    
    # 参数定义同一个资源最多几个线程同时使用
    semphore = threading.Semaphore(3)
    
    
    def func():
        if semphore.acquire():
            for i in range(5):
                print(threading.currentThread().getName() + "get semphore")
                time.sleep(15)
                semphore.release()
                print(threading.currentThread().getName() + "release semphore")
    
    
    for i in range(8):
        t1 = threading.Thread(target=func)
        t1.start()

*  threading.Timer  
    
    
     *  Timer : 是利用多线程在指定时间后启动一个功能

import threading
    import time
    
    def func():
        print("I am body")
        time.sleep(4)
        print("bay")
    
    
    if __name__ == "__main__":
        t1 = threading.Timer(6, func)
        t1.start()
        i = 0
        while i < 6:
            print("{0}..........".format(i))
            time.sleep(2)
            i += 1

0..........
    1..........
    2..........
    I am body
    3..........
    4..........
    bay
    5..........

*  可重入锁：  
    \- 可以被一个线程多次申请  
    \- 主要解决递归调用的时候，需要申请锁的情况（递归调用多次申请锁）

import threading
    import time
    
    lock = threading.RLock()
    
    
    class MyThread(threading.Thread):
        def run(self):
            global num
            time.sleep(1)
    
            if lock.acquire(1):
                num += 1
                msg = self.name + 'set num to ' + str(num)
                print(msg)
                lock.acquire()
                lock.release()
                lock.release()
    
    
    num = 0
    
    def mytherad():
        for i in range(8):
            t1 = MyThread()
            t1.start()
    
    
    if __name__ == '__main__':
        mytherad()

Thread-77set num to 1
    Thread-78set num to 2
    Thread-79set num to 3
    Thread-80set num to 4
    Thread-81set num to 5
    Thread-82set num to 6
    Thread-83set num to 7
    Thread-84set num to 8