在Java中异步处理队列中的Amazon SQS消息

我很难弄清楚如何处理来自AmazonSQS的消息

我正在努力实现以下目标：

SQS上的侦听器

处理队列中的消息并将其添加到数据库

从队列中删除已处理的消息

最让我困扰的是如何实施步骤2。我有class

SQSConnector

和

ProfileDao

。现在我想要一个简单的实现，在

ProfileDao

中初始化

SQSConnector

，并从队列接收消息。我的想法是启动新线程，开始轮询消息，当队列为空时，从

ProfileDao

中断线程

返回/处理消息的最佳方法是什么（回调函数？），如果有其他方法，我愿意选择

---

谢谢你

我已经使用Java和

ExecutorService创建一个线程池，该线程池可以执行实现可调用接口并返回未来的类。在ExecutorService创建未来时，我将它们推送到在线程中运行的ConcurrentLinkedQueue上，并在未来完成时处理结果

执行检查SQS并异步启动工作：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class SqsProcessor {

    private static final int THREAD_COUNT = 100;
    private ExecutorService _executor = null;
    private FutureResultProcessor futureResultProcessor = null;

    public SqsProcessor() {
        _executor = Executors.newFixedThreadPool(THREAD_COUNT);
        _futureResultProcessor = new FutureResultProcessor();
    }

    public void waitReceive() {

        // Receive a SQS message

        // Start the work related to the SQS message
        Callable<MyWorkderResult> sqsWorker = new MyWorker(sqsMessage);
        Future<MyWorkerResult> sqsFuture = _executor.submit(sqsWorker);

        // Send to the queue so the result can be processed when it completes
        _futureResultProcessor.add(sqsFuture);
    }
}

接收和处理未来结果的ConcurrentLinkedQueue：

import java.util.concurrent.Future;
import java.util.concurrent.ConcurrentLinkedQueue;

public class FutureResultProcessor extends Thread {

    private final ConcurrentLinkedQueue<Future<MyWorkerResult>> resultQueue = new ConcurrentLinkedQueue<Future<MyWorkerResult>>();
    private final Integer CHECK_SLEEP = 300;

    public FutureResultProcessor() {
    }

    public void run() {
        while(true) {
            Future<MyWorkerResult> myFuture = resultQueue.poll();

            if(myFuture == null) {
                // There's nothing to process
                try { Thread.sleep(CHECK_SLEEP); } catch (InterruptedException e) {}
                continue;
            }

            // Process result
            if(myFuture != null) {

                MyFutureResult myFutureResult = myFuture.get();

                // Process result
            }
        }
    }

    public void add(Future<MyWorkerResult> sqsFuture) {
        resultQueue.offer(sqsFuture);
    }
}

import java.util.concurrent.Future；
导入java.util.concurrent.ConcurrentLinkedQueue；
公共类FutureResultProcessor扩展线程{
private final ConcurrentLinkedQueue resultQueue=新ConcurrentLinkedQueue（）；
私有最终整数检查\u SLEEP=300；
公共未来结果处理器（）{
}
公开募捐{
while（true）{
Future myFuture=resultQueue.poll（）；
如果（myFuture==null）{
//没有什么需要处理的
尝试{Thread.sleep（CHECK_sleep）}catch（InterruptedException e）{}
继续；
}
//过程结果
如果（myFuture！=null）{
MyFutureResult MyFutureResult=myFuture.get（）；
//过程结果
}
}
}
公共作废添加（未来SQS未来）{
结果报价（SQS未来）；
}
}

或者，您可以收集一组期货，等待它们全部完成，然后再处理结果

可能很合适。我没有直接使用它，但它提供了一个运行异步任务的框架，提供了错误处理，甚至可以将任务分发到远程实例

public class MyWorkerResult {
    // Results set in MyWorker call()
}

import java.util.concurrent.Future;
import java.util.concurrent.ConcurrentLinkedQueue;

public class FutureResultProcessor extends Thread {

    private final ConcurrentLinkedQueue<Future<MyWorkerResult>> resultQueue = new ConcurrentLinkedQueue<Future<MyWorkerResult>>();
    private final Integer CHECK_SLEEP = 300;

    public FutureResultProcessor() {
    }

    public void run() {
        while(true) {
            Future<MyWorkerResult> myFuture = resultQueue.poll();

            if(myFuture == null) {
                // There's nothing to process
                try { Thread.sleep(CHECK_SLEEP); } catch (InterruptedException e) {}
                continue;
            }

            // Process result
            if(myFuture != null) {

                MyFutureResult myFutureResult = myFuture.get();

                // Process result
            }
        }
    }

    public void add(Future<MyWorkerResult> sqsFuture) {
        resultQueue.offer(sqsFuture);
    }
}