{"title":"Creating Threads in Java","description":"","content":"Java was built with threading in mind from day one. Unlike languages that bolted on concurrency later, Java's thread support is woven into the JVM itself. \n\nEvery Java program starts with at least one thread (the main thread), and the JVM runs several background threads for garbage collection, finalization, and JIT compilation. Understanding how to create and manage threads is foundational to writing concurrent Java applications.\n\nThis chapter dives deep into creating threads in Java. \n\n---\n\n# The Thread Class\n\nAt the heart of Java's threading model is the `java.lang.Thread` class. Every thread in a Java program is represented by an instance of this class or one of its subclasses.\n\n### Thread Constructors\n\nThe Thread class provides eight public constructors, though you'll primarily use just a few:\n\n\n```java\n// Most common constructors\nThread() // Empty thread (must override run())\nThread(Runnable target) // Thread with a task\nThread(Runnable target, String name) // Task with a name\nThread(String name) // Named thread (must override run())\n\n// ThreadGroup constructors (less common, legacy)\nThread(ThreadGroup group, Runnable target)\nThread(ThreadGroup group, Runnable target, String name)\nThread(ThreadGroup group, Runnable target, String name, long stackSize)\nThread(ThreadGroup group, String name)\n```\n\n\nThe `stackSize` parameter is a hint to the JVM about how much stack space to allocate for the thread. The JVM may ignore it, and behavior varies across platforms. On 64-bit systems, the default is typically 1MB. You might reduce it when creating many threads to save memory, or increase it for deeply recursive algorithms.\n\n\n```java\n// Creating a thread with custom stack size (512KB)\nThread t = new Thread(null, task, \"RecursiveWorker\", 512 * 1024);\n```\n\n\n### Key Thread Properties\n\nEvery thread has several properties that affect its behavior:\n\n#### **Name**\n\nA human-readable identifier used for debugging. If you don't set one, Java generates names like \"Thread-0\", \"Thread-1\", etc.\n\n\n```java\nThread t = new Thread(task);\nt.setName(\"OrderProcessor-1\");\n\n// Or in constructor\nThread t = new Thread(task, \"OrderProcessor-1\");\n\n// Get current thread's name\nString name = Thread.currentThread().getName();\n```\n\n\n#### **Priority**\n\nAn integer from 1 to 10 that hints to the scheduler how important this thread is. Higher priority threads may get more CPU time, but this is platform-dependent and not a guarantee.\n\n\n```java\nThread t = new Thread(task);\nt.setPriority(Thread.MAX_PRIORITY); // 10\nt.setPriority(Thread.NORM_PRIORITY); // 5 (default)\nt.setPriority(Thread.MIN_PRIORITY); // 1\n```\n\n\n#### **Daemon Status**\n\nDetermines whether the thread prevents JVM shutdown. Daemon threads are killed when all user threads complete.\n\n\n```java\nThread t = new Thread(task);\nt.setDaemon(true); // Must set before start()\n```\n\n\n#### **Thread ID**\n\nA unique positive long number generated when the thread is created. Unlike names, IDs are guaranteed unique.\n\n\n```java\nlong id = Thread.currentThread().getId();\n```\n\n\n### Thread States\n\nA Java thread can be in one of six states, defined in the `Thread.State` enum:\n\n\n```mermaid\nstateDiagram-v2\n [*] --> NEW: Thread created\n\n NEW --> RUNNABLE: start() called\n\n RUNNABLE --> BLOCKED: Waiting for
monitor lock\n BLOCKED --> RUNNABLE: Lock acquired\n\n RUNNABLE --> WAITING: wait(), join(),
park()\n WAITING --> RUNNABLE: notify(), unpark(),
join completes\n\n RUNNABLE --> TIMED_WAITING: sleep(ms),
wait(ms), join(ms)\n TIMED_WAITING --> RUNNABLE: Timeout expires
or notified\n\n RUNNABLE --> TERMINATED: run() completes
or exception\n\n TERMINATED --> [*]\n\n classDef newState fill:#ffd43b,stroke:#000,color:#000\n classDef runnableState fill:#69db7c,stroke:#000,color:#000\n classDef blockedState fill:#ff8787,stroke:#000,color:#000\n classDef waitingState fill:#ffa94d,stroke:#000,color:#000\n classDef timedState fill:#9775fa,stroke:#000,color:#000\n classDef termState fill:#38d9a9,stroke:#000,color:#000\n\n class NEW newState\n class RUNNABLE runnableState\n class BLOCKED blockedState\n class WAITING waitingState\n class TIMED_WAITING timedState\n class TERMINATED termState\n```\n\n\n\n| State | Description |\n|-------|-------------|\n| NEW | Thread created but `start()` not yet called |\n| RUNNABLE | Executing or ready to execute (waiting for CPU) |\n| BLOCKED | Waiting to acquire a monitor lock (synchronized block) |\n| WAITING | Waiting indefinitely for another thread |\n| TIMED_WAITING | Waiting with a timeout |\n| TERMINATED | Completed execution (normally or via exception) |\n\n\nYou can query a thread's state at any time:\n\n\n```java\nThread t = new Thread(task);\nSystem.out.println(t.getState()); // NEW\n\nt.start();\nSystem.out.println(t.getState()); // RUNNABLE (probably)\n\nt.join();\nSystem.out.println(t.getState()); // TERMINATED\n```\n\n\n\n> **TIP**\n>\n> The RUNNABLE state includes both threads that are actually running on a CPU and threads that are ready to run but waiting for a CPU. Java doesn't distinguish between \"running\" and \"ready\" because this is an OS-level detail that changes constantly.\n\n\n---\n\n# Three Ways to Create Threads\n\nJava provides three fundamental approaches to defining what a thread should do: extending Thread, implementing Runnable, and implementing Callable.\n\n### Extending Thread\n\nThe most direct approach is to create a subclass of Thread and override the `run()` method:\n\n\n```java\npublic class DataProcessor extends Thread {\n private final String data;\n\n public DataProcessor(String data) {\n super(\"DataProcessor-\" + data.hashCode()); // Set thread name\n this.data = data;\n }\n\n @Override\n public void run() {\n System.out.println(\"Processing: \" + data);\n // Do actual processing\n }\n}\n\n// Usage\nDataProcessor processor = new DataProcessor(\"order-123\");\nprocessor.start();\n```\n\n\nThis approach works but has significant drawbacks:\n\n1. **Single inheritance limitation**: Java allows only one superclass. If your class extends Thread, it can't extend anything else.\n2. **Tight coupling**: The task logic is bound to the Thread class, making it harder to test and reuse.\n3. **Poor separation of concerns**: Mixes \"what to do\" with \"how to run it.\"\n\n**When to use:** Almost never. There are rare cases where you need to customize Thread behavior itself (custom scheduling, specialized cleanup), but these are uncommon.\n\n### Implementing Runnable\n\nThe preferred approach separates the task from the execution mechanism:\n\n\n```java\npublic class OrderTask implements Runnable {\n private final Order order;\n\n public OrderTask(Order order) {\n this.order = order;\n }\n\n @Override\n public void run() {\n System.out.println(\"Processing order: \" + order.getId());\n order.process();\n }\n}\n\n// Usage with Thread\nThread t = new Thread(new OrderTask(order), \"OrderWorker\");\nt.start();\n```\n\n\nWith Java 8's lambda expressions, simple tasks become one-liners:\n\n\n```java\n// Lambda syntax for simple tasks\nThread t = new Thread(() -> {\n System.out.println(\"Processing in \" + Thread.currentThread().getName());\n});\nt.start();\n\n// Method reference\nThread t = new Thread(order::process);\nt.start();\n```\n\n\nThe Runnable approach is preferred because:\n\n1. **Flexibility**: The same Runnable can be used with raw threads, executors, thread pools, or any other execution mechanism.\n2. **Inheritance freedom**: Your class can extend whatever it needs.\n3. **Testability**: You can test the run() method directly without threading concerns.\n4. **Clarity**: It's obvious that you're defining a task, not a special kind of thread.\n\n### Implementing Callable\n\nWhat if your task needs to return a result or throw a checked exception? That's where Callable comes in:\n\n\n```java\npublic class PriceCalculator implements Callable {\n private final Order order;\n\n public PriceCalculator(Order order) {\n this.order = order;\n }\n\n @Override\n public BigDecimal call() throws PricingException {\n // Calculate total price\n BigDecimal total = order.getItems().stream()\n .map(item -> item.getPrice().multiply(BigDecimal.valueOf(item.getQuantity())))\n .reduce(BigDecimal.ZERO, BigDecimal::add);\n\n // Apply discounts (might throw checked exception)\n return applyDiscounts(total);\n }\n\n private BigDecimal applyDiscounts(BigDecimal total) throws PricingException {\n // ...\n }\n}\n```\n\n\nUnlike Runnable, you can't pass a Callable directly to a Thread constructor. Instead, use an ExecutorService:\n\n\n```java\nExecutorService executor = Executors.newSingleThreadExecutor();\n\n// Submit returns a Future\nFuture future = executor.submit(new PriceCalculator(order));\n\n// Do other work while calculation runs...\n\ntry {\n // Get the result (blocks until complete)\n BigDecimal price = future.get();\n System.out.println(\"Total: \" + price);\n} catch (ExecutionException e) {\n // Handle PricingException wrapped in ExecutionException\n Throwable cause = e.getCause();\n if (cause instanceof PricingException) {\n System.err.println(\"Pricing failed: \" + cause.getMessage());\n }\n} finally {\n executor.shutdown();\n}\n```\n\n\nThe diagram below shows how Runnable and Callable differ in their interaction with the execution framework:\n\n\n```mermaid\nflowchart LR\n subgraph Callable[\"Callable Pattern\"]\n\t\tdirection LR\n C1[Callable]\n C2[ExecutorService]\n C3[\"call(): V\"]\n C4[Future]\n C5[\"get(): V\"]\n\n C1 --> C2\n C2 --> C3\n C3 --> C4\n C4 --> C5\n end\n\t\n subgraph Runnable[\"Runnable Pattern\"]\n\t\tdirection LR\n R1[Runnable]\n R2[Thread or Executor]\n R3[run: void]\n R4[No return value]\n\n R1 --> R2\n R2 --> R3\n R3 --> R4\n end\t\n\n style R1 fill:#00ceff,stroke:#000,color:#000\n style R2 fill:#ffa94d,stroke:#000,color:#000\n style R3 fill:#69db7c,stroke:#000,color:#000\n style R4 fill:#ff8787,stroke:#000,color:#000\n\n style C1 fill:#00ceff,stroke:#000,color:#000\n style C2 fill:#ffa94d,stroke:#000,color:#000\n style C3 fill:#69db7c,stroke:#000,color:#000\n style C4 fill:#9775fa,stroke:#000,color:#000\n style C5 fill:#38d9a9,stroke:#000,color:#000\n```\n\n\n### Comparison: Runnable vs Callable\n\n\n| Aspect | Runnable | Callable |\n|--------|----------|----------|\n| Method signature | `void run()` | `V call() throws Exception` |\n| Return value | None | Generic type V |\n| Checked exceptions | Cannot throw | Can throw |\n| Use with Thread | Direct | Must wrap in FutureTask |\n| Use with Executor | `execute()` or `submit()` | `submit()` only |\n| Result retrieval | Shared variables, manual sync | Future.get() |\n| Introduced in | Java 1.0 | Java 5 |\n\n\n**When to use each:**\n\n- **Runnable**: Fire-and-forget tasks, tasks that communicate results via shared state\n- **Callable**: Tasks that produce results, tasks that may throw checked exceptions\n\n---\n\n# Thread Configuration\n\nBeyond the basics, Java provides several configuration options that affect how threads behave.\n\n### Naming Conventions\n\nGood thread names are invaluable for debugging. When you're looking at a thread dump from a production server with hundreds of threads, meaningful names are the difference between finding the problem in minutes versus hours.\n\n\n```java\n// Bad - generic names tell you nothing\nThread t = new Thread(task); // Becomes \"Thread-0\"\n\n// Good - descriptive names\nThread t = new Thread(task, \"OrderProcessor-CustomerA-1\");\nThread t = new Thread(task, \"EmailSender-Marketing\");\nThread t = new Thread(task, \"DB-ConnectionPool-3\");\n```\n\n\nCommon patterns:\n\n- `{Component}-{Function}-{Number}`: \"PaymentService-Processor-1\"\n- `{Pool}-{Number}`: \"HTTP-Worker-5\"\n- `{Feature}-{ID}`: \"UserSession-abc123\"\n\n### Thread Priority\n\nThread priority is a hint to the scheduler, not a guarantee. The JVM maps Java's 1-10 scale to OS-specific priorities, and the mapping varies:\n\n\n```java\nThread highPriority = new Thread(urgentTask);\nhighPriority.setPriority(Thread.MAX_PRIORITY); // 10\n\nThread lowPriority = new Thread(backgroundTask);\nlowPriority.setPriority(Thread.MIN_PRIORITY); // 1\n\nThread normal = new Thread(regularTask);\n// Priority defaults to NORM_PRIORITY (5)\n```\n\n\n**Important caveats:**\n\n1. On Linux, you need root privileges to raise thread priority above normal.\n2. Priority differences matter mainly under CPU contention.\n3. Relying on priority for correctness is a design smell. Use proper synchronization instead.\n4. Starvation is possible if high-priority threads never yield.\n\n### Daemon Threads\n\nDaemon threads are service threads that run in the background and don't prevent JVM shutdown. The JVM exits when only daemon threads remain.\n\n\n```java\nThread daemon = new Thread(() -> {\n while (true) {\n cleanupExpiredCache();\n try {\n Thread.sleep(60000);\n } catch (InterruptedException e) {\n return; // Exit cleanly\n }\n }\n});\ndaemon.setDaemon(true); // Must set BEFORE start()\ndaemon.start();\n```\n\n\nJVM's built-in daemon threads include:\n\n- Garbage collector\n- Finalizer thread\n- Reference handler\n- Signal dispatcher\n\n**Rules for daemon threads:**\n\n1. Set daemon status before calling `start()`. After start, it throws `IllegalThreadStateException`.\n2. Child threads inherit daemon status from their parent.\n3. Never use daemons for tasks that must complete (file writes, transactions).\n4. Daemon threads are terminated abruptly without running finally blocks when JVM exits.\n\n\n```mermaid\nflowchart TB\n JVM[JVM Process]\n\n subgraph User[\"User Threads\"]\n U1[main]\n U2[Worker-1]\n U3[Worker-2]\n end\n\n subgraph Daemon[\"Daemon Threads\"]\n D1[GC]\n D2[Finalizer]\n D3[CacheCleanup]\n end\n\n JVM --> User\n JVM --> Daemon\n\n User -->|All complete| EXIT[JVM Exit]\n Daemon -->|Killed| EXIT\n\n style U1 fill:#00ceff,stroke:#000,color:#000\n style U2 fill:#00ceff,stroke:#000,color:#000\n style U3 fill:#00ceff,stroke:#000,color:#000\n style D1 fill:#ffa94d,stroke:#000,color:#000\n style D2 fill:#ffa94d,stroke:#000,color:#000\n style D3 fill:#ffa94d,stroke:#000,color:#000\n style EXIT fill:#ff8787,stroke:#000,color:#000\n```\n\n\n### Thread Groups (Legacy)\n\nThread groups were Java's original mechanism for organizing threads into hierarchies. They're now considered largely obsolete, replaced by executors and thread pools for most purposes.\n\n\n```java\n// Creating a thread group\nThreadGroup workers = new ThreadGroup(\"Workers\");\n\nThread t1 = new Thread(workers, task, \"Worker-1\");\nThread t2 = new Thread(workers, task, \"Worker-2\");\n\n// Operations on the group\nworkers.activeCount(); // Number of active threads\nworkers.interrupt(); // Interrupt all threads in group\nworkers.list(); // Print thread list to stdout (debugging)\n```\n\n\nThread groups are still used in some frameworks and for security manager policies, but you shouldn't use them in new code. Use ExecutorService instead.\n\n---\n\n# Thread Lifecycle Management\n\nUnderstanding how to properly start, wait for, and stop threads is essential for writing correct concurrent programs.\n\n### The start() Method\n\nCalling `start()` tells the JVM to create a new native thread and invoke the `run()` method on it. This involves:\n\n1. Allocating memory for the thread's stack\n2. Creating an OS-level thread\n3. Scheduling the thread for execution\n4. Eventually calling `run()` on the new thread\n\n\n```java\nThread t = new Thread(() -> {\n System.out.println(\"Running in: \" + Thread.currentThread().getName());\n});\n\nSystem.out.println(\"Before start: \" + t.getState()); // NEW\nt.start();\nSystem.out.println(\"After start: \" + t.getState()); // RUNNABLE (usually)\n```\n\n\n**Critical:** You can only call `start()` once on a thread. Calling it again throws `IllegalThreadStateException`:\n\n\n```java\nThread t = new Thread(task);\nt.start();\nt.join();\nt.start(); // IllegalThreadStateException!\n```\n\n\nIf you need to run the same task again, create a new Thread instance.\n\n### run() vs start(): A Classic Interview Question\n\nThis is one of the most common Java concurrency interview questions, and getting it wrong is an instant red flag.\n\n\n```java\nThread t = new Thread(() -> {\n System.out.println(\"Thread: \" + Thread.currentThread().getName());\n});\n\n// WRONG - runs in main thread, no new thread created\nt.run(); // Prints \"Thread: main\"\n\n// CORRECT - runs in new thread\nt.start(); // Prints \"Thread: Thread-0\"\n```\n\n\nWhen you call `run()` directly, you're just calling a regular method on the Thread object. No new thread is created. The code executes synchronously in the calling thread.\n\nWhen you call `start()`, the JVM creates a new OS thread and schedules `run()` to execute on that new thread, running concurrently with the calling thread.\n\n\n```mermaid\nsequenceDiagram\n participant Main as Main Thread\n participant T as Thread Object\n participant OS as OS Thread\n\n Note over Main,OS: Calling run() directly\n Main->>T: run()\n T->>T: Execute task code\n T-->>Main: Return\n Note over Main: Still in main thread!\n\n Note over Main,OS: Calling start()\n Main->>T: start()\n T->>OS: Create native thread\n OS->>T: run()\n Main->>Main: Continue (concurrent)\n T->>T: Execute task code\n```\n\n\n### join() and Timeouts\n\nThe `join()` method makes the current thread wait until the target thread terminates:\n\n\n```java\nThread worker = new Thread(longRunningTask);\nworker.start();\n\n// Wait indefinitely\nworker.join();\nSystem.out.println(\"Worker finished\");\n\n// Wait with timeout (returns after 5 seconds regardless)\nworker.join(5000);\nif (worker.isAlive()) {\n System.out.println(\"Worker still running after 5 seconds\");\n}\n```\n\n\nThe overloaded versions accept milliseconds and nanoseconds:\n\n\n```java\njoin() // Wait forever\njoin(long millis) // Wait up to millis milliseconds\njoin(long millis, int nanos) // Wait up to millis + nanos\n```\n\n\n\n> **TIP**\n>\n> `join()` can throw `InterruptedException`. If the waiting thread is interrupted, you should either propagate the exception or restore the interrupt status:\n\n\n\n```java\ntry {\n worker.join();\n} catch (InterruptedException e) {\n Thread.currentThread().interrupt(); // Restore interrupt status\n // Handle the interruption\n}\n```\n\n\n### Interrupts and InterruptedException\n\nJava uses a cooperative interruption model. You can't forcibly stop a thread (the deprecated `stop()` method was dangerous). Instead, you ask a thread to stop, and it decides how and when to comply.\n\n\n```java\nThread worker = new Thread(() -> {\n while (!Thread.currentThread().isInterrupted()) {\n // Do work\n try {\n Thread.sleep(100);\n } catch (InterruptedException e) {\n // Sleep was interrupted - thread should exit\n Thread.currentThread().interrupt(); // Restore flag\n return;\n }\n }\n System.out.println(\"Worker exiting gracefully\");\n});\n\nworker.start();\nThread.sleep(1000);\nworker.interrupt(); // Ask worker to stop\nworker.join();\n```\n\n\nThere are two ways to check for interruption:\n\n\n```java\n// Check and clear the flag\nif (Thread.interrupted()) {\n // Flag was set, now cleared\n}\n\n// Check without clearing\nif (Thread.currentThread().isInterrupted()) {\n // Flag was set, still set\n}\n```\n\n\n**Important:** Many blocking methods throw `InterruptedException` when interrupted:\n\n- `Thread.sleep()`\n- `Object.wait()`\n- `BlockingQueue.take()`\n- `Future.get()`\n- `Lock.lockInterruptibly()`\n\nWhen these methods throw `InterruptedException`, they clear the interrupt flag. This is why you should restore it with `Thread.currentThread().interrupt()` if you catch but don't rethrow the exception.\n\n\n```mermaid\nsequenceDiagram\n participant Main as Main Thread\n participant Worker as Worker Thread\n\n Main->>Worker: start()\n activate Worker\n\n loop While not interrupted\n Worker->>Worker: Do work\n Worker->>Worker: sleep(100)\n end\n\n Main->>Worker: interrupt()\n Note over Worker: InterruptedException thrown
or isInterrupted() returns true\n\n Worker->>Worker: Cleanup\n deactivate Worker\n Worker-->>Main: Thread terminates\n\n Main->>Worker: join()\n```\n\n\n---\n\n# Returning Results from Threads\n\nGetting results back from threads is a common requirement. Java provides several approaches, each with trade-offs.\n\n### The Old Way: Shared Variables with Synchronization\n\nBefore Callable and Future, you'd share results through instance variables:\n\n\n```java\npublic class SumCalculator implements Runnable {\n private final int[] numbers;\n private volatile long result; // volatile for visibility\n private volatile boolean done;\n\n public SumCalculator(int[] numbers) {\n this.numbers = numbers;\n }\n\n @Override\n public void run() {\n long sum = 0;\n for (int n : numbers) {\n sum += n;\n }\n result = sum;\n done = true;\n }\n\n public long getResult() {\n if (!done) {\n throw new IllegalStateException(\"Not finished\");\n }\n return result;\n }\n}\n\n// Usage\nSumCalculator calc = new SumCalculator(numbers);\nThread t = new Thread(calc);\nt.start();\nt.join();\nlong sum = calc.getResult();\n```\n\n\nThis works but requires careful synchronization and is error-prone.\n\n### The Better Way: Callable and Future\n\nJava 5 introduced a cleaner pattern:\n\n\n```java\nCallable sumTask = () -> {\n long sum = 0;\n for (int n : numbers) {\n sum += n;\n }\n return sum;\n};\n\nExecutorService executor = Executors.newSingleThreadExecutor();\nFuture future = executor.submit(sumTask);\n\n// Do other work...\n\n// Get result (blocks if not ready)\ntry {\n long sum = future.get();\n System.out.println(\"Sum: \" + sum);\n} catch (ExecutionException e) {\n System.err.println(\"Task failed: \" + e.getCause());\n}\n\nexecutor.shutdown();\n```\n\n\nFuture provides several useful methods:\n\n\n```java\nfuture.isDone() // Check if complete (non-blocking)\nfuture.isCancelled() // Check if cancelled\nfuture.cancel(true) // Attempt to cancel (mayInterruptIfRunning)\nfuture.get() // Get result, block indefinitely\nfuture.get(5, TimeUnit.SECONDS) // Get with timeout, throws TimeoutException\n```\n\n\n### Using FutureTask with Raw Threads\n\nIf you need Callable semantics but can't use an ExecutorService:\n\n\n```java\nCallable task = () -> {\n Thread.sleep(1000);\n return \"Result\";\n};\n\nFutureTask futureTask = new FutureTask<>(task);\nThread t = new Thread(futureTask, \"FutureWorker\");\nt.start();\n\n// futureTask IS the Future\nString result = futureTask.get();\n```\n\n\nFutureTask implements both `Runnable` and `Future`, bridging the gap between raw threads and the Callable/Future pattern.\n\n### The Modern Way: CompletableFuture\n\nJava 8 introduced CompletableFuture, which provides a much richer API for asynchronous programming. We cover this in detail in the CompletableFuture chapter, but here's a taste:\n\n\n```java\nCompletableFuture future = CompletableFuture.supplyAsync(() -> {\n return calculateSum(numbers);\n});\n\n// Chain transformations\nfuture.thenApply(sum -> sum * 2)\n .thenAccept(doubled -> System.out.println(\"Doubled: \" + doubled));\n\n// Or combine multiple futures\nCompletableFuture future1 = CompletableFuture.supplyAsync(() -> sum(part1));\nCompletableFuture future2 = CompletableFuture.supplyAsync(() -> sum(part2));\n\nCompletableFuture combined = future1.thenCombine(future2, Long::sum);\n```\n\n\n---\n\n# Thread Factories\n\nWhen using thread pools or executors, you often want to customize how threads are created. This is where `ThreadFactory` comes in.\n\n### The ThreadFactory Interface\n\n\n```java\n@FunctionalInterface\npublic interface ThreadFactory {\n Thread newThread(Runnable r);\n}\n```\n\n\nA ThreadFactory is responsible for creating new threads. The default factory creates standard threads, but you can customize everything: names, priorities, daemon status, exception handlers, and more.\n\n### Building a Custom ThreadFactory\n\n\n```java\npublic class NamedThreadFactory implements ThreadFactory {\n private final String namePrefix;\n private final AtomicInteger threadNumber = new AtomicInteger(1);\n private final boolean daemon;\n\n public NamedThreadFactory(String namePrefix, boolean daemon) {\n this.namePrefix = namePrefix;\n this.daemon = daemon;\n }\n\n @Override\n public Thread newThread(Runnable r) {\n Thread t = new Thread(r, namePrefix + \"-\" + threadNumber.getAndIncrement());\n t.setDaemon(daemon);\n t.setUncaughtExceptionHandler((thread, ex) -> {\n System.err.println(\"Thread \" + thread.getName() + \" died: \" + ex.getMessage());\n });\n return t;\n }\n}\n\n// Usage\nExecutorService executor = Executors.newFixedThreadPool(4,\n new NamedThreadFactory(\"OrderProcessor\", false));\n```\n\n\n### Production-Ready ThreadFactory\n\nHere's a more complete example with logging and monitoring:\n\n\n```java\npublic class MonitoredThreadFactory implements ThreadFactory {\n private static final Logger log = LoggerFactory.getLogger(MonitoredThreadFactory.class);\n\n private final String poolName;\n private final AtomicInteger threadCount = new AtomicInteger(0);\n private final AtomicInteger activeCount = new AtomicInteger(0);\n\n public MonitoredThreadFactory(String poolName) {\n this.poolName = poolName;\n }\n\n @Override\n public Thread newThread(Runnable r) {\n int num = threadCount.incrementAndGet();\n String name = poolName + \"-thread-\" + num;\n\n Runnable wrapper = () -> {\n activeCount.incrementAndGet();\n log.debug(\"Thread {} started\", name);\n try {\n r.run();\n } finally {\n activeCount.decrementAndGet();\n log.debug(\"Thread {} completed\", name);\n }\n };\n\n Thread t = new Thread(wrapper, name);\n t.setUncaughtExceptionHandler((thread, ex) -> {\n log.error(\"Thread {} threw uncaught exception\", thread.getName(), ex);\n });\n\n return t;\n }\n\n public int getTotalCreated() {\n return threadCount.get();\n }\n\n public int getActiveCount() {\n return activeCount.get();\n }\n}\n```\n\n\n### Guava's ThreadFactoryBuilder\n\nGoogle's Guava library provides a convenient builder for creating thread factories:\n\n\n```java\nThreadFactory factory = new ThreadFactoryBuilder()\n .setNameFormat(\"worker-%d\")\n .setDaemon(true)\n .setPriority(Thread.NORM_PRIORITY)\n .setUncaughtExceptionHandler((t, e) -> log.error(\"Error in {}\", t.getName(), e))\n .build();\n\nExecutorService executor = Executors.newCachedThreadPool(factory);\n```\n\n\n---\n\n# Common Patterns\n\n### One-Shot Execution Pattern\n\nFor tasks that run once and then the thread is done:\n\n\n```java\npublic void processAsync(Order order) {\n Thread worker = new Thread(() -> {\n try {\n order.process();\n notifySuccess(order);\n } catch (Exception e) {\n notifyFailure(order, e);\n }\n }, \"OrderProcessor-\" + order.getId());\n\n worker.start();\n // Don't join - fire and forget\n}\n```\n\n\n### Worker Thread Pattern\n\nA long-lived thread that processes items from a queue:\n\n\n```java\npublic class WorkerThread extends Thread {\n private final BlockingQueue queue;\n private volatile boolean running = true;\n\n public WorkerThread(BlockingQueue queue, String name) {\n super(name);\n this.queue = queue;\n }\n\n @Override\n public void run() {\n while (running) {\n try {\n Task task = queue.poll(1, TimeUnit.SECONDS);\n if (task != null) {\n task.execute();\n }\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n break;\n }\n }\n System.out.println(getName() + \" shutting down\");\n }\n\n public void shutdown() {\n running = false;\n interrupt(); // Wake up if blocked in poll()\n }\n}\n```\n\n\n### Background Cleanup Pattern\n\nA daemon thread for periodic maintenance:\n\n\n```java\npublic class CacheManager {\n private final Thread cleanupThread;\n\n public CacheManager() {\n cleanupThread = new Thread(() -> {\n while (!Thread.currentThread().isInterrupted()) {\n try {\n cleanupExpiredEntries();\n Thread.sleep(60_000); // Every minute\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n }\n }\n }, \"CacheCleanup\");\n\n cleanupThread.setDaemon(true);\n cleanupThread.start();\n }\n\n private void cleanupExpiredEntries() {\n // Remove expired cache entries\n }\n}\n```\n","pageType":"concurrency-interview"}

Get Premium