标签: java.util.concurrent

我正在编写一个将HashMap返回给用户的应用程序.用户将获得对此MAP的引用.在后端,我将运行一些将更新Map的线程.

到目前为止我做了什么？

我已经制作了所有后端线程,因此共享一个公共频道来更新MAP.所以在后端我确信并发写操作不会成为问题.

我遇到的问题

1. 如果用户尝试更新MAP并同时在后端更新MAP - >并发写操作问题.
2. 如果使用尝试从MAP读取内容并同时在后端更新MAP - >并发READ和WRITE操作问题.

直到现在我还没有遇到任何这样的问题,但我担心将来我可能会面对.请给出sugesstions.

我在用 ConcurrentHashMap<String, String>.

我看到上面的注释在JCIP一书中被广泛使用.我认为这非常有用,因为即使没有适当的文档,它也会说明有关同步策略的一些信息.我也看到Intellij Idea使用这些注释它们现在实际上是Java语言本身的一部分吗？

当返回值不感兴趣时,当忽略返回值时,是否存在(AtomicInteger.getAndIncrement()和实际上不相关的)AtomicInteger.incrementAndGet()方法之间的差异？

我正在考虑哪些差异会更加惯用,以及哪些会减少CPU缓存的负载同步,或其他任何事情,任何事情来帮助决定哪一个比投掷硬币更合理地使用.

如果我们使用ExecutorCompletionService,我们可以提交一系列任务作为Callables,并将结果与CompletionServiceas进行交互queue.

但也有在invokeAll的ExecutorService,它接受一个Collection任务,我们得到的名单Future,以检索结果.

据我所知,有在使用一个或比其他任何好处(除了我们避免for使用循环invokeAll,我们将不得不submit对任务的CompletionService),基本上他们是有轻微的差别同样的想法.

那么为什么有两种不同的方式来提交一系列任务呢？我是否正确表现他们是相同的？是否有一个比另一个更合适的情况？我想不出一个.

我们有一个共享的ConcurrentHashMap,由2个线程读取和写入.

class Test {

    ConcurrentHashMap map;

    read() {
        map.get(object);
    }

    write() {
        map.put(key, object);
    }
}

我们是否需要使地图变得易变,以便读者线程尽快看到一个线程的写入？

是否有可能在一个线程中放置到地图的位置不会被另一个线程看到或看得很晚？HashMap也有同样的问题.

我正在使用ExecutorService线程池执行可调用对象.我想给这个帖子命名.

更具体地说,在旧版本中,我这样做了 -

Thread thread = new Thread(runnable Task);
thread.setName("My Thread Name");

我在log4j日志记录中使用线程名称,这在故障排除时有很大帮助.现在我将我的代码从Java 1.4迁移到Java 1.6.我写了这个(在下面给出) - 但我不知道如何给这个帖子命名.

private final ExecutorService executorPool = Executors.newCachedThreadPool();
Future<String> result = executorPool.submit(callable Task);

请给我一些想法给这个帖子命名？

在阅读有关内存一致性错误的Java文档时.我找到了与两个创造事件相关的点 - 在关系之前:

• 当一个语句调用时Thread.start(),与该语句有一个before-before关系的每个语句也与新线程执行的每个语句都有一个before-before关系.新线程可以看到导致创建新线程的代码的影响.

• 当一个线程终止并导致Thread.join()另一个线程返回时,终止
  线程执行的所有语句
  与成功连接后的所有语句都有一个before-before关系.现在,执行连接的线程可以看到线程中代码的效果.

我无法理解他们的意思.如果有人用一个简单的例子解释它会很棒.

我看到BlockingQueue的这些实现并无法理解它们之间的差异.我的结论到目前为止:

1. 我不会需要SynchronousQueue
2. LinkedBlockingQueue确保FIFO,必须使用参数true创建BlockingQueue以使其成为FIFO
3. SynchronousQueue打破了大多数集合方法(包含,大小等)

那我什么时候需要SynchronousQueue？这种实现的性能是否优于LinkedBlockingQueue？

为了使它更复杂...为什么当其他人(Executors.newSingleThreadExecutor和Executors.newFixedThreadPool)使用LinkedBlockingQueue 时,Executors.newCachedThreadPool使用SynchronousQueue ？

编辑

第一个问题解决了.但我仍然不明白为什么Executors.newCachedThreadPool使用SynchronousQueue时其他人(Executors.newSingleThreadExecutor和Executors.newFixedThreadPool)使用LinkedBlockingQueue？

我得到的是,使用SynchronousQueue,如果没有自由线程,生产者将被阻止.但由于线程数实际上是无限的(如果需要,将创建新线程),这将永远不会发生.那为什么要使用SynchronousQueue呢？

在给定的超时后,Future.get(timeout)不能可靠地抛出TimeoutException.这是正常的行为,还是我可以做些什么来使这更可靠？我的机器上的测试失败了.但是如果我睡了3000而不是2000,它就会过去.

public class FutureTimeoutTest {
@Test
public void test() throws
    ExecutionException,
    InterruptedException {

    ExecutorService exec = Executors.newSingleThreadExecutor();
    final Callable call = new Callable() {
        @Override
        public Object call() throws Exception {
             try {
                Thread.sleep(2000);
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
            return 0;
        }
    };
    final Future future = exec.submit(call);
    try {
        future.get(1000, TimeUnit.MILLISECONDS);
        fail("expected TimeoutException");
    } catch (TimeoutException ignore) {
    }
}

}

我需要为Web服务器实现全局对象收集统计信息.我有Statistics 单身,有方法addSample(long sample),随后打电话updateMax.这显然是线程安全的.我有这个方法来更新整个统计信息的最大值:

AtomicLong max;

private void updateMax(long sample) {
    while (true) {
        long curMax = max.get();
        if (curMax < sample) {
            boolean result = max.compareAndSet(curMax, sample);
            if (result) break;
        } else {
            break;
        }
    }
}

这个实现是否正确？我正在使用java.util.concurrent,因为我相信它会比简单快synchronized.是否有其他/更好的方法来实现这一点？