python 多线程(二)

共享变量

- 概念: 当多个线程同时访问一个变量的时候,会产生共享变量的问题
# 不启用多线程,正常执行结果
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
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Julywhj

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值