Python 多线程 （02）

共享变量

当多个线程同时访问一个变量的时候，会产生共享变量的问题。
问题解决：锁（是一个标志，表示一个线程正在占用一些资源），信号灯
锁的使用方法：上锁，使用共享资源，放心的用，取消锁，释放锁。
案例1

import threading
sum=0
loopsum=1000000
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('staring.....{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))

线程安全问题

如果一个资源/变量，他对于多线程来讲，不用枷锁也不会引起任何问题，则称为线程安全。

生产者消费者问题（模型）

可以用来待见消息队列

案例2

import threading
import time
#from queue import Queue
import queue
class Producer(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(0.5)
if __name__=='__main__':
    queue=queue.Queue()
    for i in range(500):
        queue.put('初始产品'+str(i))
    for i in range(2):
        p=Producer()
        p.start()
    for i in range(5):
        c=Consumer()
        c.start()

semphore

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

案例3

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

Timer

使用方法在一个指定的秒数之后调用方法-threading.Timer(sec,func)

可重入锁

一个锁可以被一个线程多次申请
主要解决递归调用的时候，需要申请锁的情况
mutex=threading.RLock()