Java中的并发和阻塞队列

发布于 2024-07-30 17:53:14 字数 755 浏览 2 评论 0原文

我遇到一个线程将事件推送到第二个线程的传入队列的经典问题。只是这一次，我对表演很感兴趣。我想要实现的是：

我想要并发访问队列，生产者推送，接收者弹出。
当队列为空时，我希望消费者阻塞到队列，等待生产者。

我的第一个想法是使用 LinkedBlockingQueue，但我很快意识到它不是并发的并且性能受到影响。另一方面，我现在使用 ConcurrentLinkedQueue，但我仍然要为每个发布支付 wait() / notify() 的成本。由于消费者在发现空队列时不会阻塞，因此我必须同步并在锁上 wait() 。另一方面，生产者必须在每次发布时获得该锁和 notify()。总的结果是我付出的成本 同步（锁定）{lock.notify()} 在每个发布中，即使不需要。

我想这里需要的是一个既阻塞又并发的队列。我想象 push() 操作就像在 ConcurrentLinkedQueue 中一样工作，当推送的元素是第一个元素时，向对象添加一个额外的 notify()在列表中。我认为 ConcurrentLinkedQueue 中已经存在这样的检查，因为推送需要与下一个元素连接。因此，这比每次在外部锁上同步要快得多。

这样的东西可用/合理吗？

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

浅暮の光 2024-08-06 17:53:14

我认为无论您有什么疑问，您都可以坚持使用 java.util.concurrent.LinkedBlockingQueue。它是并发的。不过，我不知道它的性能。也许，BlockingQueue 的其他实现会更适合您。它们并不太多，因此请进行性能测试和测量。

回复收藏 0 原文

猫七 2024-08-06 17:53:14

与此答案类似 https://stackoverflow.com/a/1212515/1102730 但有点不同..我最终使用ExecutorService。您可以使用 Executors.newSingleThreadExecutor() 实例化一个。我需要一个并发队列来读取/写入 BufferedImages 到文件，以及读取和写入的原子性。我只需要一个线程，因为文件 IO 比源网络 IO 快几个数量级。另外，我更关心操作的原子性和正确性而不是性能，但这种方法也可以通过池中的多个线程来完成，以加快速度。

获取图像（Try-Catch-Finally 省略）：

Future<BufferedImage> futureImage = executorService.submit(new Callable<BufferedImage>() {
    @Override
        public BufferedImage call() throws Exception {
            ImageInputStream is = new FileImageInputStream(file);
            return  ImageIO.read(is);
        }
    })

image = futureImage.get();

保存图像（Try-Catch-Finally 省略）：

Future<Boolean> futureWrite = executorService.submit(new Callable<Boolean>() {
    @Override
    public Boolean call() {
        FileOutputStream os = new FileOutputStream(file); 
        return ImageIO.write(image, getFileFormat(), os);  
    }
});

boolean wasWritten = futureWrite.get();

需要注意的是，您应该在finally 块中刷新并关闭流。我不知道它与其他解决方案相比表现如何，但它非常通用。

Similar to this answer https://stackoverflow.com/a/1212515/1102730 but a bit different.. I ended up using an ExecutorService. You can instantiate one by using Executors.newSingleThreadExecutor(). I needed a concurrent queue for reading/writing BufferedImages to files, as well as atomicity with reads and writes. I only need a single thread because the file IO is orders of magnitude faster than the source, net IO. Also, I was more concerned about atomicity of actions and correctness than performance, but this approach can also be done with multiple threads in the pool to speed things up.

To get an image (Try-Catch-Finally omitted):

Future<BufferedImage> futureImage = executorService.submit(new Callable<BufferedImage>() {
    @Override
        public BufferedImage call() throws Exception {
            ImageInputStream is = new FileImageInputStream(file);
            return  ImageIO.read(is);
        }
    })

image = futureImage.get();

To save an image (Try-Catch-Finally omitted):

Future<Boolean> futureWrite = executorService.submit(new Callable<Boolean>() {
    @Override
    public Boolean call() {
        FileOutputStream os = new FileOutputStream(file); 
        return ImageIO.write(image, getFileFormat(), os);  
    }
});

boolean wasWritten = futureWrite.get();

It's important to note that you should flush and close your streams in a finally block. I don't know about how it performs compared to other solutions, but it is pretty versatile.

回复收藏 0 原文