Comment mettre en œuvre une Serrure avec un délai d'attente dans Python 2.7

Ma version thread-safe files d'attente http://docs.python.org/2/library/queue.html et leur mettre/trouver les méthodes qui prend en charge timeout.

Jusqu'à présent, fonctionne très bien, mais si quelqu'un peut faire un examen par les pairs sur elle, je serai reconnaissant.

"""
Thread-safe lock mechanism with timeout support module.
"""

from threading import ThreadError, current_thread
from Queue import Queue, Full, Empty


class TimeoutLock(object):
    """
    Thread-safe lock mechanism with timeout support.
    """

    def __init__(self, mutex=True):
        """
        Constructor.
        Mutex parameter specifies if the lock should behave like a Mutex, and
        thus use the concept of thread ownership.
        """
        self._queue = Queue(maxsize=1)
        self._owner = None
        self._mutex = mutex

    def acquire(self, timeout=0):
        """
        Acquire the lock.
        Returns True if the lock was succesfully acquired, False otherwise.

        Timeout:
        - < 0 : Wait forever.
        -   0 : No wait.
        - > 0 : Wait x seconds.
        """
        th = current_thread()
        try:
            self._queue.put(
                th, block=(timeout != 0),
                timeout=(None if timeout < 0 else timeout)
            )
        except Full:
            return False

        self._owner = th
        return True

    def release(self):
        """
        Release the lock.
        If the lock is configured as a Mutex, only the owner thread can release
        the lock. If another thread attempts to release the lock a
        ThreadException is raised.
        """
        th = current_thread()
        if self._mutex and th != self._owner:
            raise ThreadError('This lock isn\'t owned by this thread.')

        self._owner = None
        try:
            self._queue.get(False)
            return True
        except Empty:
            raise ThreadError('This lock was released already.')

Je doute que cela peut être fait.

Si vous souhaitez mettre en œuvre ce, sans aucune forme d'interrogation, alors vous avez besoin de l'OS à savoir que le thread est bloqué, et le système d'exploitation doit être conscient de l'attente, afin de débloquer le fil après un certain temps. Pour cela, les besoins de soutien existent déjà dans le système d'exploitation; vous ne pouvez pas mettre en œuvre ce à l'Python niveau.

(Vous pourriez avoir le thread bloqué au niveau de l'OS ou de niveau application, et de disposer d'un mécanisme par lequel il peut être réveillé par un thread différent, au moment approprié, mais alors vous avez besoin que les autres thread pour être efficace interrogation)

En général, vous n'avez pas vraiment délimité en attente/progrès de garantie de la serrure de toute façon, que votre fils devra attendre une surabondance de temps pour un changement de contexte à prendre place à l'avis qu'il a été débloqué. Donc à moins de mettre une limite supérieure sur le montant de contention du PROCESSEUR, vous n'allez pas être en mesure d'utiliser le délai d'attente pour frapper tout dur en temps réel des délais. Mais vous n'avez probablement pas besoin de cela, sinon vous ne rêverait pas de l'aide de verrous mis en œuvre en Python.

En raison de l'Python GIL (Global Interprète de Verrouillage), les bureaux de solutions à base ne sont probablement pas aussi inefficace ou mal illimitée que vous le pensez (en fonction de la façon dont ils sont mis en œuvre) (et en supposant que vous êtes en utilisant soit Disponible ou PyPy).

Il n'y a qu'un seul thread en cours d'exécution à un moment, et par définition, il y a un autre fil que vous souhaitez exécuter (celui qui détient le verrou vous êtes en attente pour). Le GIL est tenu pendant un certain temps par un seul thread à exécuter un tas de bytecode, puis a chuté et acquis de nouveau à donner à quelqu'un d'autre une chance à lui. Donc, si l'bloqué avec timeout thread est juste dans une boucle de vérification de l'heure et de les céder à d'autres threads, il ne fera que réveiller chaque tellement souvent quand il fait le GIL et puis presque immédiatement abandonner de nouveau à quelqu'un d'autre et de le bloquer sur le GIL de nouveau. Parce que ce fil ne pourrait jamais se réveiller quand elle reçoit un tour à la GIL de toute façon, il sera également le faire vérifier dès que possible après l'expiration du délai qu'il serait en mesure de reprendre l'exécution, même si le délai d'attente a été magiquement parfait.

