Threads

A thread is a lightweight unit of execution within a process. Multiple threads share the same process memory but execute independently.

Process vs Thread

Process (JVM)
+----------------------------------+
| Thread 1: Handle Request A       |
| Thread 2: Handle Request B       |
| Thread 3: Handle Request C       |
|                                  |
| Shared: Memory, Objects, DB Pool |
+----------------------------------+

Thread Lifecycle

NEW --> RUNNABLE --> RUNNING --> TERMINATED
              ^          |
              |          v
              +---- BLOCKED/WAITING

State	Description
NEW	Thread created but not started
RUNNABLE	Ready to run, waiting for CPU
RUNNING	Currently executing
BLOCKED	Waiting for a lock
WAITING	Waiting indefinitely
TIMED_WAITING	Waiting for a time period
TERMINATED	Finished execution

Thread in Backend

Each incoming request is handled by a thread:

Request 1 --> Thread Pool --> Thread 1 processes request
Request 2 --> Thread Pool --> Thread 2 processes request
Request 3 --> Thread Pool --> Thread 3 processes request

Thread Pool

Instead of creating a new thread per request, use a thread pool:

Thread Pool (10 threads)
    |
    +--> Thread 1: Busy
    +--> Thread 2: Available
    +--> Thread 3: Busy
    +--> ...
    +--> Thread 10: Available

Benefits:

• Reuse threads instead of creating new ones
• Limit concurrent requests
• Prevent resource exhaustion

Java Threads

// Creating threads
Thread t = new Thread(() -> {
    System.out.println("Running in thread: " + Thread.currentThread().getName());
});
t.start();

// Using ExecutorService
ExecutorService executor = Executors.newFixedThreadPool(10);
executor.submit(() -> processRequest());

Why Threads Matter for Backend

• Each request is handled by a thread
• Too few threads = requests wait
• Too many threads = resource exhaustion
• Thread pools balance throughput and resource usage

Thread Pools

ExecutorService pool = Executors.newFixedThreadPool(10);

Pool Types

• Fixed: Fixed number of threads
• Cached: Creates as needed
• Scheduled: For delayed tasks
• WorkStealing: ForkJoinPool

Best Practices

• Size pools appropriately
• Use meaningful thread names
• Implement graceful shutdown
• Monitor thread usage

Common Issues

• Thread leaks
• Context switching overhead
• Deadlocks

Key Points

• Understanding Threads is essential for production systems
• Always consider scalability and maintainability
• Test thoroughly before deploying to production
• Monitor performance and set up alerting

Common Patterns

1. Validation: Always validate input at the boundary
2. Error Handling: Use structured error responses
3. Logging: Log key events for debugging
4. Testing: Unit, integration, and load tests
5. Documentation: Keep docs updated with code changes