Tagged articles
Runnable
16 articles · Page 1 of 1
This article systematically explains LangChain’s four fundamental design patterns—Command, Chain of Responsibility, Decorator, and Pipeline—showing their definitions, core implementations, and practical code examples to help developers understand and extend the framework.
Chain of ResponsibilityCommandDecorator
0 likes · 34 min read

The article explains LCEL’s core design and the Runnable interface, showing how they unify prompts, models, and parsers into a single composable chain with built‑in streaming, batch, async support, parallel execution, type inference, and automatic tracing, illustrated with TypeScript examples.
AILCELLangChain
0 likes · 13 min read

This article explains three common ways to create multithreaded Java programs—extending Thread, implementing Runnable, and using Lambda expressions—providing step‑by‑step instructions, code samples, console output, and a summary of each method’s advantages and appropriate use cases.
JavaMultithreadingRunnable
0 likes · 6 min read

This article explains the Runnable interface in Langchain.js v0.3, shows how to implement custom Runnables with code examples, and demonstrates chaining them to create reusable, asynchronous workflows for front‑end AI applications.
Code ExampleFrontend DevelopmentJavaScript
0 likes · 6 min read

The article clarifies Java processes and threads using a game analogy, then demonstrates three thread‑creation techniques—extending Thread, implementing Runnable, and implementing Callable with FutureTask—while covering run vs start, thread control methods such as sleep, join, and daemon settings.
JavaMultithreadingRunnable
0 likes · 9 min read

This article explains the fundamental concepts of processes and threads, uses a gaming analogy to illustrate their relationship, and details three ways to create threads in Java—extending Thread, implementing Runnable, and implementing Callable—along with common thread control methods such as sleep, join, and setDaemon.
ConcurrencyJavaRunnable
0 likes · 9 min read

This article explains why ThreadLocal variables can lose their values when used across thread pools, and demonstrates how to create custom Runnable and Callable wrappers that propagate HystrixRequestContext to ensure reliable ThreadLocal transmission in multithreaded Java environments.
ConcurrencyContextPropagationHystrix
0 likes · 8 min read

This article provides a comprehensive guide to Java's ThreadPoolExecutor, covering its lifecycle states, constructor arguments, work‑queue options, keep‑alive behavior, thread factories, rejection policies, common methods, and practical code examples for Callable, Runnable, Future and FutureTask.
ExecutorServiceFutureFutureTask
0 likes · 20 min read

This article explains how to implement Java multithreading using the Runnable interface through a ticket‑booking example, demonstrates common pitfalls like calling run() directly, shows code with and without Thread.sleep, and discusses concurrency issues such as thread‑unsafe ticket duplication.
ConcurrencyJavaRunnable
0 likes · 10 min read

Through a whimsical first‑person narrative, the article explains three Java thread‑creation techniques—extending Thread, implementing Runnable (including anonymous and lambda forms), and using Callable with FutureTask—to illustrate their syntax, usage, and the ability to retrieve thread results.
ConcurrencyJavaRunnable
0 likes · 7 min read

This article explains the distinction between Java's RUNNABLE thread state and the operating‑system concepts of ready, running, and waiting, covering JVM‑level definitions, I/O blocking behavior, time‑slice scheduling, and includes concrete code examples to illustrate how blocked I/O still appears as RUNNABLE.
I/OJVMRunnable
0 likes · 12 min read

This article explains the three primary techniques for creating threads in Java—subclassing Thread, implementing the Runnable interface, and using Callable with Future—provides complete code examples for each method, and compares their advantages and disadvantages for practical multithreading development.
FutureJavaRunnable
0 likes · 8 min read

This article explains three Java thread‑creation techniques—extending the Thread class, implementing the Runnable interface, and implementing the Callable interface—provides complete code examples for each, compares their advantages and disadvantages, and recommends the best practice for concurrent programming.
ConcurrencyJavaRunnable
0 likes · 6 min read

This article explains the Java RUNNABLE thread state, how it differs from traditional OS ready/running states, its relationship with time‑slicing, blocking I/O, and why the JVM reports many blocked operations as RUNNABLE, illustrated with code examples and diagrams.
JVMJavaRunnable
0 likes · 12 min read

This article explains how to create and start Java threads by directly instantiating Thread, extending the Thread class, implementing the Runnable interface, handling common pitfalls such as calling run() instead of start(), and demonstrates naming threads and using thread pools with clear code examples.
JavaMultithreadingRunnable
0 likes · 7 min read

This article compares Java's Callable and Runnable interfaces, demonstrates how Future.get() blocks, shows alternative submit methods, and provides complete code examples illustrating return values, task completion checks, and practical usage of ThreadPoolExecutor.
FutureRunnableThreadPoolExecutor
0 likes · 5 min read
