Concurrency Utilities

Jakarta EE Concurrency Utilities: Your Team of Helper Friends! 🎪

Imagine you’re running a HUGE lemonade stand at a fair. You can’t do everything alone—squeezing lemons, pouring drinks, taking money, and cleaning cups all at once! You need a team of helpers, each doing their job. That’s exactly what Jakarta Concurrency does for your Java applications!

🌟 The Big Picture: What is Jakarta Concurrency?

Think of your Java application like a busy restaurant:

• Customers keep coming (requests)
• You need waiters, cooks, and cleaners working together
• Everyone needs to share the same kitchen (resources)

Jakarta Concurrency gives you managed workers that the restaurant (application server) can supervise. Without it, you’d have random people running around with no boss—chaos!

graph TD
    A["Your App"] --> B["Jakarta Concurrency"]
    B --> C["ManagedExecutorService"]
    B --> D["Scheduled Executor"]
    B --> E["ManagedThreadFactory"]
    B --> F["ContextService"]
    C --> G["🏃 Workers doing tasks NOW"]
    D --> H["⏰ Workers doing tasks LATER"]
    E --> I["🏭 Factory making workers"]
    F --> J["📦 Keeping important info safe"]

Why Not Just Use Regular Java Threads?

Regular threads are like hiring strangers off the street:

• The restaurant manager doesn’t know them
• They can’t access the employee locker (security context)
• They don’t know restaurant rules (container services)

Managed workers are official employees—they follow rules and have proper access!

🏃 ManagedExecutorService: Your Team of “Do It Now” Helpers

Simple Analogy: Imagine you have a magic button. Press it, and a helper appears to do your chore while you keep playing!

What It Does

ManagedExecutorService is like having a team of assistants ready to work:

• You give them a task
• They do it in the background
• You can keep doing your stuff
• They tell you when done (if you want)

Real Example: Sending Welcome Emails

@Resource
ManagedExecutorService executor;

public void registerUser(User user) {
    // Save user immediately
    userRepo.save(user);

    // Send email in background
    // (don't make user wait!)
    executor.submit(() -> {
        emailService.sendWelcome(user);
    });

    // User sees "Done!" instantly
}

What happened?

1. User clicks “Register”
2. We save them to database (fast!)
3. We tell a helper: “Send email when you can”
4. User sees success immediately
5. Email arrives a few seconds later

Getting Results Back

Sometimes you want to know what the helper found:

// Ask helper to fetch weather
Future<String> weather = executor.submit(
    () -> weatherApi.getToday()
);

// Do other things...
buyUmbrella();

// Now check what helper found
String forecast = weather.get(); // "Sunny!"

It’s like asking a friend to check if it’s raining while you get dressed!

⏰ ManagedScheduledExecutorService: The “Do It Later” Helpers

Simple Analogy: This is your alarm clock team. You tell them: “Wake me up at 7 AM” or “Remind me every hour to drink water.”

What It Does

Schedule tasks to run:

• Once after a delay (“Do this in 5 minutes”)
• Repeatedly at fixed intervals (“Do this every hour”)

Real Example: Cleanup Old Data

@Resource
ManagedScheduledExecutorService scheduler;

@PostConstruct
public void setup() {
    // Run cleanup every night at midnight
    scheduler.scheduleAtFixedRate(
        () -> cleanupOldLogs(),
        0,           // start now
        24,          // every 24 hours
        TimeUnit.HOURS
    );
}

Think of it like hiring a janitor who automatically cleans every night!

One-Time Delayed Task

// Send reminder in 30 minutes
scheduler.schedule(
    () -> sendReminder(user),
    30,
    TimeUnit.MINUTES
);

Like telling your assistant: “Knock on my door in 30 minutes for my next meeting.”

graph TD
    A["Schedule Task"] --> B{Type?}
    B -->|Once| C["schedule"]
    B -->|Repeat| D["scheduleAtFixedRate"]
    C --> E["⏰ Runs after delay"]
    D --> F["🔄 Runs repeatedly"]

🏭 ManagedThreadFactory: The Worker-Making Machine

