René's URL Explorer Experiment


Title: ScheduledDataLoaderRegistry ticker mode schedules one task per data loader on every dispatchAll(), so pending tasks grow with loaders × dispatch calls · Issue #290 · graphql-java/java-dataloader · GitHub

Open Graph Title: ScheduledDataLoaderRegistry ticker mode schedules one task per data loader on every dispatchAll(), so pending tasks grow with loaders × dispatch calls · Issue #290 · graphql-java/java-dataloader

X Title: ScheduledDataLoaderRegistry ticker mode schedules one task per data loader on every dispatchAll(), so pending tasks grow with loaders × dispatch calls · Issue #290 · graphql-java/java-dataloader

Description: Summary In ticker mode, each call to dispatchAll() starts a new self-rescheduling task for every registered data loader (dispatchOrReschedule → reschedule), and the chains already running from earlier calls keep going. After k calls with...

Open Graph Description: Summary In ticker mode, each call to dispatchAll() starts a new self-rescheduling task for every registered data loader (dispatchOrReschedule → reschedule), and the chains already running from earl...

X Description: Summary In ticker mode, each call to dispatchAll() starts a new self-rescheduling task for every registered data loader (dispatchOrReschedule → reschedule), and the chains already running from earl...

Opengraph URL: https://github.com/graphql-java/java-dataloader/issues/290

X: @github

direct link

Domain: github.com


