标签: java.util.concurrent

java.util.concurrentAPI提供了一个名为as的类Lock,它基本上将序列化控件以访问关键资源.它给出了诸如park()和的方法unpark().

我们可以做类似的事情,如果我们可以使用synchronized关键字,并使用wait()和notify() notifyAll()方法.

我想知道其中哪一个在实践中更好,为什么？

在java中是否存在Mutex对象或创建一个？我问,因为用1许可证初始化的信号量对象对我没有帮助.想想这个案例:

try {
   semaphore.acquire();
   //do stuff
   semaphore.release();
} catch (Exception e) {
   semaphore.release();
}

如果在第一次获取时发生异常,则catch块中的释放将增加许可,并且信号量不再是二进制信号量.

请问是正确的方法吗？

try {
   semaphore.acquire();
   //do stuff
} catch (Exception e) {
   //exception stuff
} finally {
   semaphore.release();
}

上面的代码会确保信号量是二进制的吗？

所以我有一个程序产生线程(~5-150)执行一堆任务.最初我使用的是FixedThreadPool因为这个类似的问题表明它们更适合长寿命的任务,而且由于我对多线程的知识非常有限,我认为线程的平均寿命(几分钟)" 长寿 ".

但是,我最近添加了生成其他线程的功能,这样做超过了我设置的线程限制.在这种情况下,最好猜测并增加我可以允许的线程数或切换到一个CachedThreadPool所以我没有浪费线程？

初步尝试它们,似乎没有什么区别,所以我倾向于选择CachedThreadPool公正以避免浪费.但是,线程的生命周期是否意味着我应该选择一个FixedThreadPool并且只处理未使用的线程？这个问题使得看起来这些额外的线程没有浪费,但我希望澄清.

我的一个应用程序在负载运行的一段时间内挂起,是否有人知道在jstack中可能导致此类输出的原因:

"scheduler-5" prio=10 tid=0x00007f49481d0000 nid=0x2061 waiting on condition [0x00007f494e8d0000]
   java.lang.Thread.State: WAITING (parking)
        at sun.misc.Unsafe.park(Native Method)
        - parking to wait for  <0x00000006ee117310> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
        at java.util.concurrent.locks.LockSupport.park(LockSupport.java:186)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2043)
        at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(ScheduledThreadPoolExecutor.java:1085)
        at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(ScheduledThreadPoolExecutor.java:807)
        at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1043)
        at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1103)
        at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:603)
        at java.lang.Thread.run(Thread.java:722)

当它挂起时,我在jstack输出中看到了很多.

我大量使用Spring @Async和地图,同步地图和ehcache.

有趣的是,这只发生在一个app实例上.另外两个人跑得很好.还有什么我可以调查以获得更多细节？

我发现这篇文章/sf/ask/1679495121/,但在我的情况下它并不是很有用.

我想知道的基本区别shutdown(),并shutdownNow()为关闭Executor Service？据我了解shutdown()应该用于优美关机,这意味着人乳宁,并排队等待处理,但尚未开始应该可以完成所有任务,并shutdownNow()做一个突然关机意味着一些未完成的任务被取消,未启动的任务也被取消.我还缺少哪些隐含/明确的东西？

PS:我发现了另一个问题,关于SO与此相关的,但不是我想知道到底是什么.

我听说Java 8提供了很多关于并发计算的实用程序.因此,我想知道并行化给定for循环的最简单方法是什么？

public static void main(String[] args)
{
    Set<Server> servers = getServers();
    Map<String, String> serverData = new ConcurrentHashMap<>();

    for (Server server : servers)
    {
        String serverId = server.getIdentifier(); 
        String data = server.fetchData();

        serverData.put(serverId, data);
    }
}

在JDK8中,当我使用parallelStream时会产生多少个线程？例如,在代码中:

list.parallelStream().forEach(/** Do Something */);

如果此列表包含100000个项目,将生成多少个线程？

另外,每个线程都可以获得相同数量的项目,还是随机分配？

这是JavaDoc关于的一段话ConcurrentHashMap.它说检索操作通常不会阻塞,因此可能与更新操作重叠.这是否意味着该get()方法不是线程安全的？

"但是,即使所有操作都是线程安全的,检索操作也不需要锁定,并且没有任何支持以阻止所有访问的方式锁定整个表.这个类可以在依赖于的程序中与Hashtable完全互操作.它的线程安全,但不是它的同步细节.

检索操作(包括get)通常不会阻塞,因此可能与更新操作(包括put和remove)重叠.检索反映了最近完成的更新操作的结果."

我花了一些时间学习Scala执行上下文,底层线程模型和并发的主题.您能解释一下scala.concurrent.blocking "调整运行时行为"和"可以提高性能或避免死锁"的方式,如scaladoc中所述？

在文档中,它被作为一种等待api的手段,它不实现Awaitable.(也许只是长时间运行的计算应该被包装？).

它究竟是做什么的？

通过消息来源不容易背叛其秘密.

是否可以使用Collections.synchronizedMap()并发保持正确性来重写下面的代码片段？

Collections.synchronizedMap(new WeakHashMap<Class, Object>());

即是否可以使用java.util.concurrent中的东西？请注意,仅替换为

new ConcurrentHashMap<Class, Object>(new WeakHashMap<Class, Object>()));

显然不行