标签: java.util.concurrent

我试图找到指示java.util.concurrent.Future是否是线程安全的文档.例如,我可以安全地将Future的相同实例提供给多个线程,这些线程都会调用Future.get(...)吗？

我已经用这种方式使用Future测试了代码,它似乎工作得很好,但如果我能找到记录的期望,以这种方式未来对于并发访问是安全的,我会更高兴.

谢谢.

这对于今天另一个问题的回答是一个"副作用" .这更多是关于好奇心而不是实际问题.

Java SE 7提供了Oracle称之为"fork/join框架"的东西.这是将工作安排到多个处理器的一种可能的优秀方式.虽然我理解它应该如何工作,但我无法理解它优越的地方和关于偷工作的说法.

也许其他人更深入地了解为什么这种方法是可取的(除了因为它有一个奇特的名字).

/加盟叉的根本原语ForkJoinTasks,这是FutureS,而这个想法是要么执行工作立即[原文](措辞是误导,因为"立即"意味着它同步发生在主线程,在现实中发生这种情况的内部a Future)低于某个阈值或递归地将工作划分为两个任务,直到达到阈值.

未来是一种封装任务的概念,该任务以不透明和未指定的方式异步运行到对象中.您有一个函数可以验证结果是否可用,并且您获得了一个允许您(等待和)检索结果的函数.
严格地说,你甚至不知道未来是否异步运行,它可以在内部执行get().从理论上讲,实现可以为每个未来生成一个线程或使用线程池.
实际上,Java将future作为任务队列上的任务实现,并附加了一个线程池(对于整个fork/join框架也是如此).

fork/join文档给出了这个具体的用法示例:

protected void compute() {
    if (mLength < sThreshold) {
        computeDirectly();
        return;
    }

    int split = mLength / 2;

    invokeAll(new ForkBlur(mSource, mStart, split, mDestination),
              new ForkBlur(mSource, mStart + split, mLength - split,
                           mDestination));
}

这将以与Mergesort将如何遍历它们的方式相同的方式将任务提交给底层线程池的任务队列(由于递归).
比如说我们有一个32个"项目"的数组要处理并且阈值为4,并且均匀分割,它将产生8个任务,每个具有4个"项目",看起来像这样:

00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 …

想通过ExecutorService的 invokeAll(..)方法运行Runnable任务的集合.但是现在不支持(仅支持可调用任务的集合)

有什么具体的原因吗？做类似事情的替代方法是什么.

我对以下内容感到困惑

我知道,如果我使用该类中的schedule方法ScheduledThreadPoolExecutor:

ScheduledFuture<?> scheduledFuture = 
scheduledThreadPoolExecutor.schedule(myClassRunnable, 5, TimeUnit.SECONDS);

我能够通过或稍后检索值, 并且应该为null,因为该任务只执行了一次并且已完成.并且null因为我正在使用方法版本而不是方法版本.它符合APIscheduledFuture.get(5, TimeUnit.SECONDS)scheduledFuture.get()shedule's Runnableshedule's Callable

直到这里我很好.

我的问题:

ScheduledFuture从scheduleWithFixedDelay(甚至来自scheduleAtFixedRate)方法中检索if 的目的是什么:

ScheduledFuture<?> scheduledFuture= 
scheduledThreadPoolExecutor.scheduleWithFixedDelay(myClassRunnable, 1, 5, TimeUnit.SECONDS);

是的,我知道两种固定方法多次执行相同的任务,直到ScheduledThreadPoolExecutor's shutdown调用该方法(它必须停止所有已安排的任务).

我做了一项研究,通过谷歌寻找一些使用ScheduledFuture返回的例子scheduleWithFixedDelay,我只找到一个使用cancel方法,取消一个特定的任务.但没有人与get合作.

我不知道我是不是错了,但如果我们正在使用,似乎没有get方法scheduleWithFixedDelay,因为如果我以后使用:

• scheduledFuture.get() - 它仍在等待,Runnable对象保持工作多次(运行,完成,延迟,运行等......)
• scheduledFuture.get(32,TimeUnit.SECONDS) - 总是出现TimeoutException

