def __init__(self, group=None, target=None, name=None, args=(), kwargs={}, daemon=None): ThreadBase.__init__(self) assert group is None self.__target = target self.__args = args self.__kwargs = kwargs if not name: name = _newname() current = current_thread() if daemon is not None: self.__dict__['daemon'] = daemon else: self.__dict__['daemon'] = current.daemon self.__dict__['name'] = name def call_run(): # As soon as the thread is done, break the circular reference. try: self.run() finally: self.__thread = None _thread._remove_thread_id(self.ident) self.__thread = core.PythonThread(call_run, None, name, name) threadId = _thread._add_thread(self.__thread, weakref.proxy(self)) self.__dict__['ident'] = threadId
def start_new_thread(function, args, kwargs={}, name=None): def threadFunc(threadId, function=function, args=args, kwargs=kwargs): try: try: function(*args, **kwargs) except SystemExit: pass finally: _remove_thread_id(threadId) global _nextThreadId _threadsLock.acquire() try: threadId = _nextThreadId _nextThreadId += 1 if name is None: name = 'PythonThread-%s' % (threadId) thread = core.PythonThread(threadFunc, [threadId], name, name) thread.setPythonIndex(threadId) _threads[threadId] = (thread, {}, None) thread.start(core.TPNormal, False) return threadId finally: _threadsLock.release()
def test_cvar_notify_thread(num_threads): # Tests notify() with some number of threads waiting. m = Mutex() cv = ConditionVarFull(m) # We prematurely notify, so that we can test that it's not doing anything. m.acquire() cv.notify() state = {'waiting': 0} def wait_thread(): m.acquire() state['waiting'] += 1 cv.wait() state['waiting'] -= 1 m.release() # Start the threads, and yield to it, giving it a chance to mess up. threads = [] for i in range(num_threads): thread = core.PythonThread(wait_thread, (), "", "") thread.start(core.TP_high, True) # Yield until all of the threads are waiting for the condition variable. for i in range(1000): m.release() yield_thread() m.acquire() if state['waiting'] == num_threads: break assert state['waiting'] == num_threads # OK, now signal it, and yield. One thread must be unblocked per notify. for i in range(num_threads): cv.notify() expected_waiters = num_threads - i - 1 for j in range(1000): m.release() yield_thread() m.acquire() if state['waiting'] == expected_waiters: break assert state['waiting'] == expected_waiters m.release() for thread in threads: thread.join() cv = None
def __init__(self, group=None, target=None, name=None, args=(), kwargs={}): ThreadBase.__init__(self) self.__target = target self.__args = args self.__kwargs = kwargs if not name: import threading2 name = threading2._newname() current = current_thread() self.__dict__['daemon'] = current.daemon self.__dict__['name'] = name self.__thread = core.PythonThread(self.run, None, name, name) threadId = _thread._add_thread(self.__thread, weakref.proxy(self)) self.__dict__['ident'] = threadId return
def test_mutex_contention(): # As a smoke test for mutexes, we just spawn a bunch of threads that do a # lot of mutexing and hope that we can catch any obvious issues with the # mutex implementation, especially when compiling with DEBUG_THREADS. m1 = Mutex() m2 = Mutex() m3 = Mutex() m4 = Mutex() def thread_acq_rel(m): for i in range(5000): m.acquire() m.release() def thread_nested(): for i in range(5000): m1.acquire() m4.acquire() m4.release() m1.release() def thread_hand_over_hand(): m1.acquire() for i in range(5000): m2.acquire() m1.release() m3.acquire() m2.release() m1.acquire() m3.release() m1.release() def thread_sleep(m): for i in range(250): m.acquire() core.Thread.sleep(random() * 0.003) m.release() threads = [ core.PythonThread(thread_acq_rel, (m1, ), "", ""), core.PythonThread(thread_acq_rel, (m2, ), "", ""), core.PythonThread(thread_acq_rel, (m3, ), "", ""), core.PythonThread(thread_acq_rel, (m4, ), "", ""), core.PythonThread(thread_nested, (), "", ""), core.PythonThread(thread_nested, (), "", ""), core.PythonThread(thread_nested, (), "", ""), core.PythonThread(thread_hand_over_hand, (), "", ""), core.PythonThread(thread_hand_over_hand, (), "", ""), core.PythonThread(thread_sleep, (m1, ), "", ""), core.PythonThread(thread_sleep, (m2, ), "", ""), core.PythonThread(thread_sleep, (m3, ), "", ""), core.PythonThread(thread_sleep, (m4, ), "", ""), ] for thread in threads: thread.start(core.TP_normal, True) for thread in threads: thread.join()