def __init__(self, adapter=get_adapter('simple')(dict()), inactivity_timeout=10, client_timeout=5, lock_free=False, no_copy=True): self._thread = None self._frame = None self._history = [] self._history_tape = [] self._is_stopped = False self._manager = None self._input_adapter = adapter self._inactivity_timeout = inactivity_timeout self._last_access = 0 self._lock_free = lock_free self._no_copy = no_copy if not lock_free: self._lock = rwlock.RWLockFair() self._event_handler = ClientEventHandler( inactivity_timeout=client_timeout)
def __init__(self, *args, **kwargs): super(PopoRecordManager, self).__init__(*args, **kwargs) self._all_sequence_records = {} self._all_sequence_max = {} self._all_tracking_records = {} self._all_tracking_max = {} self._all_notification_records = {} self._all_notification_max = {} self._rw_lock = rwlock.RWLockFair()
def setUp(self): """Test setup.""" self.v_value = 0 from readerwriterlock import rwlock self.c_rwlock_instance = [ rwlock.RWLockRead(), rwlock.RWLockWrite(), rwlock.RWLockFair() ]
def __init__(self, model, model_file, workspace_dir = None): self.model = model self.model_file = model_file self.workspace_dir = workspace_dir if workspace_dir else '_workspace_' self.ready = False self.learn_dir = self.workspace_dir + '/learn' self.archive_dir = self.workspace_dir + '/archive' print('Using workspace directory {:s}'.format(self.workspace_dir), flush=True) self.gateway = None self.lock = rwlock.RWLockFair()
def __init__(self, *args, **kwargs): super(_QTasks, self).__init__(name="QTasks") self._abort = Event() self._job_queue = Queue() self._job_states = {} self._cancellation_events = {} lock_generator = rwlock.RWLockFair() self._r_lock = lock_generator.gen_rlock() self._w_lock = lock_generator.gen_wlock() self._worker_thread = Thread(target=self._job_handler, daemon=True)
def __init__(self, agent, name): self._agent = agent self.name = name self.initial_x_range = [0, 10] self.initial_y_range = [0, 10] self.page_list = [[2, INFINITY], [INFINITY, INFINITY]] self._page_list_lock = threading.Lock() self.min_page_idx = 0 default_node = ChartNode(self, shape="circle") default_node.idx = 0 self.nodes = [default_node] self._nodes_dict = {hash(default_node): default_node} self._nodes_lock = rwlock.RWLockFair() self.classes = {} self._classes_by_bidegree = {} self.edges = {} self._batched_messages = [] self._batched_messages_lock = threading.Lock()
def acquire(self, pkey: int, lock_type: str): """ :param primary key, lock_type "r"/"w" :return: Generated locks by corresponding rids None if failed to acquire """ if pkey not in self.locks_map: self.locks_map[pkey] = rwlock.RWLockFair() # Create a new RWLock Entrance for this record if lock_type == 'r': rlock = self.locks_map[pkey].gen_rlock() success = rlock.acquire(blocking=False) if not success: return None return rlock elif lock_type == 'w': wlock = self.locks_map[pkey].gen_wlock() success = wlock.acquire(blocking=False) if not success: return None return wlock raise ValueError("Lock Type not recognized", lock_type)
import threading from readerwriterlock import rwlock today = 0 weekdays = [ 'sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday' ] marker = rwlock.RWLockFair() def weekday_reader(_id): global today read_marker = marker.gen_rlock() while today < len(weekdays) - 1: read_marker.acquire() print('Reader-', str(_id), 'sees', weekdays[today], 'reader count - ', read_marker.c_rw_lock.v_read_count) read_marker.release() def weekday_writer(_id): global today write_marker = marker.gen_wlock() while today < len(weekdays) - 1: write_marker.acquire() today = (today + 1) % 7 print('Writer-', str(_id), 'day modifies to', weekdays[today]) write_marker.release()
def __init__(self): self.queue = Queue(maxsize=16) self.current_data = None self.lock = rwlock.RWLockFair()
from flask import Flask, jsonify, request, make_response from flask_cors import CORS, cross_origin import datetime from readerwriterlock import rwlock # LOCKS # a fair priority lock lock = rwlock.RWLockFair() # Custom packages from orders.Order import Order, placeOrder, getUserOrders, deleteUserOrder from products.Product import getFutureAvailability, getProducts from users import loginHandler app = Flask(__name__) loginHandler = loginHandler.LoginHandler(lock) cors = CORS(app, supports_credentials=True, resources={ r"/api/*": { "origins": "*", "allow_headers": "*", "expose_headers": "*" } }) @app.route('/api/login', methods=['POST']) def login():
def __init__(self): self.root = TrieNode() lock = rwlock.RWLockFair() self.read_lock = lock.gen_rlock() self.write_lock = lock.gen_wlock()
import copy from readerwriterlock import rwlock from circular_shifts import circular_shift from scraper import scrape_url # Reader/Writer Mutex Lock database_lock = rwlock.RWLockFair() original_shifts_list = [] lowercase_shifts_list = [] shift_to_url = {} url_to_title = {} noise_words = [ line.strip() for line in open("Noisewords.txt", "r", encoding='utf8').readlines() ] noise_words.sort() noise_words = set(noise_words) def auto_fill_find(string): """ Finds up to 5 possible strings that start with the string given so far. :param string: the query of the user so far :return: a list of suggested auto-fill results """ # Assume lowercase for the string string = string.lower().strip()
def __init__(self): self.conn = dao.connect.DBUtil().getExternalConnection() self.conn.jconn.setAutoCommit(False) self.complete = None self.pencil = rwlock.RWLockFair()
else: pass def login(): loginResult = c.start("ForceLogin=1", '', mainCallback) if (loginResult.ErrorCode != 0): print("login in fail") exit() # IF1911 IF1911Queue = Manager().Queue() IF1911 = "IF1911.CFE" IF1911PORT = 50000 IF1911Lock = rwlock.RWLockFair() def IF1911Get(): while True: p = IF1911Queue.get() def IF1911Process(): numQueue = Queue.Queue() getThread = threading.Thread(target=IF1911Get()) getThread.start() with socket.socket(socket.AF_INET,socket.SOCK_STREAM) as s: s.bind(HOST,IF1911PORT) s.listen(2) #测试下第三个连接来会不会被拒绝 while True: conn,addr = s.accept()
def __init__(self) -> None: self._services: CounterType[ServiceDefinition] = CounterType() self._rwlock = rwlock.RWLockFair() self._wlock = self._rwlock.gen_wlock() self._rlock = self._rwlock.gen_rlock()