Python高阶之多线程锁机制

'''
1.多进程的优势：为了同步完成多项任务，通过提高资源使用效率来提高系统的效率。
2.查看线程数：threading.enumerate()函数便可以看到当前线程的数量。
3.查看当前线程的名字:threading.current_thread()可以看到当前线程的信息。
4.类可以继承 threading.Thread
'''
# import threading
# import time
#
# class CodingThread(threading.Thread):
#     def run(self):
#         for x in range(3):
#             print('正在写脚本:%s'%threading.current_thread())
#             time.sleep(1)
#
# class ModelThread(threading.Thread):
#     def run(self):
#         for x in range(3):
#             print('正在创建模型：%s'%threading.current_thread())
#             time.sleep(1)
#
# # 主线程入口
# def main():
#     t1 = CodingThread()
#     t2 = ModelThread()
#
#     t1.start()
#     t2.start()
#
#
# if __name__ == '__main__':
#     main()

# 多线程共享全局变量的问题：
'''
多线程都是在同一个进程中运行的。因此在进程中的全局变量所有线程都是可共享的。
这就造成了一个问题，因为线程执行的顺序是无序的。有可能会造成数据错误。
'''
# import threading

# VALUES = 0
# 全局变量使用线程时,避免数据不出现乱序，则加上锁
# gLock = threading.Lock()
#
# def get_ticket():
#     global VALUES
#     # 加锁
#     gLock.acquire()
#     for x in range(100000):
#         VALUES += 1
#     # 解锁
#     gLock.release()
#     print('VALUES:%d' % VALUES)
#
# def main():
#     for x in range(3):
#         t = threading.Thread(target=get_ticket)
#         t.start()

# 应该打印出来是: 100000,200000,300000
# 实际打印出来是: 100000,124976,224976
# 所有使用到threading.Lock
'''
加上锁后返回的值：
VALUES:100000
VALUES:200000
VALUES:300000
'''

# if __name__ == '__main__':
#     main()

# Lock版本生产者和消费者模式：
'''
生产者和消费者模式是多线程开发中经常见到的一种模式。
生产者的线程专门用来生产一些数据，然后存放到一个中间的变量中。
消费者再从这个中间的变量中取出数据进行消费。
但是因为要使用中间变量，中间变量经常是一些全局变量，因此需要使用锁来保证数据完整性。
使用threading.Lock锁实现的“生产者与消费者模式”的一个例子：
'''
import threading
import random
import time

gMoney = 1000
glock = threading.Lock()
# 记录生产者生产的次数，达到10次就不再生产
gtime = 0

# 生产者
class Producer(threading.Thread):
    def run(self):
        global gMoney
        global gtime
        while True:
            Money = random.randint(100,1000)
            glock.acquire()
            if gtime >= 10:
                # 解锁返回
                glock.release()
                break
            gMoney += Money
            print('%s存入了%d元钱，还剩%d元钱'%(threading.current_thread(),Money,gMoney))
            time.sleep(0.5)
            gtime += 1
            glock.release()

# 消费者
class Consumer(threading.Thread):
    def run(self):
        global gMoney
        global gtime
        while True:
            Money = random.randint(100, 1000)
            glock.acquire()
            if gMoney > Money:
                gMoney -= Money
                print('%s消费了%d元钱，还剩%d元钱' % (threading.current_thread(), Money, gMoney))
                time.sleep(0.5)
            else:
                # 如果钱不够了，有可能是已经超过了次数，这时候就判断一下
                if gtime >= 10:
                    glock.release()
                    break
                print('%s消费了%d元钱，还剩%d元钱，不足！！！' % (threading.current_thread(), Money, gMoney))
            glock.release()

def main():
    for x in range(3):
        c1 = Consumer(name='消费者线程数%s'%x)
        c1.start()

    for x in range(5):
        p1 = Producer(name='生产者线程数%s'%x)
        p1.start()

if __name__ == '__main__':
    main()