def __enter__(self):
self._pool = fastthreadpool.Pool(self._max_thread_num)
self.host_check_list = []
for i in range(self._max_thread_num):
self.host_check_list.append(host_checker.HostChecker('202.96.134.133', self._config_dict))
return self
def main(rootDirName, dstBaseDirName):
if not os.path.exists(dstBaseDirName):
os.makedirs(dstBaseDirName)
itemsScanner = deque()
evtScanner = Event()
bFinishing = False
path_join = os.path.join
with fastthreadpool.Pool(32) as pool:
pool.submit(Scanner, rootDirName, itemsScanner, evtScanner)
while not bFinishing or itemsScanner or (pool.pending > 0):
try:
itemType, relPathName = itemsScanner.popleft()
except IndexError:
evtScanner.wait(0.1)
evtScanner.clear()
continue
if itemType == 0:
dirName = path_join(dstBaseDirName, relPathName)
if not os.path.exists(dirName):
os.makedirs(dirName)
elif itemType == 1:
pool.submit(Copy, path_join(rootDirName, relPathName),
path_join(dstBaseDirName, relPathName))
elif itemType == 2:
bFinishing = True
else:
print("ERROR:", relPathName)
break
while pool.failed:
print(pool.failed.popleft())
def test_threading_Semaphore_threads(self):
s = threading.Semaphore(8)
pool = fastthreadpool.Pool()
for value in range(10):
if value & 1:
pool.submit(self.release_cb, s)
else:
pool.submit(self.acquire_cb, s)
pool.shutdown()
assert s._value == 8
def threading_Semaphore_threads(self, values):
s = threading.Semaphore(8)
pool = fastthreadpool.Pool()
for value in values:
if value & 1:
pool.submit(self.release_cb, s)
else:
pool.submit(self.acquire_cb, s)
pool.shutdown()
return getattr(s, "_value", -1)
def fastthreadpool_Semaphore_threads(self, values):
s = fastthreadpool.Semaphore(8)
pool = fastthreadpool.Pool()
for value in values:
if value & 1:
pool.submit(self.release_cb, s)
else:
pool.submit(self.acquire_cb, s)
pool.shutdown()
return s.value
def submit_done_cb(self, data):
# Important: The result function is executed in the worker thread. So we need a
# lock in the result function!
with fastthreadpool.Pool() as pool:
for value in data:
pool.submit_done(self.worker, self.locked_result_cb, value)
def submit_done_cb(self, data):
pool = fastthreadpool.Pool(done_callback=self.result_cb)
for value in data:
pool.submit(self.worker, value)
pool.shutdown()
def submit(self, data):
pool = fastthreadpool.Pool()
for value in data:
pool.submit(self.worker, value)
pool.shutdown()
self.result = list(pool.done)
def map_gen_failed_cb(self, data):
pool = fastthreadpool.Pool(failed_callback=self.failed_cb)
pool.map(self.worker_gen, data)
pool.shutdown()
self.result = list(pool.done)
def map_gen_done_cb(self, data):
pool = fastthreadpool.Pool(done_callback=self.result_cb)
pool.map(self.worker_gen, data)
pool.shutdown()
def map_gen(self, data):
pool = fastthreadpool.Pool()
pool.map(self.worker_gen, data)
pool.shutdown()
self.result = list(pool.done)
if args.addr.startswith('file:'):
unix = True
addr = args.addr[5:]
if os.path.exists(addr):
os.remove(addr)
else:
addr = args.addr.split(':')
addr[1] = int(addr[1])
addr = tuple(addr)
print('serving on: {}'.format(addr))
if args.pool:
print(f"creating thread pool with {args.threads} threads")
print(f"buffer size is {args.bufsize} bytes")
pool = fastthreadpool.Pool(args.threads)
pool.submit(pool_echo_server, addr, unix, args.threads, args.bufsize)
pool.join()
sys.exit(0)
if args.uvloop:
import uvloop
loop = uvloop.new_event_loop()
print('using uvloop')
else:
loop = asyncio.new_event_loop()
print('using asyncio loop')
asyncio.set_event_loop(loop)
loop.set_debug(False)
def submit_failed_cb(self, data):
pool = fastthreadpool.Pool(failed_callback=self.failed_cb)
for value in data:
pool.submit(self.worker, value)
pool.shutdown()
self.result = list(pool.done)
def submit_gen_pool_done_cb(self, data):
with fastthreadpool.Pool(done_callback=self.result_cb) as pool:
for value in data:
pool.submit(self.worker_gen, value)
def submit_gen_result_id(self, data):
pool = fastthreadpool.Pool(result_id=True)
for value in data:
pool.submit(self.worker_gen, value)
pool.shutdown()
self.result = sum([result[1] for result in pool.done])
def map_gen_done_cb(self, data):
with fastthreadpool.Pool(done_callback=self.result_cb) as pool:
pool.map(self.worker_gen, data)
def map_no_done(self, data):
pool = fastthreadpool.Pool()
pool.map(self.worker, data, False)
pool.shutdown()
import time
import fastthreadpool
if __name__ == "__main__":
startTime = time.time()
pool = fastthreadpool.Pool()
def Hello(text):
print(time.time() - startTime, text)
return "World " + text
def Done(result):
print(time.time() - startTime, "Done", result)
tmr1s = pool.schedule(1.0, Hello, "Hallo 1s")
print("1s timer", tmr1s)
tmr15s = pool.schedule_done(1.5, Hello, Done, "Hallo 1.5s")
print("1.5s timer", tmr15s)
pool.submit_at(startTime + 1.8, 0.0, Hello, "Submit At")
pool.submit_at(startTime + 3.8, 0.0, Hello, "Submit At 2")
pool.submit_at(startTime + 1.9, 0.8, Hello, "Submit At Interval")
print("SLEEP")
try:
time.sleep(5)
except:
pass
print("CANCEL 1.5s timer", tmr15s)
pool.cancel(None, tmr15s)
print("SLEEP")
def map(self, data):
pool = fastthreadpool.Pool()
pool.map(self.worker, data)
pool.shutdown()
self.result = sum(pool.done)
