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()
