标签: java.util.concurrent

当已经有其他实现可用时，还需要引入 Weak HashMap 吗？

简而言之，我有两个问题：

• Why jdk has WeakHashMap when there is HashMap and Concurrent HashMap in java ?

• What is the use of it in real life applications ?

编辑 ：

虽然 WeakHashmap key 是弱引用，但它们仍然引用了一些东西，而不是 GC 在 WeakHashMap 中丢弃键的依据。

我试图了解运行时如何创建未来对象executorService.submit(Callable);

例如，假设我创建了一个线程池，在其中传递可调用的实现

class FactorialCalculator implements Callable<Long> { 
  private int number; 
  public FactorialCalculator(int number) { 
    this.number = number; 
  } 
  @Override 
  public Long call() throws Exception { 
        return (number*number); 
  }
}

我想返回 future 对象，这样我就可以从调用函数中获取返回值。我的自定义线程池如下所示

class MyThreadPool implements java.util.concurrent.Executor 
{
    private final java.util.concurrent.BlockingQueue<Callable> queue;

    public MyThreadPool(int numThreads) {
        queue = new java.util.concurrent.LinkedBlockingQueue<>();
        for (int i=0 ; i<numThreads ; i++) {
            new Thread(new Runnable(){
                @Override
                public void run() {
                    while(true) {
                        queue.take().call();
                    }
                }
            }).start();
        }
    }

    @Override
    public void submit(Callable command) …

我有一个工作单元列表，我想并行处理它们。每个单元工作时间为 8-15 秒，完全计算时间，无 I/O 阻塞。我想要实现的是ExecutorService：

• 当没有工作要做时实例化零个线程
• 如果需要，可以动态扩展到 20 个线程
• 允许我一次添加所有工作单位（不阻止提交）

就像是：

Queue<WorkResult> queue = new ConcurrentLinkedDeque<>();
ExecutorService service = ....
for(WorkUnit unit : list) {
    service.submit(() -> {
        .. do some work ..
        queue.offer(result);
    );
}
while(queue.peek() != null) {
    ... process results while they arrive ...
}

我尝试但没有成功的是：

• 使用 anewCachedThreadPool()创建了太多线程
• 然后我使用了它的内部调用new ThreadPoolExecutor(0, 20, 60L, SECONDS, new SynchronousQueue<>())，但后来我注意到由于同步队列，submit() 被阻塞
• 所以我用过new LinkedBlockingQueue()，只是为了发现 ThreadPoolExecutor 只生成一个线程

我确信有官方的实现来处理这个非常基本的并发用例。有人可以建议吗？

我正在写一个BlockingQueue,我想知道其他实现如何解决这个问题:

如果我只有一个监视器(队列对象)并让生产者和消费者wait,我将不得不确保notifyAll而不是notify被调用,否则生产者可能只发信号通知另一个等待生成器,即使队列已满.即使有东西可供消费者等待.另一方面,notifyAll对许多线程和处理器而言,调用似乎不是可扩展的解决方案.

不要BlockingQueues使用两台显示器？一个是生产者等待,一个是消费者等待？然后我将以封装的方式同步队列和相关监视器.这是要走的路吗？

我正在用Java编写一个负载测试应用程序,并且有一个线程池可以对正在测试的服务器执行任务.因此,要创建1000个作业并在5个线程中运行它,我会执行以下操作:

    ExecutorService pool = Executors.newFixedThreadPool(5);
    List<Runnable> jobs = makeJobs(1000);
    for(Runnable job : jobs){
        pool.execute(job);
    }

但是我并不认为这种方法可以很好地扩展,因为我必须提前制作所有"工作"对象并将它们放在内存中直到需要它们为止.

我正在寻找一种方法让池中的线程在每次需要新工作时都会进入某种"JobFactory"类,并且工厂可以根据请求构建Runnables,直到运行所需的工作数.工厂可能会开始返回'null'来向线程发出信号,表示没有更多的工作要做.

我可以手动编写类似这样的东西,但它似乎是一个常见的用例,并且想知道在我可以使用的精彩但复杂的"java.util.concurrent"包中是否有任何东西？

我尝试将外部非线程安全库集成到我的Web项目中; 我发现为每个客户端线程创建此对象的实例太昂贵了.

因此,我想创建一个具有以下属性的对象池.

1. 动态对象创建时,动态创建池中的对象,而不是在构造函数中创建它们.池最初为空,当客户端线程获取资源对象时,池可以按需创建新资源.一旦创建的对象的数量达到了池的大小; 然后将阻止新的客户端线程,并等待其他线程回收资源.
2. 池应该是公平的,公平性确保第一个要求的线程是获得的第一个线程; 否则有些线程可能会永远等待.

我该怎么做？如果有一个有效的例子,我将不胜感激.

谁可以解释我这个:

final AtomicReference<Integer> atomicReference = new AtomicReference<>(1);
atomicReference.set(2);

在什么意义上最终使用？

来自Java Concurrency in Practice,第12.1章测试正确性,特别是12.1.3 测试安全性(作者希望设置用于测试Bounded Buffer类的数据竞争安全性的测试用例)

为了确保您的测试实际测试您的想法,重要的是校验和本身不能被编译器猜测.使用连续的整数作为测试数据是一个坏主意,因为结果总是相同的,智能编译器可以想象它只是预先计算它.

为了避免这个问题,测试数据应该是随机生成的,但许多其他有效的测试都会受到随机数生成器(RNG)选择不当的影响.随机数生成可以在类和时序工件之间创建耦合,因为大多数随机数生成器类是线程安全的,因此引入了额外的同步.给每个线程自己的RNG允许使用非线程安全的RNG.

我不明白作者反对使用随机数生成器生成测试输入的观点.特别是行随机数生成可以创建类之间的耦合,并且我不清楚时序伪像.

1. 他指的是哪些类和时序工件？
2. RNG可以创造什么样的联轴器？

我正在和一个人合作ScheduledExecutorService.我用这种方式:

ScheduledExecutorService executor;
public class ScheduledFanSpeedController implements Runnable {
.
.
.
public void start(){
executor = Executors.newScheduledThreadPool(1);
executor.scheduleAtFixedRate(this, 0, 55, TimeUnit.SECONDS);
}

该.scheduleAtFixRate可能抛出RejectedExecutionException.如果执行者在第n次执行任务时抛出此异常,我将如何捕获此异常？我是否真的不得不为此压倒一切？

我需要在Clojure程序中实现无限操作.我希望Java程序员的语法也相当清晰:

(defn- my-operation
    (future
        (while @continue
            (do things)
            (Thread/sleep polling-time)))

这给了我我想要的东西,在不同的线程中的操作,因此它不会阻止主要的,并且还有一个非常清晰和直接的语法,而不必处理将迫使我使用点特殊形式的本机Java函数.

但Java未来的定义是"异步计算结果的表示",在这种情况下,我实际上并没有对结果做任何事情.

• 以这种方式使用它们是错误的吗？
• 与启动我自己的Thread相比,是否有任何技术差异应该让我担心？
• 这在语义上是错误的吗？