Hey, it has json ld scripts:
{"@context":"https://schema.org","@type":"DiscussionForumPosting","headline":"ScheduledDataLoaderRegistry ticker mode schedules one task per data loader on every dispatchAll(), so pending tasks grow with loaders × dispatch calls","articleBody":"## Summary\n\nIn ticker mode, each call to `dispatchAll()` starts a new self-rescheduling task for **every** registered data loader (`dispatchOrReschedule` → `reschedule`), and the chains already running from earlier calls keep going. After `k` calls with `n` loaders, the executor holds `n × k` pending tasks, and each one re-runs every `schedule` until `close()`.\n\ngraphql-java's per-level dispatch calls `dispatchAll()` many times per request, so with ~200 loaders a single request leaves thousands of tasks on the shared scheduler thread for its whole lifetime.\n\nThe ticker contract only needs **one** periodic task per registry: \"after the first `dispatchAll()`, dispatch every `schedule` until closed\".\n\nVersion: java-dataloader 6.0.0, the latest release; `ScheduledDataLoaderRegistry` on `master` is unchanged since then. We hit this through Netflix DGS 12 with `dgs.graphql.dataloader.ticker-mode-enabled=true` and graphql-java 25.0.\n\n## Where\n\n`ScheduledDataLoaderRegistry` (6.0.0):\n\n```java\nprivate void reschedule(String key, DataLoader\u003c?, ?> dataLoader) {\n    if (!closed) {\n        Runnable runThis = () -> dispatchOrReschedule(key, dataLoader);\n        scheduledExecutorService.schedule(runThis, schedule.toMillis(), TimeUnit.MILLISECONDS);\n    }\n}\n\nprivate int dispatchOrReschedule(String key, DataLoader\u003c?, ?> dataLoader) {\n    ...\n    if (tickerMode || !shouldDispatch) {\n        reschedule(key, dataLoader);   // a new chain per loader on every dispatchAll(); existing chains continue too\n    }\n    return sum;\n}\n```\n\n`rescheduleNow()` has the same shape: one more chain per loader per call.\n\n## Reproducer\n\nThis needs only java-dataloader 6.0.0 (plus jspecify and reactive-streams) on the classpath and uses the default dispatch predicate. Run it with `java -cp 'lib/*' Repro.java`.\n\n\u003cdetails>\u003csummary>Repro.java\u003c/summary>\n\n```java\nimport java.time.Duration;\nimport java.util.concurrent.CompletableFuture;\nimport java.util.concurrent.ScheduledThreadPoolExecutor;\nimport java.util.concurrent.TimeUnit;\nimport org.dataloader.BatchLoader;\nimport org.dataloader.DataLoaderFactory;\nimport org.dataloader.registries.ScheduledDataLoaderRegistry;\n\n/**\n * Ticker-mode ScheduledDataLoaderRegistry: pending executor tasks grow with\n * (registered data loaders) x (dispatchAll() calls) and stay until close().\n *\n * Only java-dataloader on the classpath, default dispatch predicate:\n *   java -cp 'lib/*' Repro.java\n */\npublic class Repro {\n    static final int LOADERS = 200;\n    static final Duration TICK = Duration.ofMillis(15);\n\n    public static void main(String[] args) throws Exception {\n        System.out.println(ScheduledDataLoaderRegistry.class.getProtectionDomain().getCodeSource().getLocation().getPath()\n                + \", \" + LOADERS + \" data loaders, ticker mode, schedule \" + TICK.toMillis() + \" ms\");\n        System.out.printf(\"%-18s %16s %22s %22s%n\", \"dispatchAll calls\", \"pending tasks\", \"tasks run / second\", \"pending 1 tick after close\");\n        for (int calls : new int[] {1, 2, 10, 50}) {\n            run(calls);\n        }\n    }\n\n    static void run(int calls) throws Exception {\n        ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(1);\n        ScheduledDataLoaderRegistry registry = ScheduledDataLoaderRegistry.newScheduledRegistry()\n                .scheduledExecutorService(executor)\n                .tickerMode(true)\n                .schedule(TICK)\n                .build();\n        for (int i = 0; i \u003c LOADERS; i++) {\n            BatchLoader\u003cString, String> echo = keys -> CompletableFuture.completedFuture(keys);\n            registry.register(\"loader-\" + i, DataLoaderFactory.newDataLoader(\"loader-\" + i, echo));\n        }\n\n        // graphql-java calls dispatchAll() several times per request (once per dispatch point / level).\n        for (int i = 0; i \u003c calls; i++) {\n            registry.dispatchAll();\n        }\n\n        int pending = executor.getQueue().size();\n        long before = executor.getCompletedTaskCount();\n        TimeUnit.SECONDS.sleep(1);\n        long perSecond = executor.getCompletedTaskCount() - before;\n\n        registry.close();\n        TimeUnit.MILLISECONDS.sleep(TICK.toMillis() * 3);\n        int afterClose = executor.getQueue().size();\n\n        System.out.printf(\"%-18d %16d %22d %22d%n\", calls, pending, perSecond, afterClose);\n        executor.shutdownNow();\n    }\n}\n```\n\n\u003c/details>\n\nOutput: 200 loaders, 15 ms schedule, JDK 26, Apple M-series.\n\n| `dispatchAll()` calls | pending tasks, 6.0.0 | task runs/s, 6.0.0 | pending tasks, patched | task runs/s, patched |\n| --- | --- | --- | --- | --- |\n| 1 | 200 | 11,400 | 1 | 56 |\n| 2 | 400 | 22,800 | 1 | 56 |\n| 10 | 2,000 | 114,000 | 1 | 57 |\n| 50 | 10,000 | 590,000 | 1 | 58 |\n\n`close()` drains both variants within one tick, so a registry that is closed stops costing anything. The cost is incurred while requests are in flight, and it is permanent for a registry that is never closed.\n\n## End-to-end with graphql-java\n\n`Bench.java` (below) runs a graphql-java 25.0 workload with registries built the way DGS builds them in ticker mode:\n\n- one shared single-thread scheduler and a 15 ms schedule;\n- a registry predicate of `DISPATCH_NEVER` and a per-loader predicate of `DISPATCH_ALWAYS`;\n- 200 loaders, 20 items × 3 nested levels, and one chained \"late\" load per item that only a tick can dispatch;\n- 48 concurrent requests, with the registry closed when the request completes.\n\nThe patched numbers come from putting the patched class ahead of the jar on the classpath.\n\n| Metric | 6.0.0, 3 ms I/O | patched, 3 ms I/O | 6.0.0, 20 ms I/O | patched, 20 ms I/O |\n| --- | --- | --- | --- | --- |\n| Throughput (rps) | 327 | **594** | 296 | 283 |\n| Latency p50 / p99 (ms) | 140 / 225 | **78 / 127** | 157 / 208 | 166 / 211 |\n| Scheduled tasks per request | 2,381 | **4.0** | 3,956 | **9.0** |\n| Scheduler queue, peak / end | 59,137 / 3,400 | **82 / 2** | 56,580 / 1,200 | **83 / 8** |\n| Scheduler-thread CPU per request (ms) | 1.94 | **1.04** | 2.55 | **1.39** |\n\nThese are single laptop runs, so read the ratios rather than the absolute numbers.\n\nWhen the scheduler thread is the bottleneck, the patched registry roughly doubles throughput. When the workload is I/O-bound there is a small p50 cost. With thousands of staggered chains, some chain happens to fire much sooner than one `schedule` after a late load is queued. With a single tick, that load waits up to one `schedule`. Lowering `schedule` recovers this cheaply once there is a single tick per registry.\n\n\u003cdetails>\u003csummary>Bench.java\u003c/summary>\n\n```java\nimport com.sun.management.ThreadMXBean;\nimport graphql.ExecutionInput;\nimport graphql.GraphQL;\nimport graphql.schema.DataFetcher;\nimport graphql.schema.DataFetchingEnvironment;\nimport graphql.schema.idl.RuntimeWiring;\nimport graphql.schema.idl.SchemaGenerator;\nimport graphql.schema.idl.SchemaParser;\nimport java.lang.management.ManagementFactory;\nimport java.time.Duration;\nimport java.util.ArrayList;\nimport java.util.List;\nimport java.util.Locale;\nimport java.util.concurrent.CompletableFuture;\nimport java.util.concurrent.ConcurrentLinkedQueue;\nimport java.util.concurrent.Executor;\nimport java.util.concurrent.ExecutorService;\nimport java.util.concurrent.Executors;\nimport java.util.concurrent.ScheduledExecutorService;\nimport java.util.concurrent.ScheduledThreadPoolExecutor;\nimport java.util.concurrent.Semaphore;\nimport java.util.concurrent.TimeUnit;\nimport java.util.concurrent.atomic.AtomicInteger;\nimport java.util.concurrent.atomic.AtomicReference;\nimport java.util.stream.Collectors;\nimport java.util.stream.IntStream;\nimport org.dataloader.BatchLoader;\nimport org.dataloader.DataLoader;\nimport org.dataloader.DataLoaderFactory;\nimport org.dataloader.registries.DispatchPredicate;\nimport org.dataloader.registries.ScheduledDataLoaderRegistry;\n\n/**\n * graphql-java workload over a ticker-mode ScheduledDataLoaderRegistry, built the way Netflix DGS builds\n * per-request registries when dgs.graphql.dataloader.ticker-mode-enabled=true: one shared single-thread\n * scheduler, 15 ms schedule, registry predicate DISPATCH_NEVER, per-loader DISPATCH_ALWAYS, registry closed\n * when the request completes.\n *\n * The query fans out to FIELD_LOADERS loaders per item over DEPTH nested levels; each item also issues one\n * \"late\" load chained on another load's result, which only a tick can dispatch.\n *\n *   java -Xms2g -Xmx2g -cp 'lib/*' Bench.java --io-ms=3\n *   java -Xms2g -Xmx2g -cp 'patched/classes:lib/*' Bench.java --io-ms=3\n */\npublic class Bench {\n    static final int LOADERS = 200, FIELD_LOADERS = 10, ITEMS = 20, DEPTH = 3, WARMUP = 300;\n    static final Duration TICK = Duration.ofMillis(15);\n\n    public static void main(String[] args) throws Exception {\n        int requests = 3000, concurrency = 48;\n        long ioMs = 3;\n        for (String a : args) {\n            String[] kv = a.replaceFirst(\"^--\", \"\").split(\"=\", 2);\n            switch (kv[0]) {\n                case \"requests\" -> requests = Integer.parseInt(kv[1]);\n                case \"concurrency\" -> concurrency = Integer.parseInt(kv[1]);\n                case \"io-ms\" -> ioMs = Long.parseLong(kv[1]);\n                default -> throw new IllegalArgumentException(a);\n            }\n        }\n        String impl = ScheduledDataLoaderRegistry.class.getProtectionDomain().getCodeSource().getLocation().getPath();\n        System.out.printf(Locale.ROOT, \"registry class from %s%nrequests=%d concurrency=%d ioMs=%d loaders=%d items=%d depth=%d tick=%dms%n\",\n                impl, requests, concurrency, ioMs, LOADERS, ITEMS, DEPTH, TICK.toMillis());\n        new Bench(ioMs).measure(requests, concurrency);\n    }\n\n    final AtomicReference\u003cThread> schedulerThread = new AtomicReference\u003c>();\n    final ScheduledThreadPoolExecutor scheduler = new ScheduledThreadPoolExecutor(1, r -> {\n        Thread t = new Thread(r, \"dataloader-scheduler\");\n        schedulerThread.set(t);\n        return t;\n    });\n    final ExecutorService io = Executors.newVirtualThreadPerTaskExecutor();\n    final Executor ioDelay;\n    final GraphQL graphql = buildGraphQL();\n    final String query = \"{ items { \" + itemFields(DEPTH) + \" } }\";\n\n    Bench(long ioMs) {\n        ioDelay = CompletableFuture.delayedExecutor(ioMs, TimeUnit.MILLISECONDS, io);\n    }\n\n    void measure(int requests, int concurrency) throws Exception {\n        for (int i = 0; i \u003c WARMUP; i++) runOne().get();\n\n        ThreadMXBean threads = (ThreadMXBean) ManagementFactory.getThreadMXBean();\n        long tickerCpu0 = threads.getThreadCpuTime(schedulerThread.get().threadId());\n        long tasks0 = scheduler.getTaskCount();\n        AtomicInteger peakQueue = new AtomicInteger();\n        ScheduledExecutorService sampler = Executors.newSingleThreadScheduledExecutor();\n        sampler.scheduleAtFixedRate(() -> peakQueue.accumulateAndGet(scheduler.getQueue().size(), Math::max), 0, 5, TimeUnit.MILLISECONDS);\n\n        Semaphore permits = new Semaphore(concurrency);\n        ConcurrentLinkedQueue\u003cLong> latencies = new ConcurrentLinkedQueue\u003c>();\n        long t0 = System.nanoTime();\n        for (int i = 0; i \u003c requests; i++) {\n            permits.acquire();\n            runOne().whenComplete((ns, err) -> {\n                if (err == null) latencies.add(ns);\n                permits.release();\n            });\n        }\n        permits.acquire(concurrency);\n        double wallMs = (System.nanoTime() - t0) / 1e6;\n        int queueAtEnd = scheduler.getQueue().size();\n        sampler.shutdownNow();\n\n        double tickerCpuMs = (threads.getThreadCpuTime(schedulerThread.get().threadId()) - tickerCpu0) / 1e6;\n        List\u003cLong> sorted = new ArrayList\u003c>(latencies);\n        sorted.sort(null);\n        System.out.printf(Locale.ROOT, \"| throughput (rps) | %.0f |%n\", requests / (wallMs / 1000));\n        System.out.printf(Locale.ROOT, \"| latency p50 / p99 (ms) | %.0f / %.0f |%n\", pct(sorted, 0.5), pct(sorted, 0.99));\n        System.out.printf(Locale.ROOT, \"| scheduled tasks / request | %.1f |%n\", (scheduler.getTaskCount() - tasks0) / (double) requests);\n        System.out.printf(Locale.ROOT, \"| scheduler queue peak / end | %d / %d |%n\", peakQueue.get(), queueAtEnd);\n        System.out.printf(Locale.ROOT, \"| scheduler-thread CPU / request (ms) | %.2f |%n\", tickerCpuMs / requests);\n        scheduler.shutdownNow();\n        io.shutdownNow();\n    }\n\n    static double pct(List\u003cLong> sorted, double q) {\n        return sorted.get((int) ((sorted.size() - 1) * q)) / 1e6;\n    }\n\n    CompletableFuture\u003cLong> runOne() {\n        long start = System.nanoTime();\n        ScheduledDataLoaderRegistry registry = registry();\n        ExecutionInput input = ExecutionInput.newExecutionInput(query).dataLoaderRegistry(registry).build();\n        return graphql.executeAsync(input).thenApply(result -> {\n            if (!result.getErrors().isEmpty()) throw new IllegalStateException(result.getErrors().toString());\n            registry.close();\n            return System.nanoTime() - start;\n        });\n    }\n\n    ScheduledDataLoaderRegistry registry() {\n        ScheduledDataLoaderRegistry registry = ScheduledDataLoaderRegistry.newScheduledRegistry()\n                .scheduledExecutorService(scheduler)\n                .tickerMode(true)\n                .schedule(TICK)\n                .dispatchPredicate(DispatchPredicate.DISPATCH_NEVER)\n                .build();\n        for (int i = 0; i \u003c LOADERS; i++) {\n            String name = \"loader-\" + i;\n            BatchLoader\u003cInteger, Integer> loader = keys -> CompletableFuture.supplyAsync(() -> keys, ioDelay);\n            registry.register(name, DataLoaderFactory.newDataLoader(name, loader), DispatchPredicate.DISPATCH_ALWAYS);\n        }\n        return registry;\n    }\n\n    static String itemFields(int depth) {\n        String scalars = IntStream.range(0, FIELD_LOADERS).mapToObj(i -> \"f\" + i).collect(Collectors.joining(\" \")) + \" id late\";\n        return depth == 0 ? scalars : scalars + \" children { \" + itemFields(depth - 1) + \" }\";\n    }\n\n    static DataLoader\u003cInteger, Integer> loader(DataFetchingEnvironment env, String name) {\n        return env.getDataLoader(name);\n    }\n\n    GraphQL buildGraphQL() {\n        String sdl = \"type Query { items: [Item] }\\ntype Item { id: Int late: Int children: [Item] \"\n                + IntStream.range(0, FIELD_LOADERS).mapToObj(i -> \"f\" + i + \": Int\").collect(Collectors.joining(\" \")) + \" }\";\n        RuntimeWiring wiring = RuntimeWiring.newRuntimeWiring()\n                .type(\"Query\", t -> t.dataFetcher(\"items\", env -> IntStream.range(0, ITEMS).boxed().toList()))\n                .type(\"Item\", t -> {\n                    t.dataFetcher(\"id\", env -> env.getSource());\n                    for (int i = 0; i \u003c FIELD_LOADERS; i++) {\n                        String name = \"loader-\" + i;\n                        t.dataFetcher(\"f\" + i, (DataFetcher\u003c?>) env -> loader(env, name).load(env.\u003cInteger>getSource()));\n                    }\n                    t.dataFetcher(\"late\", env -> loader(env, \"loader-100\").load(env.\u003cInteger>getSource())\n                            .thenCompose(v -> loader(env, \"loader-101\").load(v)));\n                    t.dataFetcher(\"children\", env -> loader(env, \"loader-150\").load(env.\u003cInteger>getSource())\n                            .thenApply(id -> List.of(id * 10, id * 10 + 1, id * 10 + 2)));\n                    return t;\n                })\n                .build();\n        return GraphQL.newGraphQL(new SchemaGenerator().makeExecutableSchema(new SchemaParser().parse(sdl), wiring)).build();\n    }\n}\n```\n\n\u003c/details>\n\n## Production\n\nWe saw this on a production DGS 12 service with ~200 data loaders per request, a 15 ms schedule and a CPU-bound workload. We compared continuous-profiler samples, 8 pods × 60–120 s, before and after shipping the change below as a patched jar. Both sets were taken before an unrelated profiler-configuration change that affected heap and GC.\n\n| | 6.0.0 | patched |\n| --- | --- | --- |\n| CPU samples in `ScheduledThreadPoolExecutor` frames | 10.2% | 0.98% |\n| …on the scheduler thread (`DelayedWorkQueue.siftDown`/`compareTo` on a huge queue, plus tracer per-task overhead) | 6.6% | 0.95% |\n| …on request threads (enqueueing from `dispatchAll()`) | 3.5% | ~0.01% |\n| CPU samples with `ScheduledDataLoaderRegistry` frames | 6.8% | 2.1% |\n| Live `ScheduledFutureTask`s after GC, per pod (JFR `ObjectCountAfterGC`) | 420k–1.06M | below the histogram's reporting threshold |\n\nAPM tracers that wrap every scheduled task, such as dd-trace's context propagation, multiply the per-task cost. That makes the effect larger in production than in the benchmark.\n\nWhat remains on the scheduler thread after the change is the tick itself: iterating the loaders and evaluating `shouldDispatch`.\n\n## Proposed fix\n\nIn ticker mode, keep at most one pending tick per registry. Each tick re-arms itself, then calls `dispatchAllWithCount()`, which still applies every registry-level and per-loader predicate. Non-ticker mode is unchanged.\n\n```diff\n+import java.util.concurrent.atomic.AtomicBoolean;\n ...\n     private volatile boolean closed;\n+    private final AtomicBoolean tickScheduled = new AtomicBoolean();\n ...\n     public void rescheduleNow() {\n-        dataLoaders.forEach(this::reschedule);\n+        if (tickerMode) {\n+            scheduleTick();\n+        } else {\n+            dataLoaders.forEach(this::reschedule);\n+        }\n     }\n ...\n     private int dispatchOrReschedule(String key, DataLoader\u003c?, ?> dataLoader) {\n         ...\n-        if (tickerMode || !shouldDispatch) {\n+        if (tickerMode) {\n+            scheduleTick();\n+        } else if (!shouldDispatch) {\n             reschedule(key, dataLoader);\n         }\n         return sum;\n     }\n+\n+    private void scheduleTick() {\n+        if (!closed && tickScheduled.compareAndSet(false, true)) {\n+            scheduledExecutorService.schedule(this::tick, schedule.toMillis(), TimeUnit.MILLISECONDS);\n+        }\n+    }\n+\n+    private void tick() {\n+        tickScheduled.set(false);\n+        // re-arm before dispatching so that a data loader throwing on dispatch cannot stop the ticker\n+        scheduleTick();\n+        dispatchAllWithCount();\n+    }\n```\n\nBehaviour this preserves:\n\n- In ticker mode, after the first `dispatchAll()`, every loader whose predicate passes is dispatched at least every `schedule` until `close()`.\n- `close()` stops further ticks. The pending tick runs once more, sees `closed` and does not re-arm. An explicit `dispatchAll()` after close still dispatches.\n- In non-ticker mode, per-loader rescheduling continues only while the predicate says no, exactly as today.\n\nWe have run this patched class in production since 2026-10-15. Tests cover:\n\n- one pending task after many `dispatchAll()` and `rescheduleNow()` calls;\n- a load issued after `dispatchAll()` completing on the next tick;\n- the ticker surviving a predicate that throws during a tick;\n- `close()` stopping the ticker while `dispatchAll()` still dispatches.\n\nHappy to open a PR with these tests if this direction works for you.\n","author":{"url":"https://github.com/Meemaw","@type":"Person","name":"Meemaw"},"datePublished":"2026-10-16T08:24:13Z","url":"https://github.com/graphql-java/java-dataloader/issues/290"}