我以为我应该能够检索空值,因为我可以使用方法中的period参数/参数scheduleWithFixedDelay.我的意思是:运行Runnable对象,等待它完成并使用scheduledFuture.get()获取确认它已完成的空值,等待延迟时间的周期再次运行Runnable对象根据period值等....

澄清和例子非常受欢迎

提前致谢.

在Java,没有线程安全版本的HashMap命名的ConcurrentHashMap和线程安全版本TreeMap的命名ConcurrentSkipListMap,但没有ConcurrentHashSet对HashSet的.

相反,通常有4种方法可以使用线程安全Set:

1. Set<String> mySet = Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>());
2. Set<String> s = Collections.synchronizedSet(new HashSet<String>());
3. ConcurrentSkipListSet<E>
4. CopyOnWriteArraySet<E>

1所使用keySet()的ConcurrentHashMap同时实现Set和线程安全的.

2使用synchronized方式,似乎不推荐这种方式.

图3基于ConcurrentSkipListMap并被广泛使用.

4基于CopyOnWriteArrayList,因此它共享相同的基本属性CopyOnWriteArrayList.以下是从CopyOnWriteArraySetdoc中选择:http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/CopyOnWriteArraySet.html

• 它最适合于设置大小通常很小的应用程序,只读操作数量远远超过可变操作,并且您需要在遍历期间防止线程之间的干扰.
• 它是线程安全的.
• 变异操作(添加,设置,删除等)很昂贵,因为它们通常需要复制整个底层阵列.
• 迭代器不支持mutative remove操作.
• 遍历迭代器的速度很快,不会遇到来自其他线程的干扰.
• 迭代器在构造迭代器时依赖于不变的数组快照.

由于常用1和3,为什么CopyOnWriteArraySet存在？什么时候CopyOnWriteArraySet有用？

补充: CopyOnWriteArraySet基于CopyOnWriteArrayList,并且数据结构中的contains操作List是O(n),而Set数据结构是为了高性能contains操作,有人可以解释一下吗？

我有一个场景,我必须为同一个callable异步执行5个线程.据我了解,有两种选择:

1)使用submit(Callable)

ExecutorService executorService = Executors.newFixedThreadPool(5);
List<Future<String>> futures = new ArrayList<>();
for(Callable callableItem: myCallableList){
    futures.add(executorService.submit(callableItem));
}

2)使用invokeAll(Callable集合)

ExecutorService executorService = Executors.newFixedThreadPool(5);
List<Future<String>> futures = executorService.invokeAll(myCallableList));

1. 应该是什么首选方式？
2. 与其他产品相比,它们中的任何产品是否存在任何劣势或性能影响？

我知道这个问题之前已被多次询问和回答,但我无法弄清楚互联网上的例子,比如这个或那个.

这两种解决方案都检查阻塞队列的数组/队列/链表的空白,notifyAll以及put()方法中的等待线程,反之亦然get().一个评论在第二环节强调了这一情况,并提到这是没有必要的.

所以问题是; 检查队列是否为空,对我来说似乎有点奇怪 完全通知所有等待的线程.有任何想法吗？

提前致谢.

关于提高内在锁的性能,Java 6带来的四个主要变化之一是Adapative Spinning技术.什么是自适应纺纱？它是自旋锁和互斥锁的组合吗？有人可以用一种易于理解的方式解释这种策略的有用性,默认情况下可以从JDK6开始使用.

在Java中拥有多个线程池有什么优缺点？我见过代码,其中有多个线程池用于不同的"类型"任务,我不确定它是更好的设计还是只是开发人员是懒惰的.一个示例是使用ScheduledThreadPoolExecutor来定期执行或超时的任务,并使用另一个ThreadPoolExecutor来完成其他任务.

我需要一张符合以下要求的地图:

1. 它应该是高度并发的.的put(),get()并且remove()方法可同时被多个线程调用.

2. 它应该是固定的大小.如果HashMap达到最大值的大小(例如10000),则不应允许向地图添加新条目.它不能是LRU缓存,其中最旧的条目在达到最大大小时被删除.

ConcurrentHashMap可能满足#1.但是,不确定如何在ConcurrentHashMap不影响并发性的情况下实现#2 (添加自定义put()方法,只有当大小小于最大大小时才会添加到地图中,需要"同步".这将失败目的使用并发HashMap).

请让我知道你的想法.