[Python 多线程] Semaphore、BounedeSemaphore (十二)

 Semaphore

信号量，信号量对象内部维护一个倒计数器，每一次acquire都会减1，当acquire方法发现计数为0就阻塞请求的线程，直到其它线程对信号量release后，计数大于0，恢复阻塞的线程。

方法：

Semaphore(value=1)                            构造方法。value小于0，抛ValueError异常。默认为1。

acquire(blocking=True,timeout=None)  获取信号量，计数器减1，获取成功返回True。

release()                                               释放信号量，计数器加1。

计数器永远不会低于0，因为acquire的时候，发现是0，都会被阻塞。

 举例：

图书馆有三本书，三本都被借走(acquire)之后，其他人想看，就得等别人还回来(阻塞)，有人还回来(release)一本后，就有一个人可以拿到这本书，其他人仍然得等归还。

#Semaphore 信号量，借还
import threading,logging,time
DATEFMT="%H:%M:%S"
FORMAT = "[%(asctime)s]	 [%(threadName)s,%(thread)d] %(message)s"
logging.basicConfig(level=logging.INFO,format=FORMAT,datefmt=DATEFMT)

def work(s:threading.Semaphore):
    logging.info('in sub thread')
    logging.info(s.acquire())
    logging.info('sub thread oevr')

s = threading.Semaphore(3)
logging.info(s.acquire())
logging.info(s.acquire())
logging.info(s.acquire())

threading.Thread(target=work,args=(s,)).start()
time.sleep(2)

logging.info(s.acquire(False))  #不阻塞
logging.info((s.acquire(timeout=3))) #3秒超时会阻塞

logging.info('release')
s.release()


运行结果：
[08:48:43]	 [MainThread,8840] True
[08:48:43]	 [MainThread,8840] True
[08:48:43]	 [MainThread,8840] True
[08:48:43]	 [Thread-1,6212] in sub thread
[08:48:45]	 [MainThread,8840] False
[08:48:48]	 [MainThread,8840] False
[08:48:48]	 [MainThread,8840] release
[08:48:48]	 [Thread-1,6212] True
[08:48:48]	 [Thread-1,6212] sub thread oevr

　　这个例子只起了一个线程，如果多起几个，当release还回来的数小于阻塞的线程数时，程序就会一直处于阻塞状态，直到全部relase。

 应用举例：

因为资源有限，且开启一个连接成本高，所以，使用连接池。

一个简单的连接池(例子)：

连接池应该有容量(value总数)，也应该工厂方法可以获取连接，能够把不用的连接归还，供其他使用者使用。

#一个简单的连接池
import threading,logging,time
DATEFMT="%H:%M:%S"
FORMAT = "[%(asctime)s]	 [%(threadName)s,%(thread)d] %(message)s"
logging.basicConfig(level=logging.INFO,format=FORMAT,datefmt=DATEFMT)


class Conn:
    def __init__(self,name):
        self.name = name

class Pool:
    def __init__(self,count=3):
        self.count = count
        #连接池容器
        self.pool = [self._connect('conn-{}'.format(x)) for x in range(self.count)]


    def _connect(self,conn_name):
        return Conn(conn_name)

    def get_conn(self):
        # if len(self.pool) > 0:
        return self.pool.pop() #从尾部弹出一个

    def return_conn(self,conn:Conn):
        self.pool.append(conn)

pool = Pool(3)
print(pool.pool)
pool.get_conn()
pool.get_conn()
pool.get_conn()
pool.get_conn() #第4个

print('End Main')

运行结果：
[<__main__.Conn object at 0x00000211BBEBC160>, <__main__.Conn object at 0x00000211BBEBC1D0>, <__main__.Conn object at 0x00000211BBEBC240>]
Traceback (most recent call last):
  File "C:/python/test.py", line 34, in <module>
    pool.get_conn()
  File "C:/python/test.py", line 24, in get_conn
    return self.pool.pop() #从尾部弹出一个
IndexError: pop from empty list

　　当连接池中已经没有可用连接时，再获取就会抛异常 IndexError：pop from empty list。

那就加个判断，只在池中连接数量大于0的时候才可以获取连接：

#修改get_conn函数
    def get_conn(self):
        if len(self.pool) > 0:
            return self.pool.pop() #从尾部弹出一个

　　这样在连接池为空时，就不会抛异常了。

这个连接池的例子如果使用多线程，这个get_conn()方法是线程不安全的，有可能其它线程看到池中还有一个连接，正准备获取，其它线程也看到了，也准备获取连接，就会抛异常。再或者，都在向池中加连接的时候，也可能会多加。

这个问题可以用锁Lock来解决， 在获取连接和加连接时，加锁解锁；也可以使用semaphore信号量来解决。

使用信号量对上例进行修改：

