标签: java.util.concurrent

我有一个多线程应用程序编写和读取ConcurrentLinkedQueue,它在概念上用于支持列表/表中的条目.我最初为此使用了ConcurrentHashMap,效果很好.需要跟踪订单条目的新要求,因此可以在最早的第一个订单中删除它们,具体取决于某些条件.ConcurrentLinkedQueue似乎是一个不错的选择,功能上它运作良好.

可配置数量的条目保存在内存中,当达到限制时提供新条目时,将以最早的第一顺序搜索队列以查找可以删除的队列.系统不会删除某些条目并等待客户端交互.

似乎正在发生的事情是我在队列的前面有一个条目,比如100K条目之前.队列似乎具有有限数量的已配置条目(size()== 100),但在分析时,我发现内存中有~100K ConcurrentLinkedQueue $ Node对象.这似乎是设计上的,只是浏览了ConcurrentLinkedQueue的源代码,一个删除只是删除了对存储对象的引用,但留下链接列表进行迭代.

最后我的问题是:是否有一种"更好"的懒惰方式来处理这种性质的集合？我喜欢ConcurrentLinkedQueue的速度,我无法承受在这种情况下似乎可能出现的无界泄漏.如果没有,似乎我必须创建第二个结构来跟踪订单,并可能有相同的问题,加上同步问题.

我要求异步执行任务,同时丢弃任何进一步的请求,直到任务完成.

同步方法只是将任务排队,不会跳过.我最初想过使用SingleThreadExecutor,但也排队等待任务.然后我查看了ThreadPoolExecutor,但是它读取队列以获取要执行的任务,因此将执行一个任务并且至少有一个任务排队(其他任务可以使用ThreadPoolExecutor.DiscardPolicy丢弃).

我唯一能想到的就是使用信号量来阻止队列.我带着以下示例来展示我想要实现的目标.有更简单的方法吗？我错过了一些明显的事吗？

import java.util.concurrent.*;

public class ThreadPoolTester {
    private static ExecutorService executor = Executors.newSingleThreadExecutor();
    private static Semaphore processEntry = new Semaphore(1);

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 20; i++) {
            kickOffEntry(i);

            Thread.sleep(200);
        }

        executor.shutdown();
    }

    private static void kickOffEntry(final int index) {
        if (!processEntry.tryAcquire()) return;
        executor.
            submit(
                new Callable<Void>() {
                    public Void call() throws InterruptedException {
                        try {
                            System.out.println("start " + index);
                            Thread.sleep(1000); // pretend to do work
                            System.out.println("stop " …

你将如何顺序执行三个线程？例如.Thread1,Thread2,Thread3.无法将一个Thread的引用传递给另一个Thread并从run()方法调用.

所以代码应该是这样的:

 Thread1.start();
 Thread2.start();
 Thread3.start();

应该是

 Printing Thread1
 Printing Thread2
 Printing Thread3

这可以通过使用ThreadPoolExecutor并使用阻塞队列来实现,但即使这样也不是可接受的答案.

我想念MINUTES, HOURS, DAYS,自API级别1以来存在于文档中(我使用应用程序的第7版或第2.1版).

我已经读过这个问题,也指出了这个错过(虽然它不在问题本身中),但是只提出了自己计算的解决方案.

我并不懒惰,但我将一些数据发送到服务器(Java项目),在那里TimeUnit.MINUTES或者TimeUnit.HOURS被积极使用.只是想避免错误.

将不胜感激任何帮助.

我有一项任务,我想以固定的速度运行.但是,每次执行后我还需要任务的结果.这是我尝试过的:

任务

class ScheduledWork implements Callable<String>
{
    public String call()
    {
        //do the task and return the result as a String
    }
}

不,我试图使用它ScheduledExecutorService来安排它.事实证明,你不能Callable以固定的速度安排,只有一个Runnable可以这样做.

请指教.

我是比较新的java.我正在尝试了解包中类的用法:

java.util.concurrent.atomic中

我试图理解这个包的javaDoc来掌握它.但是当我应该使用这些类时,它真的没有任何意义.有人可以用简单的词语举例和更多描述吗？谢谢

在应用程序线程转储中,我可以看到有五个线程的线程池,如下所示

"pool-1-thread-5" prio=10 tid=0x000000000101a000 nid=0xe1f in Object.wait() [0x00007f3c66086000]
  java.lang.Thread.State: WAITING (on object monitor)
    at java.lang.Object.wait(Native Method)
    - waiting on <0x00000007b8e57af8> (a hidden.edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingQueue$SerializableLock)
    at java.lang.Object.wait(Object.java:503)
    at hidden.edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingQueue.take(LinkedBlockingQueue.java:316)
    - locked <0x00000007b8e57af8> (a hidden.edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingQueue$SerializableLock)
    at hidden.edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:994)
    at hidden.edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1054)
    at hidden.edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:575)
    at java.lang.Thread.run(Thread.java:722)

但我没有直接使用这样的东西,并没有在依赖中看到这样的东西.

这是什么(hidden.edu.emory.mathcs.backport)及其使用的原因(在jdk 7上运行的应用程序)？我可以检测应用程序的哪个部分启动它？

我正在阅读CyclicBarrier以下链接 http://java-latte.blogspot.in/2013/10/cyclicbarrier-in-java-concurrency.html.

在示例1中,CyclicRaceDemo.javamain方法,CyclicBarrier正在重用而不调用reset方法.

我运行了这个例子,它运行良好.所以,我想知道reset方法的用途是什么.应该什么时候打电话？或者我们需要打电话吗？

我正在做一些关于Java 8并发性的实验

在ScheduledThreadPoolExecutor API中

我可以看到以下两个签名:

schedule(Callable<V> callable, long delay, TimeUnit unit)
schedule(Runnable command, long delay, TimeUnit unit)

一个为Callable一个为一个Runnable

我也可以在API中看到以下两个:

scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)
scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)

我的问题是,为什么不存在两个等价物 Callable

scheduleAtFixedRate(Callable<V> callable, long initialDelay, long period, TimeUnit unit)
scheduleWithFixedDelay(Callable<V> callable, long initialDelay, long delay, TimeUnit unit)

我需要为操作检索一个布尔结果.

谢谢.

将2000万个实体推入java地图对象的最佳方法是什么？

1. 没有多线程,它需要大约40秒.
2. 使用ForkJoinPool需要大约25秒,我创建了2个任务,每个任务都推动了1000万个实体

我相信这两项任务都在两个不同的核心中运行.问题:当我创建一个推送1000万个数据的任务时,需要大约9秒,然后当运行2个任务时,每个任务都会推送1000万个数据,为什么需要大约26秒？难道我做错了什么 ？

在不到10秒的时间内插入20 M数据是否有不同的解决方案？