react-profiling0
react-import-mapreact,react-dom,react-dom/client,react-dom/profiling,react-is,react/compiler-runtime,react/jsx-dev-runtime,react/jsx-runtime,scheduler@b8488ee2c322
route-pattern/_view_fragments/issues/show/:user_id/:repository/:id/issue_layout(.:format)
route-controllervoltron_issues_fragments
route-actionissue_layout
fetch-noncev2:bb35e166-ad8d-9d47-3a67-bb68ac0761cd
current-catalog-service-hash81bb79d38c15960b92d99bca9288a9108c7a47b18f2423d0f6438c5b7bcd2114
request-idE1CC:D1D28:2B4A24:398A68:6B018E3A
html-safe-nonce2b9195eeffccf5c0fae27a07172c217bfc5fc1aa70ba41c775a7f898c767eb9a
visitor-payloadeyJyZWZlcnJlciI6IiIsInJlcXVlc3RfaWQiOiJFMUNDOkQxRDI4OjJCNEEyNDozOThBNjg6NkIwMThFM0EiLCJ2aXNpdG9yX2lkIjoiNzY4MjczOTA2ODgxOTU3NDMzMCIsInJlZ2lvbl9lZGdlIjoiaWFkIiwicmVnaW9uX3JlbmRlciI6ImlhZCJ9
visitor-hmacda74a8b4a55b2938f29a03e8373cb2d01f0707cb830a06f64d46573e576f5602
hovercard-subject-tagissue:5880853458
github-keyboard-shortcutsrepository,issues,copilot
google-site-verificationApib7-x98H0j5cPqHWwSMm6dNU4GmODRoqxLiDzdx9I
octolytics-urlhttps://collector.github.com/github/collect
analytics-location///voltron/issues_fragments/issue_layout
fb:app_id1401488693436528
apple-itunes-appapp-id=1477376905, app-argument=https://github.com/_view_fragments/issues/show/graphql-java/java-dataloader/290/issue_layout
twitter:imagehttps://opengraph.githubassets.com/8fe04a25b8ffb82cfaf707f0bd0e5d50c371cbff0a45d201ce853e01914e43aa/graphql-java/java-dataloader/issues/290
twitter:cardsummary_large_image
og:imagehttps://opengraph.githubassets.com/8fe04a25b8ffb82cfaf707f0bd0e5d50c371cbff0a45d201ce853e01914e43aa/graphql-java/java-dataloader/issues/290
og:image:altSummary In ticker mode, each call to dispatchAll() starts a new self-rescheduling task for every registered data loader (dispatchOrReschedule → reschedule), and the chains already running from earl...
og:image:width1200
og:image:height600
og:site_nameGitHub
og:typeobject
og:author:usernameMeemaw
hostnamegithub.com
expected-hostnamegithub.com
Nonecc5dfdd32f62ebd3223cab3af3aa2b268d3605218237326a48a99d1efd89495c
turbo-cache-controlno-preview
go-importgithub.com/graphql-java/java-dataloader git https://github.com/graphql-java/java-dataloader.git
octolytics-dimension-user_id14289921
octolytics-dimension-user_logingraphql-java
octolytics-dimension-repository_id97364654
octolytics-dimension-repository_nwographql-java/java-dataloader
octolytics-dimension-repository_publictrue
octolytics-dimension-repository_is_forkfalse
octolytics-dimension-repository_network_root_id97364654
octolytics-dimension-repository_network_root_nwographql-java/java-dataloader
turbo-body-classeslogged-out env-production page-responsive
disable-turbofalse
browser-stats-urlhttps://api.github.com/_private/browser/stats
browser-errors-urlhttps://api.github.com/_private/browser/errors
release8c77c9e8439031ad54c75a250694842892f693e1
ui-targetfull
theme-color#1e2327
color-schemelight dark
react-app-nameissues

