when invoked on an unlocked lock, a :exc:`ValueError` is raised.
+ .. method:: locked()
+
+ Return a boolean indicating whether this object is locked right now.
+
+ .. versionadded:: next
+
+
.. class:: RLock()
A recursive lock object: a close analog of :class:`threading.RLock`. A
differs from the implemented behavior in :meth:`threading.RLock.release`.
+ .. method:: locked()
+
+ Return a boolean indicating whether this object is locked right now.
+
+ .. versionadded:: next
+
+
.. class:: Semaphore([value])
A semaphore object: a close analog of :class:`threading.Semaphore`.
There is no return value.
+ .. method:: locked()
+
+ Return a boolean indicating whether this object is locked right now.
+
+ .. versionadded:: next
+
+
.. _condition-objects:
Condition Objects
Release the underlying lock. This method calls the corresponding method on
the underlying lock; there is no return value.
+ .. method:: locked()
+
+ Return a boolean indicating whether this object is locked right now.
+
+ .. versionadded:: next
+
.. method:: wait(timeout=None)
Wait until notified or until a timeout occurs. If the calling thread has
self.waiters.pop()
self.wakeup.release()
+ def locked(self):
+ return bool(self.count)
+
def __repr__(self):
return f'_ModuleLock({self.name!r}) at {id(self)}'
class AcquirerProxy(BaseProxy):
- _exposed_ = ('acquire', 'release')
+ _exposed_ = ('acquire', 'release', 'locked')
def acquire(self, blocking=True, timeout=None):
args = (blocking,) if timeout is None else (blocking, timeout)
return self._callmethod('acquire', args)
def release(self):
return self._callmethod('release')
+ def locked(self):
+ return self._callmethod('locked')
def __enter__(self):
return self._callmethod('acquire')
def __exit__(self, exc_type, exc_val, exc_tb):
class ConditionProxy(AcquirerProxy):
- _exposed_ = ('acquire', 'release', 'wait', 'notify', 'notify_all')
+ _exposed_ = ('acquire', 'release', 'locked', 'wait', 'notify', 'notify_all')
def wait(self, timeout=None):
return self._callmethod('wait', (timeout,))
def notify(self, n=1):
self.acquire = self._semlock.acquire
self.release = self._semlock.release
+ def locked(self):
+ return self._semlock._count() != 0
+
def __enter__(self):
return self._semlock.__enter__()
def test_lock(self):
lock = self.Lock()
self.assertEqual(lock.acquire(), True)
+ self.assertTrue(lock.locked())
self.assertEqual(lock.acquire(False), False)
self.assertEqual(lock.release(), None)
+ self.assertFalse(lock.locked())
self.assertRaises((ValueError, threading.ThreadError), lock.release)
@staticmethod
def test_rlock(self):
lock = self.RLock()
self.assertEqual(lock.acquire(), True)
+ self.assertTrue(lock.locked())
self.assertEqual(lock.acquire(), True)
self.assertEqual(lock.acquire(), True)
self.assertEqual(lock.release(), None)
+ self.assertTrue(lock.locked())
self.assertEqual(lock.release(), None)
self.assertEqual(lock.release(), None)
+ self.assertFalse(lock.locked())
self.assertRaises((AssertionError, RuntimeError), lock.release)
def test_lock_context(self):
- with self.Lock():
- pass
+ with self.Lock() as locked:
+ self.assertTrue(locked)
+
+ def test_rlock_context(self):
+ with self.RLock() as locked:
+ self.assertTrue(locked)
class _TestSemaphore(BaseTestCase):
@classmethod
def _test_lock(cls, obj):
obj.acquire()
+ obj.locked()
def test_lock(self, lname="Lock"):
o = getattr(self.manager, lname)()
def _test_rlock(cls, obj):
obj.acquire()
obj.release()
+ obj.locked()
- def test_rlock(self, lname="Lock"):
+ def test_rlock(self, lname="RLock"):
o = getattr(self.manager, lname)()
self.run_worker(self._test_rlock, o)
lock.release()
self.assertRaises(RuntimeError, lock.release)
+ def test_locked(self):
+ lock = self.locktype()
+ self.assertFalse(lock.locked())
+ lock.acquire()
+ self.assertTrue(lock.locked())
+ lock.acquire()
+ self.assertTrue(lock.locked())
+ lock.release()
+ self.assertTrue(lock.locked())
+ lock.release()
+ self.assertFalse(lock.locked())
+
def test_release_save_unacquired(self):
# Cannot _release_save an unacquired lock
lock = self.locktype()
def __exit__(self, t, v, tb):
self.release()
+ def locked(self):
+ """Return whether this object is locked."""
+ return self._count > 0
+
# Internal methods used by condition variables
def _acquire_restore(self, state):
if lock is None:
lock = RLock()
self._lock = lock
- # Export the lock's acquire() and release() methods
+ # Export the lock's acquire(), release(), and locked() methods
self.acquire = lock.acquire
self.release = lock.release
+ self.locked = lock.locked
# If the lock defines _release_save() and/or _acquire_restore(),
# these override the default implementations (which just call
# release() and acquire() on the lock). Ditto for _is_owned().
--- /dev/null
+Add :meth:`threading.RLock.locked`,
+:meth:`multiprocessing.Lock.locked`,
+:meth:`multiprocessing.RLock.locked`,
+and allow :meth:`multiprocessing.managers.SyncManager.Lock` and
+:meth:`multiprocessing.managers.SyncManager.RLock` to proxy ``locked()`` call.
\n\
Release the lock.");
+static PyObject *
+rlock_locked(PyObject *op, PyObject *Py_UNUSED(ignored))
+{
+ rlockobject *self = rlockobject_CAST(op);
+ int is_locked = _PyRecursiveMutex_IsLockedByCurrentThread(&self->lock);
+ return PyBool_FromLong(is_locked);
+}
+
+PyDoc_STRVAR(rlock_locked_doc,
+"locked()\n\
+\n\
+Return a boolean indicating whether this object is locked right now.");
+
static PyObject *
rlock_acquire_restore(PyObject *op, PyObject *args)
{
METH_VARARGS | METH_KEYWORDS, rlock_acquire_doc},
{"release", rlock_release,
METH_NOARGS, rlock_release_doc},
+ {"locked", rlock_locked,
+ METH_NOARGS, rlock_locked_doc},
{"_is_owned", rlock_is_owned,
METH_NOARGS, rlock_is_owned_doc},
{"_acquire_restore", rlock_acquire_restore,
projects / thirdparty / Python / cpython.git / commitdiff
