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
Domain: github.com
{"@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-profiling | 0 |
| react-import-map | react,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-controller | voltron_issues_fragments |
| route-action | issue_layout |
| fetch-nonce | v2:bb35e166-ad8d-9d47-3a67-bb68ac0761cd |
| current-catalog-service-hash | 81bb79d38c15960b92d99bca9288a9108c7a47b18f2423d0f6438c5b7bcd2114 |
| request-id | E1CC:D1D28:2B4A24:398A68:6B018E3A |
| html-safe-nonce | 2b9195eeffccf5c0fae27a07172c217bfc5fc1aa70ba41c775a7f898c767eb9a |
| visitor-payload | eyJyZWZlcnJlciI6IiIsInJlcXVlc3RfaWQiOiJFMUNDOkQxRDI4OjJCNEEyNDozOThBNjg6NkIwMThFM0EiLCJ2aXNpdG9yX2lkIjoiNzY4MjczOTA2ODgxOTU3NDMzMCIsInJlZ2lvbl9lZGdlIjoiaWFkIiwicmVnaW9uX3JlbmRlciI6ImlhZCJ9 |
| visitor-hmac | da74a8b4a55b2938f29a03e8373cb2d01f0707cb830a06f64d46573e576f5602 |
| hovercard-subject-tag | issue:5880853458 |
| github-keyboard-shortcuts | repository,issues,copilot |
| google-site-verification | Apib7-x98H0j5cPqHWwSMm6dNU4GmODRoqxLiDzdx9I |
| octolytics-url | https://collector.github.com/github/collect |
| analytics-location | / |
| fb:app_id | 1401488693436528 |
| apple-itunes-app | app-id=1477376905, app-argument=https://github.com/_view_fragments/issues/show/graphql-java/java-dataloader/290/issue_layout |
| twitter:image | https://opengraph.githubassets.com/8fe04a25b8ffb82cfaf707f0bd0e5d50c371cbff0a45d201ce853e01914e43aa/graphql-java/java-dataloader/issues/290 |
| twitter:card | summary_large_image |
| og:image | https://opengraph.githubassets.com/8fe04a25b8ffb82cfaf707f0bd0e5d50c371cbff0a45d201ce853e01914e43aa/graphql-java/java-dataloader/issues/290 |
| og:image:alt | 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... |
| og:image:width | 1200 |
| og:image:height | 600 |
| og:site_name | GitHub |
| og:type | object |
| og:author:username | Meemaw |
| hostname | github.com |
| expected-hostname | github.com |
| None | cc5dfdd32f62ebd3223cab3af3aa2b268d3605218237326a48a99d1efd89495c |
| turbo-cache-control | no-preview |
| go-import | github.com/graphql-java/java-dataloader git https://github.com/graphql-java/java-dataloader.git |
| octolytics-dimension-user_id | 14289921 |
| octolytics-dimension-user_login | graphql-java |
| octolytics-dimension-repository_id | 97364654 |
| octolytics-dimension-repository_nwo | graphql-java/java-dataloader |
| octolytics-dimension-repository_public | true |
| octolytics-dimension-repository_is_fork | false |
| octolytics-dimension-repository_network_root_id | 97364654 |
| octolytics-dimension-repository_network_root_nwo | graphql-java/java-dataloader |
| turbo-body-classes | logged-out env-production page-responsive |
| disable-turbo | false |
| browser-stats-url | https://api.github.com/_private/browser/stats |
| browser-errors-url | https://api.github.com/_private/browser/errors |
| release | 8c77c9e8439031ad54c75a250694842892f693e1 |
| ui-target | full |
| theme-color | #1e2327 |
| color-scheme | light dark |
| react-app-name | issues |
Links:
Viewport: width=device-width