#使用semaphore信号量修改连接池
import threading,logging,time,random
DATEFMT="%H:%M:%S"
FORMAT = "[%(asctime)s]	 [%(threadName)s,%(thread)d] %(message)s"
logging.basicConfig(level=logging.INFO,format=FORMAT,datefmt=DATEFMT)


class Conn:
    def __init__(self,name):
        self.name = name

    def __repr__(self):
        return self.name

class Pool:
    def __init__(self,count=3):
        self.count = count
        #连接池容器
        self.pool = [self._connect('conn-{}'.format(x)) for x in range(self.count)]
        self.semaphore = threading.Semaphore(self.count)


    def _connect(self,conn_name):
        #返回一个连接名
        return Conn(conn_name)

    def get_conn(self):
        #从池中拿走一个连接
        # if len(self.pool) > 0:
        self.semaphore.acquire(timeout=5) #-1,获取连接,最大5秒超时时间,与后面随机秒数相对应
        data = self.pool.pop() #从尾部弹出一个
        return data

    def return_conn(self,conn:Conn):
        #向池中添加一个连接
        self.pool.append(conn)
        self.semaphore.release()  # 先加入池中再信号量+1
        return len(self.pool)


pool = Pool(3)

def worker(pool:Pool):
    conn = pool.get_conn()
    logging.info(conn)
    #模拟使用了资源一段时间(随机1-4秒),然后归还
    threading.Event().wait(timeout=random.randint(1,4))
    pool.return_conn(conn)

for i in range(6):
    threading.Thread(target=worker,name="worker-{}".format(i),args=(pool,)).start()

print('End Main')

运行结果：
[10:34:12]	 [worker-0,5264] conn-2
[10:34:12]	 [worker-1,7420] conn-1
[10:34:12]	 [worker-2,2612] conn-0
End Main
[10:34:13]	 [worker-3,3972] conn-1 #归还以后又可以获取连接
[10:34:14]	 [worker-4,8172] conn-2
[10:34:15]	 [worker-5,11192] conn-1

　　上例中模拟获取连接以后使用了1-4秒钟，没有拿到资源的最多阻塞5秒钟，当连接使用结束归还后，阻塞的线程就又重新获取到连接。

问题：

1) 没有使用信号量就release的情况：

import threading

s = threading.Semaphore(3)
print(s.__dict__)




def work(s:threading.Semaphore):
    s.release()

for i in range(3):
    threading.Thread(target=work,args=(s,)).start()
    print(s.__dict__)

运行结果：
{'_cond': <Condition(<unlocked _thread.lock object at 0x00000219202973A0>, 0)>, '_value': 3}
{'_cond': <Condition(<unlocked _thread.lock object at 0x00000219202973A0>, 0)>, '_value': 2}
{'_cond': <Condition(<unlocked _thread.lock object at 0x00000219202973A0>, 0)>, '_value': 3}
{'_cond': <Condition(<unlocked _thread.lock object at 0x00000219202973A0>, 0)>, '_value': 4}
{'_cond': <Condition(<unlocked _thread.lock object at 0x00000219202973A0>, 0)>, '_value': 5}

　　没有acquire信号量时，就release的情况，结果导致了信号量的内置倒计数器的值增加，这样就超出了最大值。

解决办法：

使用BoundedSemaphore类：

BoundedSemaphore，继承自Semaphore类。边界绑定，有界的信号量，不允许使用release超过初始值的范围，否则，抛ValueError异常。

#BoundedSemaphore边界绑定
import threading

s = threading.BoundedSemaphore(3)
print(s.__dict__)

s.acquire()
print(s.__dict__)

def work(s:threading.BoundedSemaphore):
    s.release()

for i in range(3):
    threading.Thread(target=work,args=(s,)).start()
    print(s.__dict__)

运行结果：
{'_value': 3, '_cond': <Condition(<unlocked _thread.lock object at 0x000001A42DDF73A0>, 0)>, '_initial_value': 3}
{'_value': 2, '_cond': <Condition(<unlocked _thread.lock object at 0x000001A42DDF73A0>, 0)>, '_initial_value': 3}
{'_value': 3, '_cond': <Condition(<unlocked _thread.lock object at 0x000001A42DDF73A0>, 0)>, '_initial_value': 3}
{'_value': 3, '_cond': <Condition(<unlocked _thread.lock object at 0x000001A42DDF73A0>, 0)>, '_initial_value': 3}
{'_value': 3, '_cond': <Condition(<unlocked _thread.lock object at 0x000001A42DDF73A0>, 0)>, '_initial_value': 3}
Exception in thread Thread-2:
Traceback (most recent call last):
  File "C:/python/test.py", line 11, in work
    s.release()
ValueError: Semaphore released too many times

　　使用BoundedSemaphore就可以控制不会多归还。