java - Spring Boot 和执行器服务

Question

我正在使用 Spring Boot

public interface StringConsume extends Consumer<String> {

default public void strHandel(String str) {
    accept(str);
}
}

实现

@Component("StrImpl")
public class StringConsumeImpl implements StringConsume {

BlockingQueue<String> queue = new ArrayBlockingQueue<>(500);
final ExecutorService exService = Executors.newSingleThreadExecutor();
Future<?> future = CompletableFuture.completedFuture(true);

@Override
public void accept(String t) {
    try {
        queue.put(t);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    while (null != queue.peek()) {

        if (future.isDone()) {
            future = exService.submit(() -> queue.take());
        }

    }

}

}

类别

@Component
public class Test {

@Resource(name="StrImpl")
private @Autowired StringConsume handler;

public void insertIntoQueue(String str) {
    handler.accept(str);
}

}

在 StringConsumeImpl 中，我需要同步 while 循环吗？假设调用了五次 StringConsumeImpl 类，那么 while 循环将创建 5 个进程还是仅创建 1 个进程？ StringConsumeImpl 中 while 循环的最佳替代是什么(如果有)？

Answer 1

该代码存在一些问题。

首先，消费者并没有真正“消费”任何东西，它只是将字符串添加到队列中然后将其取出。为了论证，我们可以说它还通过将其打印到控制台或其他东西来“消耗”它。

其次，除非消费者在自己的线程中运行，否则由于循环，消费者只会被调用一次。例如，如果你这样做

public static void main(String[]args) {
    StringConsume consumer = new StringConsumeImpl();
    consumer.accept("hello");
}

消费者会将“hello”放入队列中，立即取出，然后留在循环中，等待更多元素取出；然而，没有人真正添加任何内容。

做你想做的事情的通常概念是“生产者/消费者”。这意味着有一个“生产者”将项目放入队列中，还有一个“消费者”将它们取出并用它们做事。

因此，在您的情况下，您的类所做的是将字符串放入队列中“消耗”字符串，使其成为“生产者”，然后通过将其从队列中取出来“消耗”字符串。当然，还有字符串的“实际”生成者，即调用它的类。

所以一般来说你会做这样的事情:

/** Produces random Strings */
class RandomStringProducer {
    Random random = new Random();
    public String produceString() {
        return Double.toString(random.nextDouble());
    }
}

/** Prints a String */
class PrintConsumer implements StringConsume {
    public void accept(String s) { System.out.println(s); }
}

/** Consumes String by putting it into a queue */
class QueueProducer implements StringConsume {
    BlockingQueue<String> queue;
    public QueueProducer(BlockingQueue<String> q) { queue = q; }
    public void accept(String s) {
        queue.put(s);
    }
}

public static void main(String[] args) {
    // the producer
    RandomStringProducer producer = new RandomStringProducer();

    // the end consumer
    StringConsume printConsumer = new PrintConsumer();

    // the queue that links producer and consumer
    BlockingQueue<String> queue = new ArrayBlockingQueue<>();

    // the consumer putting strings into the queue
    QueueProducer queuePutter = new QueueProducer(queue);

    // now, let's tie them together

    // one thread to produce strings and put them into the queue
    ScheduledExecutorService producerService = Executors.newScheduledThreadPool(1);
    Runnable createStringAndPutIntoQueue = () -> {
        String created = producer.createString();
        queuePutter.consume(created);
    };
    // put string into queue every 100ms
    producerService.scheduleAtFixedRate(createStringAndPutIntoQueue, 100, TimeUnit.MILLISECONDS);

    // one thread to consume strings
    Runnable takeStringFromQueueAndPrint = () -> {
        while(true) {
            String takenFromQueue = queue.take(); // this will block until a string is available
            printConsumer.consume(takenFromQueue);
        }
    };
    // let it run in a different thread
    ExecutorService consumerService = Executors.newSingleThreadExecutor();
    consumerService.submit(takeStringFromQueueAndPrint);

    // this will be printed; we are in the main thread and code is still being executed
    System.out.println("the produce/consume has started");
}

所以当你运行这个时，将会有三个线程:主线程、生产者线程和消费者线程。生产者和消费者将同时做他们的事情，主线程也将继续运行(如最后一行中的 System.out.println 所示)。