def test(): global TID, tid, io, wh, randint, alive import random randint = random.randint TID = 0 # thread ID (1, 2, ...) tid = thread.allocate_lock() # for changing TID io = thread.allocate_lock() # for printing, and 'alive' wh = thread.allocate_lock() # for calls to random alive = [] # IDs of active threads NSORTS = 5 arrays = [] for i in range(NSORTS): arrays.append( range( (i+1)*10 ) ) bar = barrier(NSORTS) finished = event() for i in range(NSORTS): _new_thread(_run_one_sort, arrays[i], bar, finished) finished.wait() print('all threads done, and checking results ...') if alive: raise ValueError('threads still alive at end', alive) for i in range(NSORTS): a = arrays[i] if len(a) != (i+1)*10: raise ValueError('length of array', i, 'screwed up') _check_sort(a) print('test passed!', TID, 'threads created in all')
def test_current_frames(self): import sys import time import _thread # XXX workaround for now: to prevent deadlocks, call # sys._current_frames() once before starting threads. # This is an issue in non-translated versions only. sys._current_frames() thread_id = _thread.get_ident() def other_thread(): #print("thread started") lock2.release() lock1.acquire() lock1 = _thread.allocate_lock() lock2 = _thread.allocate_lock() lock1.acquire() lock2.acquire() _thread.start_new_thread(other_thread, ()) def f(): lock2.acquire() return sys._current_frames() frames = f() lock1.release() thisframe = frames.pop(thread_id) assert thisframe.f_code.co_name in ('f', '?') assert len(frames) == 1 _, other_frame = frames.popitem() assert other_frame.f_code.co_name in ('other_thread', '?')
def test_tstate_lock(self): # Test an implementation detail of Thread objects. started = _thread.allocate_lock() finish = _thread.allocate_lock() started.acquire() finish.acquire() def f(): started.release() finish.acquire() time.sleep(0.01) # The tstate lock is None until the thread is started t = threading.Thread(target=f) self.assertIs(t._tstate_lock, None) t.start() started.acquire() self.assertTrue(t.is_alive()) # The tstate lock can't be acquired when the thread is running # (or suspended). tstate_lock = t._tstate_lock self.assertFalse(tstate_lock.acquire(timeout=0), False) finish.release() # When the thread ends, the state_lock can be successfully # acquired. self.assertTrue(tstate_lock.acquire(timeout=5), False) # But is_alive() is still True: we hold _tstate_lock now, which # prevents is_alive() from knowing the thread's end-of-life C code # is done. self.assertTrue(t.is_alive()) # Let is_alive() find out the C code is done. tstate_lock.release() self.assertFalse(t.is_alive()) # And verify the thread disposed of _tstate_lock. self.assertIsNone(t._tstate_lock) t.join()
def __init__(self): Gtk.IconView.__init__(self) self.set_item_width(BACKGROUND_ICONS_SIZE * 1.1) self._model = Gtk.ListStore(object, GdkPixbuf.Pixbuf, str, str) self._model_filter = self._model.filter_new() self._model_filter.set_visible_func(self.visible_func) self.set_model(self._model_filter) area = self.get_area() self.current_path = None pixbuf_renderer = Gtk.CellRendererPixbuf() text_renderer = Gtk.CellRendererText(ellipsize=Pango.EllipsizeMode.END) text_renderer.set_alignment(.5, .5) area.pack_start(pixbuf_renderer, True, False, False) area.pack_start(text_renderer, True, False, False) self.add_attribute(pixbuf_renderer, "pixbuf", 1) self.add_attribute(text_renderer, "markup", 2) text_renderer.set_property("alignment", Pango.Alignment.CENTER) self._loading_queue = [] self._loading_queue_lock = thread.allocate_lock() self._loading_lock = thread.allocate_lock() self._loading = False self._loaded_data = [] self._loaded_data_lock = thread.allocate_lock()
def test_repr_stopped(self): # Verify that "stopped" shows up in repr(Thread) appropriately. started = _thread.allocate_lock() finish = _thread.allocate_lock() started.acquire() finish.acquire() def f(): started.release() finish.acquire() t = threading.Thread(target=f) t.start() started.acquire() self.assertIn("started", repr(t)) finish.release() # "stopped" should appear in the repr in a reasonable amount of time. # Implementation detail: as of this writing, that's trivially true # if .join() is called, and almost trivially true if .is_alive() is # called. The detail we're testing here is that "stopped" shows up # "all on its own". LOOKING_FOR = "stopped" for i in range(500): if LOOKING_FOR in repr(t): break time.sleep(0.01) self.assertIn(LOOKING_FOR, repr(t)) # we waited at least 5 seconds t.join()
def setUp(self): self.done_mutex = _thread.allocate_lock() self.done_mutex.acquire() self.running_mutex = _thread.allocate_lock() self.random_mutex = _thread.allocate_lock() self.created = 0 self.running = 0 self.next_ident = 0
def __init__(self, func, args): self.getlock = thread.allocate_lock() self.putlock = thread.allocate_lock() self.getlock.acquire() self.putlock.acquire() self.func = func self.args = args self.done = 0 self.killed = 0 thread.start_new_thread(self._start, ())
def __init__(self, *pipes): self.active_pipes = set() self.active_sources = set() self.active_drains = set() self.active_sinks = set() self._add_pipes(*pipes) self.thread_lock = _thread.allocate_lock() self.command_lock = _thread.allocate_lock() self.__fdr,self.__fdw = os.pipe() self.threadid = None
def setUp(self): self.done_mutex = thread.allocate_lock() self.done_mutex.acquire() self.running_mutex = thread.allocate_lock() self.random_mutex = thread.allocate_lock() self.created = 0 self.running = 0 self.next_ident = 0 key = support.threading_setup() self.addCleanup(support.threading_cleanup, *key)
def __init__(self, app): ToolbarPage.__init__(self, app, "Objects") self.namespaces = {} self.images = {} self.image_directions = {} self.selected_object = [None, None] self.is_active = False self.cur_rotation = 0 x_adjust = 5 pos = self.gui.getPosition() y_pos = pos.d_y x_pos = PyCEGUI.UDim(0, x_adjust) width = PyCEGUI.UDim(0.9, 0.0) label = self.gui.createChild("TaharezLook/Label", "ObjectsLabel") label.setText(_("Objects")) label.setWidth(width) label.setXPosition(x_pos) label.setProperty("HorzFormatting", "LeftAligned") items_panel = self.gui.createChild("TaharezLook/ScrollablePane", "Items_panel") y_pos.d_scale = y_pos.d_scale + 0.045 items_panel.setXPosition(x_pos) items_panel.setYPosition(y_pos) size = self.gui.getSize() size.d_height.d_scale = size.d_height.d_scale - y_pos.d_scale size.d_width.d_offset = size.d_width.d_offset - x_adjust items_panel.setSize(size) self.items_panel = items_panel self.items = None self.have_objects_changed = False self.app.add_map_switch_callback(self.cb_map_changed) self.last_mouse_pos = None self.last_instance = None mode = self.app.current_mode mode.listener.add_callback("mouse_pressed", self.cb_map_clicked) mode.listener.add_callback("mouse_dragged", self.cb_map_clicked) mode.listener.add_callback("mouse_moved", self.cb_map_moved) mode.listener.add_callback("key_pressed", self.cb_key_pressed) self.app.add_project_clear_callback(self.cb_project_closed) self.app.add_objects_imported_callback(self.cb_objects_imported) self.objects = Queue() self.images_lock = _thread.allocate_lock() self.namespaces_lock = _thread.allocate_lock()
def __init__(self, directory): self.directory = directory self.peers = {} self.files = [] self.filter_out_files = ('README.md', 'README.rst', 'LICENSE') # Threads (low level implementation) self.__run_init_threads = 0 self.__run_init_thread_started = False self.__run_init_lock = allocate_lock() # More operating systems will be added soon. if os_type == 'Windows': files = glob.glob(self.directory + '\\*') elif os_type == 'Linux': files = glob.glob(self.directory + '/*') else: raise OSError('Your OS is not supported') for file in files: filename = ntpath.basename(file) if filename not in self.filter_out_files: self.files.append(filename) self.elements = len(self.files) # Todo: Remove none unicode chars from filenames ## Doh... not possile! do it later in peerobj. update. # Read all self.__read_all()
def __init__(self, server_address, RequestHandlerClass, maxthreads=100, pemfile=None, rest_handlers=None, userpass=None): try: if pemfile: #HTTPS server BaseServer.__init__(self, server_address, RequestHandlerClass) ctx = SSL.Context(SSL.SSLv23_METHOD) ctx.use_privatekey_file(pemfile) ctx.use_certificate_file(pemfile) self.socket = SSL.Connection(ctx, socket.socket(self.address_family, self.socket_type)) self.server_bind() self.server_activate() self.httpstyle = "HTTPS" else: #HTTP server BaseHTTPServer.__init__(self, server_address, RequestHandlerClass) self.httpstyle = "HTTP" except socket.error as e: if e.errno == 98: logging.log(logging.ERROR, "Cannot start HTTP server, address already in use") return else: raise self.lock = thread.allocate_lock() self.maxthreads = maxthreads self.threads = 0 self.rest_handlers = rest_handlers self.userpass = userpass
def __init__(self, function, *args, **kwargs): "Initialize the Micrev_Timer object." self.__function = function self.__args = args self.__kwargs = kwargs self.__thread = False self.__lock = _thread.allocate_lock()
def __init__(self, classes, n_req): self.httpd = http.server.HTTPServer(("", 10080), self.RequestHandler) self.httpd.classes = classes self.httpd.assigs = set([c[0] for c in classes]) self.lock_aturada = _thread.allocate_lock() self.lock_aturada.acquire() _thread.start_new_thread(self.serveix, (n_req,))
def __init__(self, func, args, kwargs): "Initializes instance from arguments and prepares to run." self.__func = func self.__args = args self.__kwargs = kwargs self.__mutex = _thread.allocate_lock() self.__mutex.acquire()
def __init__(self, id, frequency, datarate, ssid, password, server, port, ntp='pool.ntp.org', ntp_period=3600): self.id = id self.frequency = frequency self.datarate = datarate self.sf = self._dr_to_sf(datarate) self.ssid = ssid self.password = password self.server = server self.port = port self.ntp = ntp self.ntp_period = ntp_period self.rxnb = 0 self.rxok = 0 self.rxfw = 0 self.dwnb = 0 self.txnb = 0 self.stat_alarm = None self.pull_alarm = None self.uplink_alarm = None self.udp_lock = _thread.allocate_lock() self.lora = None self.lora_sock = None
def test_many_threads(self): import _thread, time if self.can_start_many_threads: skip("this OS supports too many threads to check (> 1000)") lock = _thread.allocate_lock() lock.acquire() count = [0] def f(): count[0] += 1 lock.acquire() lock.release() count[0] -= 1 try: try: for i in range(1000): _thread.start_new_thread(f, ()) finally: lock.release() # wait a bit to allow most threads to finish now while count[0] > 10: print(count[0]) # <- releases the GIL print("ok.") except (_thread.error, MemoryError): pass else: raise Exception("could unexpectedly start 1000 threads") # safety: check that we can start a new thread here _thread.start_new_thread(lambda: None, ())
def __init__ (self): r, w = self._fds = os.pipe() self.trigger = w asyncore.file_dispatcher.__init__(self, r) self.lock = _thread.allocate_lock() self.thunks = [] self._closed = 0
def test__count(self): # Test the _count() function. orig = thread._count() mut = thread.allocate_lock() mut.acquire() started = [] def task(): started.append(None) mut.acquire() mut.release() with support.wait_threads_exit(): thread.start_new_thread(task, ()) while not started: time.sleep(POLL_SLEEP) self.assertEqual(thread._count(), orig + 1) # Allow the task to finish. mut.release() # The only reliable way to be sure that the thread ended from the # interpreter's point of view is to wait for the function object to be # destroyed. done = [] wr = weakref.ref(task, lambda _: done.append(None)) del task while not done: time.sleep(POLL_SLEEP) self.assertEqual(thread._count(), orig)
def test_lock_acquire_interruption(self): if self.using_pthread_cond: skip('POSIX condition variables cannot be interrupted') import _thread, signal, time # Mimic receiving a SIGINT (KeyboardInterrupt) with SIGALRM while stuck # in a deadlock. # XXX this test can fail when the legacy (non-semaphore) implementation # of locks is used in thread_pthread.h, see issue #11223. oldalrm = signal.signal(signal.SIGALRM, self.alarm_interrupt) try: lock = _thread.allocate_lock() lock.acquire() signal.alarm(1) t1 = time.time() # XXX: raises doesn't work here? #raises(KeyboardInterrupt, lock.acquire, timeout=5) try: lock.acquire(timeout=5) except KeyboardInterrupt: pass else: assert False, 'Expected KeyboardInterrupt' dt = time.time() - t1 # Checking that KeyboardInterrupt was raised is not sufficient. # We want to assert that lock.acquire() was interrupted because # of the signal, not that the signal handler was called immediately # after timeout return of lock.acquire() (which can fool assertRaises). assert dt < 3.0 finally: signal.signal(signal.SIGALRM, oldalrm)
def test_lock(self): import _thread lock = _thread.allocate_lock() assert type(lock) is _thread.LockType assert lock.locked() is False raises(_thread.error, lock.release) assert lock.locked() is False r = lock.acquire() assert r is True r = lock.acquire(False) assert r is False assert lock.locked() is True lock.release() assert lock.locked() is False raises(_thread.error, lock.release) assert lock.locked() is False feedback = [] lock.acquire() def f(): self.busywait(0.25) feedback.append(42) lock.release() assert lock.locked() is True _thread.start_new_thread(f, ()) lock.acquire() assert lock.locked() is True assert feedback == [42]
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self._lock = _thread.allocate_lock() self._outqueue = queue.Queue() self._sock = None self._buffer = [] self._lastline = "" self._error = "" self._status = "start" self.handlers = Object() self.type = self.__class__.__name__ self.register("004", self.connected) self.register("ERROR", self.errored) self.register("366", self.h366) self.register("433", self.h433) self.register("513", self.h513) self.register("PING", self.pinged) self.register("PONG", self.ponged) self.register("QUIT", self.quited) self.register("INVITE", self.invited) self.register("PRIVMSG", self.privmsged) self.register("NOTICE", self.noticed) self.register("JOIN", self.joined) self.channels = [] self.encoding = "utf-8" if "realname" not in self: self.realname = "meds" if "username" not in self: self.username = "******" if "server" not in self: self.server = "localhost" if "port" not in self: self.port = 6667 if "nick" not in self: self.nick = "meds" if "channel" in self: self.channels.append(self.channel)
def __init__(self, ip, port, maxCn): '''(self, str, int, int) -> None Creates a new server instance.''' self.ip = ip self.port = port self.maxConnections = maxCn self.clients = {} self.channels = {} self.clientCount = 0 self.lock = allocate_lock() try: self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.sock.bind((ip, port)) self.sock.listen(self.maxConnections) if self.sock: print('Woot! We established the socket on {0}:{1}'.format(self.ip ,self.port)) #server loaded and is working. so self.running = True self.running = True except: if socket.error: print('Socket Error while setting up server: {0}'.format(traceback.format_exc().splitlines()[-1])) else: print('Error while setting up server:\n{0}'.format(traceback.format_exc())) #something has gone wrong, so self.running = False self.running = False return
def start(self, port=8080): """ Starts the server. This will actually start the child process. :param port: Local TCP/IP port to which the underlying socket is connected to. """ self.__process = multiprocessing.Process(target=childProcess, name=self.__name, args=(port, )) self.__process.start() self.__running = False try: if sys.platform == "win32": self._client = Client(('localhost', port)) else: try: self._client = Client(('', port)) except OSError: # wait a second before starting, this occur if we were connected to # previously running server that has just closed (we need to wait a # little before starting a new one) time.sleep(1) self._client = Client(('', port)) logger.info("Connected to Code Completion Server on 127.0.0.1:%d" % port) self.__running = True self._lock = thread.allocate_lock() thread.start_new_thread(self._threadFct, ()) except OSError: logger.exception("Failed to connect to Code Completion Server on " "127.0.0.1:%d" % port) return self.__running
def __init__(self, maxResources, newResourceFunc): self.lock = thread.allocate_lock() self.poolEvent = Event() self.freeResources = [] self.busyResources = [] self.maxResources = maxResources self.newResourceFunc = newResourceFunc
def test_timeout(self): import _thread assert isinstance(_thread.TIMEOUT_MAX, float) assert _thread.TIMEOUT_MAX > 1000 lock = _thread.allocate_lock() assert lock.acquire() is True assert lock.acquire(False) is False assert lock.acquire(True, timeout=.1) is False
def __init__(self, filename, type): self.type = type self.filename = filename if self.filename: self.db = None else: self.db = {} self.lock = _thread.allocate_lock()
def _postinit(self): # alias all queue methods for faster lookup self._popleft = self._queue.popleft self._pop = self._queue.pop if hasattr(self._queue, 'remove'): self._remove = self._queue.remove self._wlock = allocate_lock() self._append = self._queue.append
def __init__(self): root = Tk() root.title(self.title) labels = ['Server Name', 'Remote Dir', 'File Name', 'Local Dir', 'User Name?', 'Password?'] Form.__init__(self, labels, root) self.mutex = _thread.allocate_lock() self.threads = 0
def InitializeErrorWatcher(self): from System.Threading import Thread, ThreadStart import _thread self.errorLock = _thread.allocate_lock() self.errorString = "" th = Thread(ThreadStart(self.WatchErrorStream)) th.IsBackground = True th.Start()
""" Lab Visualisation & Medical Image Analysis SS2019 Institute of Computer Science II Author: Christian Breiderhoff created on June 2019 """ import config import argparse import io_ops import sys from _thread import start_new_thread, allocate_lock import multiprocessing lock = allocate_lock() thread_finished = None show_step_size = 20 show_step_size_tvflow = 500 num_threads = int(multiprocessing.cpu_count()) skip_empty_files = True skip_existing_files = False def chunk_dict(dict_in, num_seq): avg = len(dict_in) / float(num_seq) out = [] for seq in range(num_seq): out.append(dict()) last = avg i = 0
""" synchronize access to stdout: because it is shared global, thread outputs may be intermixed if not synchronized """ import _thread as thread, time def counter(myId, count): # function run in threads for i in range(count): time.sleep(1) # simulate real work mutex.acquire() print('[%s] => %s' % (myId, i)) # print isn't interrupted now mutex.release() mutex = thread.allocate_lock() # make a global lock object for i in range(5): # spawn 5 threads thread.start_new_thread(counter, (i, 5)) # each thread loops 5 times time.sleep(6) print('Main thread exiting.') # don't exit too early
def __init__(self, num_threads): self.num_threads = num_threads self.waiting = 0 self.checkin_mutex = thread.allocate_lock() self.checkout_mutex = thread.allocate_lock() self.checkout_mutex.acquire()
import _thread as thread, time stdoutmutex = thread.allocate_lock() exitmutexes = [thread.allocate_lock() for i in range(10)] def counter(myID, count): for i in range(count): time.sleep(1) stdoutmutex.acquire() print('[%s] => %s ' % (myID, i)) stdoutmutex.release() exitmutexes[myID].acquire() #向主线程发送信号。 for i in range(10): thread.start_new_thread(counter, (i, 100)) for mutex in exitmutexes: while not mutex.locked(): pass ####time.sleep(6) print('Main thread exiting.\n')
class Display: lock = _thread.allocate_lock() def __init__(self): self.alive = False self.Led = Pixel() self.tem = [[0, 0, 0]] * 25 # 显示缓存区m= def stop(self): self.alive = False if Display.lock.acquire(): # print("stop") Display.lock.release() def scroll(self, val, color=Red, delay=150): self.stop() self.alive = True if Display.lock.acquire(): # print("start") _thread.start_new_thread(self._scroll,([val,color,delay])) Display.lock.release() def Disrupt_Col(color): a = color[-1] while True: if color_num != 1: import random random.shuffle(color) if a != color[0]: break def _scroll(self, val, color=Red, delay=150): pixel_col = [[0, 0, 0]] * 25 # 显示缓存区m= val = str(val) + ' ' color_num = 1 if color != Red: if isinstance(color[0], list): color_num = len(color) # self.Disrupt_Col(color) #打乱颜色顺序 col_cnt = 0 it = iter(color) for val1 in val: val2 = CharData[val1] if color_num == 1: now_col = color else: if col_cnt < color_num: now_col = next(it) # 确定当前字符的颜色 else: col_cnt = 0 it = iter(color) now_col = next(it) col_cnt += 1 for i in range(25): # 为字符的像素点添加颜色 if val2[i] == 1: pixel_col[i] = now_col else: pixel_col[i] = [0, 0, 0] if Display.lock.acquire(): for i in range(6): # 开始滚动显示 if self.alive == False: Display.lock.release() self.clear() _thread.exit() else: for t in range(4): self.tem[20 - (t * 5):20 - (t * 5) + 5] = self.tem[20 - ((t + 1) * 5):20 - ((t + 1) * 5) + 5] # 数据向前移动5位 if i == 5: self.tem[0:5] = Zero[0:5] # 每个字符之间间隔一行 else: self.tem[0:5] = pixel_col[20 - (i * 5):20 - (i * 5) + 5] for r in range(25): self.Led.LoadPos(r, self.tem[r]) # 亮度为0 self.Led.Show() sleep_ms(delay) Display.lock.release() _thread.exit() def clear(self): self.stop() self.Led.fill((0, 0, 0)) self.Led.Show() def __show(self, it, color): it = iter(it) for r in range(25): col = next(it) self.Led.LoadPos(r, color if col else black) self.Led.Show() def show(self, images, wait=True, color=Red, *, loop=False, delay=500, clear=False): if isinstance(images, str): images = CharData[images] if isinstance(images, list) and (isinstance(images[0], Image) or isinstance(images[0], list)): for i in images: self.__show(i, color) sleep_ms(delay) try: while loop: for i in images: self.__show(i, color) sleep_ms(delay) except Exception as e: self.Led.fill((0, 0, 0)) self.Led.Show() else: it = iter(images) self.__show(it, color) try: while loop: self.__show(it, color) except Exception as e: self.Led.fill((0, 0, 0)) self.Led.Show() def get_pixel(self, x=0, y=0): print("get_pixel will be supported in the future.") def set_pixel(self, x=0, y=0, value=9): print("set_pixel will be supported in the future.") def on(self): self.clear() def off(self): self.clear() def is_on(self): return self.Led != None
def __init__(self): self.count = 0 self.mutex = thread.allocate_lock() # или Threading.semaphore
#!/usr/bin/python3 "producer and consumer threads communicating with a shared queue" numconsumers = 2 numproducers = 4 nummessages = 4 import _thread as thread, queue, time import threading sameprint = thread.allocate_lock() dataQueue = queue.Queue() def producer(idnum, dataqueue): for msgnum in range(nummessages): time.sleep(idnum) dataqueue.put('[producer id=%id, count=%d]' % (idnum, msgnum)) def consumer(idnum, dataqueue): while True: time.sleep(0.1) try: data = dataqueue.get(block=False) except queue.Empty: pass else: with sameprint: print('consumer', idnum, 'got =>', data)
import os import unittest import random from test import support import _thread as thread import time import weakref from test import lock_tests NUMTASKS = 10 NUMTRIPS = 3 POLL_SLEEP = 0.010 # seconds = 10 ms _print_mutex = thread.allocate_lock() def verbose_print(arg): """Helper function for printing out debugging output.""" if support.verbose: with _print_mutex: print(arg) class BasicThreadTest(unittest.TestCase): def setUp(self): self.done_mutex = thread.allocate_lock() self.done_mutex.acquire() self.running_mutex = thread.allocate_lock() self.random_mutex = thread.allocate_lock() self.created = 0
import barometer import lora_connection import functions import _thread import machine import socket import csv import time ################################################################################ ### ### VARIABLES ### ### Threads lock = _thread.allocate_lock() ### Data request = None data = dict() data["nFinished"] = 0 try: count = pycom.nvs_get('count') except: count = 0 ### LoRa lora = LoRa(mode=LoRa.LORA, tx_power=14, sf=9, coding_rate=LoRa.CODING_4_6) lora.power_mode(LoRa.TX_ONLY) ### Pysense
import sys import _thread import time from timer import Timer ##TODO: Initialize the following variables RECEIVER_ADDR = SENDER_ADDR = SLEEP_INTERVAL = TIMEOUT_INTERVAL = WINDOW_SIZE = # Shared resources across threads base = 0 mutex = _thread.allocate_lock() send_timer = Timer(TIMEOUT_INTERVAL) # Sets the window size def set_window_size(num_packets): global base return min(WINDOW_SIZE, num_packets - base) # Send thread def send(sock): global mutex global base global send_timer ## TODO: Add all the packets and corresponding seq_num to packets packets = [] seq_num = 0
import _thread as thread stdoutmutex = thread.allocate_lock() exitmutexes = [False] * 10 def counter(myId, count): for i in range(count): stdoutmutex.acquire() print('[%s]=>%s' % (myId, i)) stdoutmutex.release() exitmutexes[myId] = True for i in range(10): thread.start_new_thread(counter, (i, 100)) while False in exitmutexes: pass print('Main thread existing.')
def __init__(self): self.lock = _thread.allocate_lock() self.lat = None self.long = None self.h_msl = None # mm
str(dicInfos["CONTROLLER"].getPlaceCode()) + "|" + sens) system.addText("LOGS", "Mensagem de atualização enviada ao Servidor!!! ") except: pass # ------------------------------------# dicInfos = { "SENSORES": {}, "ERRO_SENSOR": {}, "CONTROLLER": newController(), "APPARATUS": newApparatus(), "PLACES": getPlaces(), "MUTEX": _thread.allocate_lock(), "SETTINGS": getServerSettings() } # conexao para Sensores dicConn = { "SENSOR": socket.socket(socket.AF_INET, socket.SOCK_STREAM), "SERVIDOR": None } dicConn["SENSOR"].bind((dicInfos["CONTROLLER"].getIpController(), dicInfos["CONTROLLER"].getPort())) dicConn["SENSOR"].listen(1) # iniciando interface grafica root = startTk(geometry="1280x720", title="Controladora", resizable=False) system = newSystem(root, "Settings/controllerInterfaceSettings.txt",
# -*- coding: utf-8 -*- import sys, threading, _thread, time, msvcrt, json sys.path.append('../../lib/') import kl_http, kl_db, kl_reg, kl_progress #from queue import Queue regex = kl_reg http = kl_http.kl_http() http.autoUserAgent = True progress = kl_progress.kl_progress('') progress.start() progress.hide() #测试代理是否可用 mylock = _thread.allocate_lock() #线程锁 #测试线程函数 def testProxy(i): try: global curnum #print('正在测试代理:%s:%s %s %s'%(i['ip'],i['port'],i['proxy_type'],i['proxy_area'])) # sys.stdout.write('正在测试代理:%s:%s ...'%(i['ip'],i['port'])+"\r") # sys.stdout.flush() progress.settext('正在测试代理:%s:%s' % (i['ip'], i['port'])) ht = kl_http.kl_http() ht.setproxy('', '', '%s:%s' % (i['ip'], i['port'])) r = ht.geturl('http://proxy.59vip.cn') mylock.acquire() #Get the lock if r != None: data = r.read().decode() if data.find('#ok#') != -1:
def __init__(self, current_values): self.current_values = current_values self.view = BeamerSettingsPageView() self.image_loading_lock = thread.allocate_lock() thread.start_new_thread(self.load_beamer_images, ())
# объект мьютекса, совместно используемый всеми потоками выполнения, передается # функции в виде аргумента; для автоматического приобретения/освобождения # блокировки используется менеджер контекста; чтобы избежать излишней нагрузки # в цикле ожидания, и для имитации выполнения продолжительных операций добавлен # вызов функции sleep import _thread as thread, time stdoutmutex = thread.allocate_lock() numthreads = 5 exitmutex = [thread.allocate_lock() for i in range(numthreads)] def counter(myId, count, mutex): for i in range(count): time.sleep(1 / (myId+1)) with mutex: print('[%s] => %s' % (myId, i)) exitmutex[myId].acquire() for i in range(numthreads): thread.start_new_thread(counter, (i, 5, stdoutmutex)) while not all(mutex.locked() for mutex in exitmutex): time.sleep(0.25) print('Main thread exiting')
channel.continueInDialplan() on_dtmf_handle.close() elif digit == '*': channel.play(media='sound:asterisk-friend') else: channel.play(media='sound:digits/%s' % digit) on_dtmf_handle = channel.on_event('ChannelDtmfReceived', on_dtmf) channel.answer() channel.play(media='sound:hello-world') client.on_channel_event('StasisStart', on_start) # Run the WebSocket sync = _thread.allocate_lock() def run(): """Thread for running the Websocket. """ sync.acquire() client.run(apps="hello") sync.release() thr = _thread.start_new_thread(run, ()) print("Press enter to exit") sys.stdin.readline() client.close() sync.acquire()
def _thread_getlock(): return _thread.allocate_lock()
import _thread, time stdout_mutex = _thread.allocate_lock() numthreads = 5 exit_mutexes = [_thread.allocate_lock() for i in range(numthreads)] def counter(id, count, mutex): for i in range(count): time.sleep(1 / (id + 1)) ''' __enter__ in 'with' block acquires a block for critical section __exit__ releases the last one. ''' with mutex: print('[%s] => %s' % (id, i)) exit_mutexes[id].acquire() for i in range(numthreads): _thread.start_new_thread(counter, (i, numthreads, stdout_mutex)) while not all(mutex.locked() for mutex in exit_mutexes): time.sleep(.25) print('Main thread exiting')
def get_variable(name): g_var = super_var(name) if (g_var): return g_var.get_value() else: return None #--------------------- IOT wifi interface ---------------- m_wifi = codey_wlan() wifi_connect_time = 3 # s connecting_ssid = None connecting_pass = None m_wifi.wifi_enable() wifi_sema = _thread.allocate_lock() def wifi(ssid, password): global connecting_ssid global connecting_pass wifi_sema.acquire(1) if (ssid != connecting_ssid) or (password != connecting_pass): connecting_ssid = ssid connecting_pass = password m_wifi.wifi_sta_config(ssid, password) m_wifi.wifi_mode_config(m_wifi.STA) m_wifi.wifi_start() wait_count = 0 while not wifi_is_connected(): stime.sleep(0.1)
def __init__(self, threads): self.__threads = threads self.__count = 0 self.__main = _thread.allocate_lock() self.__exit = _thread.allocate_lock() self.__exit.acquire()
def __init__(self, PORT, startingMode=SAFE_MODE, sim_mode=False): """ the constructor which tries to open the connection to the robot at port PORT """ # to do: find the shortest safe serial timeout value... # to do: use the timeout to do more error checking than # is currently done... # # the -1 here is because windows starts counting from 1 # in the hardware control panel, but not in pyserial, it seems displayVersion() # fields for simulator self.in_sim_mode = False self.sim_sock = None self.sim_host = '127.0.0.1' self.sim_port = 65000 self.maxSensorRetries = MIN_SENSOR_RETRIES # if PORT is the string 'simulated' (or any string for the moment) # we use our SRSerial class self.comPort = PORT #we want to keep track of the port number for reconnect() calls print('PORT is', PORT) if type(PORT) == type('string'): if PORT == 'sim': self.init_sim_mode() self.ser = None else: # for Mac/Linux - use whole port name # print 'In Mac/Linux mode...' self.ser = serial.Serial(PORT, baudrate=57600, timeout=0.5) # otherwise, we try to open the numeric serial port... if (sim_mode): self.init_sim_mode() else: # print 'In Windows mode...' try: self.ser = serial.Serial(PORT - 1, baudrate=57600, timeout=0.5) if (sim_mode): self.init_sim_mode() except serial.SerialException: print( "unable to access the serial port - please cycle the robot's power" ) # did the serial port actually open? if self.in_sim_mode: print("In simulator mode") elif self.ser.isOpen(): print('Serial port did open on iRobot Create...') else: print('Serial port did NOT open, check the') print(' - port number') print(' - physical connection') print( ' - baud rate of the roomba (it\'s _possible_, if unlikely,') print(' that it might be set to 19200 instead') print(' of the default 57600 - removing and') print(' reinstalling the battery should reset it.') # define the class' Open Interface mode self.sciMode = OFF_MODE if (startingMode == SAFE_MODE): print('Putting the robot into safe mode...') self.toSafeMode() time.sleep(0.3) if (startingMode == FULL_MODE): print('Putting the robot into full mode...') self.toSafeMode() time.sleep(0.3) self.toFullMode() self.serialLock = _thread.allocate_lock()
SEQ_SIZE = 4 HASH_SIZE = 56 PACKET_SIZE = 1988 #Packet Length specify the size of the whole packet include header 2048 B PACKET_LENGTH = PACKET_SIZE + SEQ_SIZE + HASH_SIZE filename1 = '' # read file filename2 = '' # write file # NAME NAME_SENDER = b'sender' NAME_REC = b'reciever' # global base = 0 ack_thread = _thread.allocate_lock() #set timeout duration for timer timer = Timer(TIMEOUT_DURATION) # extract the packet def packet_unpack(data): # bytes from 0 to HASH_SIZE-1: checksum checksum = data[:HASH_SIZE] # byts from HASH_SIZE to SEQ_SIZE + HASH_SIZE-1: sequence number # remaim bytes are data seq_num = int.from_bytes(data[HASH_SIZE:SEQ_SIZE + HASH_SIZE], byteorder='little', signed=True)
""" синхронизирует доступ к stdout: так как это общий глобальный объект, данные, которые выводятся из потоков выполнения, могут перемешиваться, если не синхронизировать операции """ import _thread as thread, time mutex = thread.allocate_lock() # создать объект блокировки def counter(myId, count): # эта функция выполняется в потоках for i in range(count): time.sleep(1) # имитировать работу mutex.acquire() # теперь работа print(f"[{myId}] => {i}") # функции print mutex.release() # не будет прерываться for i in range(5): thread.start_new_thread(counter, (i, 5)) # time.sleep(6) print('Main thread exiting.')
# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, # WITHOUT WARRANTIES OF ANY KIND, # EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, # MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. # See the Mulan PSL v2 for more details. # ---------------------------------------------------------------------------- import subprocess import multiprocessing import _thread as thread from gspylib.inspection.common.CheckItem import BaseItem from gspylib.inspection.common.CheckResult import ResultStatus from gspylib.threads.parallelTool import parallelTool from gspylib.os.gsnetwork import g_network DEFAULT_PARALLEL_NUM = 12 g_lock = thread.allocate_lock() noPassIPs = [] class CheckPing(BaseItem): def __init__(self): super(CheckPing, self).__init__(self.__class__.__name__) def doCheck(self): global noPassIPs allIP = [] LocalNodeInfo = self.cluster.getDbNodeByName(self.host) allIP += LocalNodeInfo.backIps allIP += LocalNodeInfo.sshIps for dbInstance in LocalNodeInfo.datanodes: allIP += dbInstance.haIps
def thread1(): global lock lock = _thread.allocate_lock() lock.acquire() time.sleep(5) lock.release()
""" The sign display server by Thomas(Sascha) Alexander Steinholz """ from multiprocessing.connection import Listener from time import sleep from _thread import start_new_thread, allocate_lock SERVER_PORT = 7980 parking_access_lock = allocate_lock() parking_directory = [] progress_bars = [] def start_server(): """ Add new connections as they come in. """ server = Listener(('', SERVER_PORT)) print("[+] Server Created.") while True: connection = server.accept() print("[+] Connected to Parking Sensor", str(connection.fileno()) + ".") start_new_thread(client_thread, (connection, )) def update_parking(identifier, direction): """ Safely update the parking_directory slot count. """ with parking_access_lock: # Find the identifier in the directory. for lot in parking_directory:
# Licensed to the .NET Foundation under one or more agreements. # The .NET Foundation licenses this file to you under the Apache 2.0 License. # See the LICENSE file in the project root for more information. import os import sys import unittest import _thread CP16623_LOCK = _thread.allocate_lock() from iptest import IronPythonTestCase, is_cli, is_cpython, is_netcoreapp, is_posix, run_test, skipUnlessIronPython class FileTest(IronPythonTestCase): def setUp(self): super(FileTest, self).setUp() self.temp_file = os.path.join(self.temporary_dir, "temp_%d.dat" % os.getpid()) self.rng_seed = 0 # The set of read modes we wish to test. Each tuple consists of a human readable # name for the mode followed by the corresponding mode string that will be # passed to the file constructor. self.read_modes = (("binary", "rb"), ("text", "r"), ("universal", "rU")) # Same deal as above but for write modes. Note that writing doesn't support a # universal newline mode. self.write_modes = (("binary", "wb"), ("text", "w")) def tearDown(self):
def __init__(self) : self._lock = allocate_lock() self._first = None self._last = None