La seule fois où ce sera la cause de beaucoup d'inefficience est si votre fil est bloqué en attente pour le lock-fil de maintien, qui est bloqué en attente pour quelque chose qui ne peut être causé par un autre Python fil (par exemple, bloqué sur IO), et il n'y a pas d'autres exécutable Python threads. Ensuite, votre bureau de vote délai d'attente va vraiment rester là vérification de l'heure à plusieurs reprises, ce qui pourrait être mauvais si vous vous attendez à cette situation de se produire pour de longues périodes de temps.

Bon, c'est déjà mise en œuvre dans python 3.2 ou ci-dessus:
https://docs.python.org/3/library/threading.html
Regardez pour l'enfilage.TIMEOUT_MAX

Mais j'ai amélioré sur le cas de test de plus de frans " version ... mais c'est déjà une perte de temps si vous êtes sur py3.2 ou au-dessus:

from unittest.mock import patch, Mock
import unittest
import os
import sys
import logging
import traceback
import threading
import time
from Util import ThreadingUtil
class ThreadingUtilTests(unittest.TestCase):
def setUp(self):
pass
def tearDown(self):
pass
# https://www.pythoncentral.io/pythons-time-sleep-pause-wait-sleep-stop-your-code/
def testTimeoutLock(self):
faulted = [False, False, False]
def locking_thread_fn(threadId, lock, duration, timeout):
try:
threadName = "Thread#" + str(threadId)
with ThreadingUtil.TimeoutLock(threadName, lock, timeout=timeout, raise_on_timeout=True):
print('%x: "%s" begins to work..' % (threading.get_ident(), threadName))
time.sleep(duration)
print('%x: "%s" finished' % (threading.get_ident(), threadName))
except:
faulted[threadId] = True
_lock = ThreadingUtil.TimeoutLock.lock()
_sleepDuration = [5, 10, 1]
_threads = []
for i in range(3):
_duration = _sleepDuration[i]
_timeout = 6
print("Wait duration (sec): " + str(_duration) + ", Timeout (sec): " + str(_timeout))
_worker = threading.Thread(
target=locking_thread_fn, 
args=(i, _lock, _duration, _timeout)
)
_threads.append(_worker)
for t in _threads: t.start()
for t in _threads: t.join()
self.assertEqual(faulted[0], False)
self.assertEqual(faulted[1], False)
self.assertEqual(faulted[2], True)

Maintenant, dans "Util" le dossier, j'ai "ThreadingUtil.py":

import time
import threading
# https://stackoverflow.com/questions/8392640/how-to-implement-a-lock-with-a-timeout-in-python-2-7
# https://docs.python.org/3.4/library/asyncio-sync.html#asyncio.Condition
# https://stackoverflow.com/questions/28664720/how-to-create-global-lock-semaphore-with-multiprocessing-pool-in-python
# https://hackernoon.com/synchronization-primitives-in-python-564f89fee732
class TimeoutLock(object):
''' taken from https://stackoverflow.com/a/8393033/1668622
'''
class lock:
def __init__(self):
self.owner = None
self.lock = threading.Lock()
self.cond = threading.Condition()
def _release(self):
self.owner = None
self.lock.release()
with self.cond:
self.cond.notify()
def __init__(self, owner, lock, timeout=1, raise_on_timeout=False):
self._owner = owner
self._lock = lock
self._timeout = timeout
self._raise_on_timeout = raise_on_timeout
# http://effbot.org/zone/python-with-statement.htm
def __enter__(self):
self.acquire()
return self
def __exit__(self, type, value, tb):
''' will only be called if __enter__ did not raise '''
self.release()
def acquire(self):
if self._raise_on_timeout:
if not self._waitLock():
raise RuntimeError('"%s" could not aquire lock within %d sec'
% (self._owner, self._timeout))
else:
while True:
if self._waitLock():
break
print('"%s" is waiting for "%s" and is getting bored...'
% (self._owner, self._lock.owner))
self._lock.owner = self._owner
def release(self):
self._lock._release()
def _waitLock(self):
with self._lock.cond:
_current_t = _start_t = time.time()
while _current_t < _start_t + self._timeout:
if self._lock.lock.acquire(False):
return True
else:
self._lock.cond.wait(self._timeout - _current_t + _start_t)
_current_t = time.time()
return False