how to know python semaphore value

Question

i use threading.semaphore in my code and i wonder if there is way i can use code like This

if(sema.acquire()!=True):
   #do Somthing

i want to use this piece of code in loop so i need to get if semaphore is taken or it's released or use code like this in my code

if(sema.get_value!=1):
  #do something

i read this doc but i can't find my answer https://docs.python.org/3/library/threading.html

Solution 1

Semaphores are designed around the idea, that threads just grab one, and wait until it becomes available, because it's not really predictable in which order they wil be acquired.

The counter is not part of the abstraction called 'Semaphore'. It is not guaranteed, that your access to the semaphore counter is atomic. If you could peek into the counter, and another thread acquires the semaphore before you do anything with it, what should you do?

Without breaking your code you can't know the value.

Solution 2

The other answers are correct but for whom reaches this page in order to actually know how to get the semaphore value you can do it like this:

>>> from threading import Semaphore
>>> sem = Semaphore(5)
>>> sem._Semaphore__value
5
>>> sem.acquire()
True
>>> sem._Semaphore__value
4

Be aware that the _Semaphore__ that prefixes the name of the variable value means that this is an implementation detail. Do not write production code based on this variable as it may change in the future. Moreover do not try to edit the value manually, otherwise.. any bad thing can happen.

Solution 3

In python3.6, you can get is like this:

from threading import Semaphore
sem = Semaphore(5)
print(sem._value)

This value is useful for debug

Solution 4

You can use

if(sema.acquire(blocking=False)):
    # Do something with lock taken
    sema.release()
else:
    # Do something in case when lock is taken by other

Such mechanism is useful for avoiding deadlocks in complex cases, but also may be used for other purposes.

More information on acquire function

Solution 5

You might consider using a threading.Condition() instead. e.g:

import threading

class ConditionalSemaphore(object):
    def __init__(self, max_count):
        self._count = 0
        self._max_count = max_count
        self._lock = threading.Condition()

    @property
    def count(self):
        with self._lock:
            return self._count

    def acquire(self):
        with self._lock:
            while self._count >= self._max_count:
                self._lock.wait()
            self._count += 1

    def release(self):
        with self._lock:
            self._count -= 1
            self._lock.notify()

View more solutions