Submissions are now open for the 2026 Adobe Experience Maker Awards.
SOLVED
How to handle multiple threads in listenener?
1 Accepted Solution
Correct answer by
Hi @Keerthana_H_N,
I would recommend the following approach that will utilize thread-safe implementations and guarantee from AEM for code execution.
Step 1: Workflow launcher
Use Workflow launcher to listen node modification and trigger Workflow with one custom step. It will be guaranteed to be called one time.
Step 2: Workflow
Create workflow with single workflow process. This workflow process should take asset path and put it to processing queue that will ensure thread-safety.
Step 3: Processing queue
Below you can find an example of code. This approach ensures:
- Thread safety while adding/removing items.
- Constant-time checks for existing paths.
- No duplicates in the queue.
import java.util.Queue;
import java.util.concurrent.*;
public class UniquePathQueue {
private final Queue<String> queue = new ConcurrentLinkedQueue<>();
private final ConcurrentHashMap<String, Boolean> pathSet = new ConcurrentHashMap<>();
// Add path only if it's not already present
public void addPath(String path) {
if (pathSet.putIfAbsent(path, Boolean.TRUE) == null) { // Ensures unique entry
queue.offer(path);
}
}
// Retrieve and remove the next path
public String takePath() {
String path = queue.poll();
if (path != null) {
pathSet.remove(path); // Remove from tracking set
}
return path;
}
// Check if queue is empty
public boolean isEmpty() {
return queue.isEmpty();
}
}ConcurrentHashMap
- Used to track unique paths.
- putIfAbsent() ensures a path is added only once.
ConcurrentLinkedQueue
- Allows multiple threads to safely add/remove elements.
- Non-blocking, meaning no locks are needed.
Thread-Safety
- Both data structures are concurrent (safe for multi-threaded use).
- No locks or synchronized blocks → High performance.
No Duplicate Paths
- Before adding a path to the queue, it checks pathSet.
- When removing an item, it also removes it from pathSet.
However, it's not all. You need to create a consumer of this queue.
Step 4: Queue path consumer
This consumer should check every N seconds your queue for items and start Sling Job to ensure that your path will be guaranteed to be processed.
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class PathConsumer {
private final UniquePathQueue pathQueue;
private final int sleepTimeSeconds;
private final JobManager jobManager;
private volatile boolean running = true;
private Thread consumerThread;
public PathConsumer(UniquePathQueue pathQueue, int sleepTimeSeconds, JobManager jobManager) {
this.pathQueue = pathQueue;
this.sleepTimeSeconds = sleepTimeSeconds;
this.jobManager = jobManager;
}
public void start() {
consumerThread = new Thread(() -> {
while (running) {
String path = pathQueue.takePath();
if (path != null) {
jobManager.addJob("my/custom/job", Map.of("damPath", path));
} else {
try {
Thread.sleep(sleepTimeSeconds * 1000L);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
System.out.println("Consumer stopped.");
});
consumerThread.start();
}
public void stop() {
running = false;
if (consumerThread != null) {
consumerThread.interrupt();
}
}
}
Feel free to make changes in implementation. I just wanted to described an alternative concept.
Best regards,
Kostiantyn Diachenko.
Kostiantyn Diachenko
Check out AEM VLT Intellij plugin
Correct answer by
Hi @Keerthana_H_N,
I would recommend the following approach that will utilize thread-safe implementations and guarantee from AEM for code execution.
Step 1: Workflow launcher
Use Workflow launcher to listen node modification and trigger Workflow with one custom step. It will be guaranteed to be called one time.
Step 2: Workflow
Create workflow with single workflow process. This workflow process should take asset path and put it to processing queue that will ensure thread-safety.
Step 3: Processing queue
Below you can find an example of code. This approach ensures:
- Thread safety while adding/removing items.
- Constant-time checks for existing paths.
- No duplicates in the queue.
import java.util.Queue;
import java.util.concurrent.*;
public class UniquePathQueue {
private final Queue<String> queue = new ConcurrentLinkedQueue<>();
private final ConcurrentHashMap<String, Boolean> pathSet = new ConcurrentHashMap<>();
// Add path only if it's not already present
public void addPath(String path) {
if (pathSet.putIfAbsent(path, Boolean.TRUE) == null) { // Ensures unique entry
queue.offer(path);
}
}
// Retrieve and remove the next path
public String takePath() {
String path = queue.poll();
if (path != null) {
pathSet.remove(path); // Remove from tracking set
}
return path;
}
// Check if queue is empty
public boolean isEmpty() {
return queue.isEmpty();
}
}ConcurrentHashMap
- Used to track unique paths.
- putIfAbsent() ensures a path is added only once.
ConcurrentLinkedQueue
- Allows multiple threads to safely add/remove elements.
- Non-blocking, meaning no locks are needed.
Thread-Safety
- Both data structures are concurrent (safe for multi-threaded use).
- No locks or synchronized blocks → High performance.
No Duplicate Paths
- Before adding a path to the queue, it checks pathSet.
- When removing an item, it also removes it from pathSet.
However, it's not all. You need to create a consumer of this queue.
Step 4: Queue path consumer
This consumer should check every N seconds your queue for items and start Sling Job to ensure that your path will be guaranteed to be processed.
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class PathConsumer {
private final UniquePathQueue pathQueue;
private final int sleepTimeSeconds;
private final JobManager jobManager;
private volatile boolean running = true;
private Thread consumerThread;
public PathConsumer(UniquePathQueue pathQueue, int sleepTimeSeconds, JobManager jobManager) {
this.pathQueue = pathQueue;
this.sleepTimeSeconds = sleepTimeSeconds;
this.jobManager = jobManager;
}
public void start() {
consumerThread = new Thread(() -> {
while (running) {
String path = pathQueue.takePath();
if (path != null) {
jobManager.addJob("my/custom/job", Map.of("damPath", path));
} else {
try {
Thread.sleep(sleepTimeSeconds * 1000L);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
System.out.println("Consumer stopped.");
});
consumerThread.start();
}
public void stop() {
running = false;
if (consumerThread != null) {
consumerThread.interrupt();
}
}
}
Feel free to make changes in implementation. I just wanted to described an alternative concept.
Best regards,
Kostiantyn Diachenko.
Kostiantyn Diachenko
Check out AEM VLT Intellij plugin
@Keerthana_H_N, in my suggested solution, even duplicated events will be handled by queue that stores only unique paths. Take a look into it.
Kostiantyn Diachenko
Check out AEM VLT Intellij plugin
@Keerthana_H_N Did you find the suggestions helpful? Please let us know if you need more information. If a response worked, kindly mark it as correct for posterity; alternatively, if you found a solution yourself, we’d appreciate it if you could share it with the community. Thank you!
Kautuk Sahni
Related Conversations
