@Override public void asyncAddEntry(ByteBuf buffer, AddEntryCallback callback, Object ctx) { if (log.isDebugEnabled()) { log.debug("[{}] asyncAddEntry size={} state={}", name, buffer.readableBytes(), state); } OpAddEntry addOperation = OpAddEntry.create(this, buffer, callback, ctx); // Jump to specific thread to avoid contention from writers writing from different threads executor.executeOrdered(name, safeRun(() -> { pendingAddEntries.add(addOperation); internalAsyncAddEntry(addOperation); })); }
void checkReadCompletion() { if (entries.size() < count && cursor.hasMoreEntries()) { // We still have more entries to read from the next ledger, schedule a new async operation if (nextReadPosition.getLedgerId() != readPosition.getLedgerId()) { cursor.ledger.startReadOperationOnLedger(nextReadPosition); } // Schedule next read in a different thread cursor.ledger.getExecutor().execute(safeRun(() -> { readPosition = cursor.ledger.startReadOperationOnLedger(nextReadPosition); cursor.ledger.asyncReadEntries(OpReadEntry.this); })); } else { // The reading was already completed, release resources and trigger callback try { cursor.readOperationCompleted(); } finally { cursor.ledger.getExecutor().executeOrdered(cursor.ledger.getName(), safeRun(() -> { callback.readEntriesComplete(entries, ctx); recycle(); })); } } }
orderedExecutor.shutdown();
void notifyCursors() { while (true) { final ManagedCursorImpl waitingCursor = waitingCursors.poll(); if (waitingCursor == null) { break; } executor.execute(safeRun(() -> waitingCursor.notifyEntriesAvailable())); } }
ledgerEntries.close(); }, ml.getExecutor().chooseThread(ml.getName()));
long ledger = Long.parseLong(args[2]); EventLoopGroup eventLoopGroup = new NioEventLoopGroup(1); OrderedExecutor executor = OrderedExecutor.newBuilder() .name("BookieClientWorker") .numThreads(1) scheduler.shutdown(); eventLoopGroup.shutdownGracefully(); executor.shutdown();
private void processReadRequestV3(final BookkeeperProtocol.Request r, final Channel c) { ExecutorService fenceThread = null == highPriorityThreadPool ? null : highPriorityThreadPool.chooseThread(c); ExecutorService lpThread = longPollThreadPool.chooseThread(c); } else { try { threadPool.executeOrdered(r.getReadRequest().getLedgerId(), read); } catch (RejectedExecutionException e) { if (LOG.isDebugEnabled()) {
/** * {@inheritDoc} */ @Override public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException { return chooseThread().invokeAll(timedCallables(tasks), timeout, unit); }
private ManagedLedgerFactoryImpl(BookKeeper bookKeeper, boolean isBookkeeperManaged, ZooKeeper zooKeeper, ManagedLedgerFactoryConfig config) throws Exception { scheduledExecutor = OrderedScheduler.newSchedulerBuilder() .numThreads(config.getNumManagedLedgerSchedulerThreads()) .name("bookkeeper-ml-scheduler") .build(); orderedExecutor = OrderedExecutor.newBuilder() .numThreads(config.getNumManagedLedgerWorkerThreads()) .name("bookkeeper-ml-workers") .build(); this.bookKeeper = bookKeeper; this.isBookkeeperManaged = isBookkeeperManaged; this.zookeeper = isBookkeeperManaged ? zooKeeper : null; this.store = new MetaStoreImplZookeeper(zooKeeper, orderedExecutor); this.config = config; this.mbean = new ManagedLedgerFactoryMBeanImpl(this); this.entryCacheManager = new EntryCacheManager(this); this.statsTask = scheduledExecutor.scheduleAtFixedRate(() -> refreshStats(), 0, StatsPeriodSeconds, TimeUnit.SECONDS); }
/** * {@inheritDoc} */ @Override public <T> Future<T> submit(Callable<T> task) { return chooseThread().submit(timedCallable(task)); }
/** * {@inheritDoc} */ @Override public void execute(Runnable command) { chooseThread().execute(timedRunnable(command)); }
LOG.warn("The scheduler did not shutdown cleanly"); mainWorkerPool.shutdown(); if (!mainWorkerPool.awaitTermination(10, TimeUnit.SECONDS)) { LOG.warn("The mainWorkerPool did not shutdown cleanly");
@Override public OrderedExecutor build() { if (null == threadFactory) { threadFactory = new DefaultThreadFactory("bookkeeper-ordered-safe-executor"); } return new OrderedExecutor(name, numThreads, threadFactory, statsLogger, traceTaskExecution, preserveMdcForTaskExecution, warnTimeMicroSec, maxTasksInQueue, enableBusyWait); } }
ledger.getExecutor().execute(safeRun(() -> { ledger.mbean.endCursorLedgerCreateOp(); if (rc != BKException.Code.OK) {
}, executor.chooseThread(name)); return promise; });
OrderedExecutor executor = OrderedExecutor.newBuilder() .numThreads(1) .name("BookieClientScheduler") executor.shutdown(); bookieClient.close();
/** * {@inheritDoc} */ @Override public <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException { return chooseThread().invokeAny(timedCallables(tasks)); }
public ZooKeeperCache(ZooKeeper zkSession) { this(zkSession, OrderedExecutor.newBuilder().name("zk-cache-callback-executor").build()); this.shouldShutdownExecutor = true; }
@SuppressWarnings("unchecked") public T build() { if (null == threadFactory) { threadFactory = new DefaultThreadFactory(name); } return (T) new OrderedExecutor( name, numThreads, threadFactory, statsLogger, traceTaskExecution, preserveMdcForTaskExecution, warnTimeMicroSec, maxTasksInQueue, enableBusyWait); } }
private void trimConsumedLedgersInBackground(CompletableFuture<?> promise) { executor.executeOrdered(name, safeRun(() -> { internalTrimConsumedLedgers(promise); })); }