Links:

Skip to contenthttps://github.com/graphql-java/java-dataloader/issues/290#start-of-content
https://github.com/
Sign inhttps://github.com/login?return_to=https%3A%2F%2Fgithub.com%2Fgraphql-java%2Fjava-dataloader%2Fissues%2F290
GitHubRepository hosting, code review, and collaborationhttps://github.com/platform
CopilotAI coding agent for tasks, projects, and automated workhttps://github.com/features/copilot
ActionsCI/CD and automationhttps://github.com/features/actions
Code QualityQuality analysis, fixes, and enforcementhttps://github.com/features/code-quality
CodespacesCloud development environmentshttps://github.com/features/codespaces
Code SecurityVulnerability detection and remediationhttps://github.com/security/advanced-security/code-security
Secret ProtectionSecret scanning and leak preventionhttps://github.com/security/advanced-security/secret-protection
All Featureshttps://github.com/features
Documentationhttps://docs.github.com/en
Traininghttps://learn.github.com/skills
Certificationshttps://learn.github.com/credentials
Build with Copilothttps://github.com/features/ai
Customize Copilothttps://docs.github.com/en/copilot/how-tos/copilot-on-github/customize-copilot/customize-copilot-overview
Integrationshttps://github.com/marketplace
Trending reposhttps://github.com/trending
GitHub Sponsorshttps://github.com/open-source/sponsors
Developer articleshttps://github.com/resources/articles
ChangelogYour source for the latest features, improvements, and fixes across GitHub products, all in one place.https://github.blog/changelog/
Enterpriseshttps://github.com/enterprise
Teamhttps://github.com/team
Startupshttps://github.com/enterprise/startups
Nonprofitshttps://github.com/solutions/industry/nonprofits
Healthcarehttps://github.com/solutions/industry/healthcare
Financial serviceshttps://github.com/solutions/industry/financial-services
Manufacturinghttps://github.com/solutions/industry/manufacturing
Governmenthttps://github.com/solutions/industry/government
See all industrieshttps://github.com/solutions/industry
Why GitHubhttps://github.com/why-github
Customer Storieshttps://github.com/customer-stories
Business insightshttps://github.com/solutions/executive-insights
Trust Centerhttps://github.com/trust-center
GitHub Advanced SecurityEnterprise-grade code securityhttps://github.com/security/advanced-security
Copilot for businessEnterprise-grade AI featureshttps://github.com/features/copilot/copilot-business
Premium SupportEnterprise-grade 24/7 supporthttps://github.com/enterprise/premium-support
Documentationhttps://docs.github.com/en
Resource centerhttps://github.com/resources
Bloghttps://github.blog/
Events & webinarshttps://github.com/resources/events
Community Forumhttps://github.com/orgs/community/discussions
Customer Storieshttps://github.com/customer-stories
Integrationshttps://github.com/marketplace
Customer supporthttps://help.github.com/
Traininghttps://learn.github.com/skills
GitHub Statushttps://www.githubstatus.com/
Abouthttps://github.com/about
Partnershttps://github.com/partners
Changeloghttps://github.blog/changelog/
GitHub UniverseThe event for developers, by developers — talks, workshops, and what’s next for GitHub.https://githubuniverse.com/
Pricinghttps://github.com/pricing
Sign inhttps://github.com/login?return_to=https%3A%2F%2Fgithub.com%2Fgraphql-java%2Fjava-dataloader%2Fissues%2F290
Sign uphttps://github.com/signup?ref_cta=Sign+up&ref_loc=header+logged+out&ref_page=%2F%3Cuser-name%3E%2F%3Crepo-name%3E%2Fvoltron%2Fissues_fragments%2Fissue_layout&source=header-repo&source_repo=graphql-java%2Fjava-dataloader
Reloadhttps://github.com/graphql-java/java-dataloader/issues/290
Reloadhttps://github.com/graphql-java/java-dataloader/issues/290
Reloadhttps://github.com/graphql-java/java-dataloader/issues/290
graphql-javahttps://github.com/graphql-java
java-dataloaderhttps://github.com/graphql-java/java-dataloader
Codehttps://github.com/graphql-java/java-dataloader
Issues2 (2)https://github.com/graphql-java/java-dataloader/issues
Pull requests18 (18)https://github.com/graphql-java/java-dataloader/pulls
Discussionshttps://github.com/graphql-java/java-dataloader/discussions
Actionshttps://github.com/graphql-java/java-dataloader/actions
Projectshttps://github.com/graphql-java/java-dataloader/projects
Wikihttps://github.com/graphql-java/java-dataloader/wiki
Security and qualityhttps://github.com/graphql-java/java-dataloader/security
Insightshttps://github.com/graphql-java/java-dataloader/insights
https://github.com/graphql-java/java-dataloader
New issuehttps://github.com/login?return_to=https://github.com/graphql-java/java-dataloader/issues/290
New issuehttps://github.com/login?return_to=https://github.com/graphql-java/java-dataloader/issues/290
#291https://github.com/graphql-java/java-dataloader/pull/291
ScheduledDataLoaderRegistry ticker mode schedules one task per data loader on every dispatchAll(), so pending tasks grow with loaders × dispatch callshttps://github.com/graphql-java/java-dataloader/issues/290#top
#291https://github.com/graphql-java/java-dataloader/pull/291
https://github.com/Meemaw
Meemawhttps://github.com/Meemaw
on Oct 16, 2026https://github.com/graphql-java/java-dataloader/issues/290#issue-5880853458
bbakermanhttps://github.com/bbakerman
completedhttps://github.com/graphql-java/java-dataloader/issues?q=is%3Aissue%20state%3Aclosed%20archived%3Afalse%20reason%3Acompleted
#291https://github.com/graphql-java/java-dataloader/pull/291
on Oct 19, 2026https://github.com/graphql-java/java-dataloader/issues/290#event-33618472901
Sign up for freehttps://github.com/signup?return_to=https://github.com/graphql-java/java-dataloader/issues/290
Sign in to commenthttps://github.com/login?return_to=https://github.com/graphql-java/java-dataloader/issues/290
https://github.com
Termshttps://docs.github.com/site-policy/github-terms/github-terms-of-service
Privacyhttps://docs.github.com/site-policy/privacy-policies/github-privacy-statement
Securityhttps://github.com/security
Statushttps://www.githubstatus.com/
Communityhttps://github.community/
Docshttps://docs.github.com/
Contacthttps://support.github.com?tags=dotcom-footer

Viewport: width=device-width


URLs of crawlers that visited me.