Simple Analogy: Instead of hiring individual workers, you have a worker-making machine. Press a button, and out pops a trained employee who knows all the company rules!

What It Does

Creates new threads that:

• Know about your application’s security
• Can access your application’s resources
• Follow container rules

Real Example: Custom Thread Pool

@Resource
ManagedThreadFactory threadFactory;

public void createCustomPool() {
    // Make 5 workers using our factory
    ExecutorService pool = Executors.newFixedThreadPool(
        5,
        threadFactory  // Use managed factory!
    );

    // These workers have proper access
    pool.submit(() -> {
        // Can use @Inject, security, etc.
    });
}

Why Use a Factory?

📦 ContextService: The “Important Stuff” Keeper

Simple Analogy: Imagine you’re a secret agent. When you send a helper on a mission, they need your badge, secret codes, and mission briefing. ContextService is the briefcase that carries all that important stuff!

What It Does

When your helper thread runs, it might need:

• Who you are (security identity)
• What transaction you’re in (database stuff)
• Application settings (configuration)

ContextService captures this information and gives it to helpers.

Real Example: Wrapping a Task with Context

@Resource
ContextService contextService;

public void processWithContext() {
    // Current user: "Alice"

    // Wrap the task with current context
    Runnable wrapped = contextService.createContextualProxy(
        () -> {
            // Inside here, we're still "Alice"!
            audit.log("Action by: " + currentUser);
        },
        Runnable.class
    );

    // Even if run later, it remembers "Alice"
    executor.submit(wrapped);
}

Without ContextService, the helper might forget who sent them!

🔄 Context Propagation: Passing the Baton

Simple Analogy: In a relay race, runners pass a baton. Context Propagation is how your main thread passes important information to helper threads—like passing the baton!

What Gets Passed?

graph LR
    A["Main Thread"] -->|Passes| B["Context Baton"]
    B --> C["Security: Who am I?"]
    B --> D["Transaction: What DB work?"]
    B --> E["Naming: JNDI lookups"]
    B --> F["Classloader: Which classes?"]

The 4 Types of Context

How It Works Automatically

Good news! When you use ManagedExecutorService, context propagation happens automatically:

// You're logged in as "Bob"

executor.submit(() -> {
    // This helper KNOWS you're Bob!
    // Transaction context flows here too!
    orderService.placeOrder(); // Works correctly
});

Configuring What to Propagate

Sometimes you want control:

// In your beans.xml or deployment descriptor
// You can specify which contexts to propagate
// or clear for security reasons

🎯 Putting It All Together

Let’s see how a real e-commerce order works:

graph TD
    A["👤 User: Order Pizza"] --> B["Main Thread"]
    B --> C["Save Order to DB"]
    C --> D["ManagedExecutor: Send Email"]
    C --> E["ManagedExecutor: Notify Kitchen"]
    C --> F["ScheduledExecutor: Check in 30min"]
    D --> G["📧 Uses User's Context]
    E --> H[🍕 Uses User's Context"]
    F --> I["⏰ Follow-up if not delivered"]

@Inject
ManagedExecutorService executor;

@Inject
ManagedScheduledExecutorService scheduler;

public void placeOrder(Order order) {
    // Save immediately
    orderRepo.save(order);

    // Background tasks (user doesn't wait)
    executor.submit(() ->
        emailService.confirm(order)
    );

    executor.submit(() ->
        kitchen.notify(order)
    );

    // Check delivery in 30 minutes
    scheduler.schedule(
        () -> checkDelivery(order),
        30, TimeUnit.MINUTES
    );
}

💡 Quick Summary

🚀 Why This Matters

Without Jakarta Concurrency:

• ❌ Helpers don’t know who you are
• ❌ Database transactions get lost
• ❌ Security checks fail
• ❌ Application becomes unpredictable

With Jakarta Concurrency:

• ✅ Helpers remember everything important
• ✅ Transactions stay connected
• ✅ Security flows correctly
• ✅ Container manages everything safely

You focus on the pizza, and your helpers handle the rest—the right way! 🍕

Remember: Jakarta Concurrency = Managed helpers who know the rules, carry your identity, and work when you tell them to!