标签: java.util.concurrent

我查看了代码,一切都是int - 传递给CountDownLatch构造函数的参数是int,Sync中的变量是int,Sync.getCount()的返回类型是int.但CountDownLatch.getCount()返回一个长？想知道为什么.

我试图了解java.util.concurrent包中的实用程序,并了解到我们可以在方法中成功完成任务之后向callable对象提交ExecutorService,该对象返回Future,其中填充了返回的值.callablecall()

我理解所有的callables都是使用多个线程并发执行的.

当我想看看ExecutorService批量任务执行有多少改进时,我想到了捕获时间.

以下是我试图执行的代码 -

package concurrency;


import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;


public class ExecutorExample {

    private static Callable<String> callable = new Callable<String>() {

        @Override
        public String call() throws Exception {
            StringBuilder builder = new StringBuilder();
            for(int i=0; i<5; i++) {
                builder.append(i);
            }
            return builder.toString();
        }
    };

    public static void main(String [] args) {
        long start = System.currentTimeMillis();
        ExecutorService …

我有一个用例来自GUI问题,我想提交给你的睿智.

用例

我有一个GUI,根据用户在GUI中设置的一些参数显示计算结果.例如,当用户移动滑块时,会触发几个事件,这些事件都会触发新的计算.当用户将滑块值从A调整为B时,会触发数十个事件.

但是计算可能需要几秒钟,而滑块调整可以每隔几百毫秒触发一次事件.

如何编写一个能够监听这些事件的正确线程,并对它们进行过滤以使结果的重绘更加生动？理想情况下,你会喜欢这样的东西

• 收到第一次更改事件后立即开始新的计算;
• 如果收到新事件则取消第一次计算,并用新参数开始新计算;
• 但要确保最后一个事件不会丢失,因为最后完成的计算需要是具有最后更新参数的计算.

我试过了什么

我的一个朋友(A. Cardona)提出了一种更新程序线程的低级方法,可以防止太多事件触发计算.我在这里复制粘贴(GPL):

他把它放在一个扩展Thread的类中:

public void doUpdate() {
    if (isInterrupted())
        return;
    synchronized (this) {
        request++;
        notify();
    }
}

public void quit() {
    interrupt();
    synchronized (this) {
        notify();
    }
}

 public void run() {
    while (!isInterrupted()) {
        try {
            final long r;
            synchronized (this) {
                r = request;
            }
            // Call refreshable update from this thread
            if (r > 0)
                refresh(); // Will trigger re-computation
            synchronized (this) {
                if (r == request) { …

Java提供 AtomicInteger,AtomicLong等等,基本上编译成 CAS指令在硬件层面.但是,为什么这样AtomicXXX类不存在其他原始类型,如short和浮点数喜欢float和double？

根据文档,AtomicInteger.incrementAndGet()是原子的.但是,在下面的源代码中,如果另一个线程在"返回下一个"之前交错怎么办？那么"下一步"会不正确吗？

public final long incrementAndGet() {
    for (;;) {
        long current = get();
        long next = current + 1;
        if (compareAndSet(current, next))
          return next;
    }
}

有了这个简单的代码

import scala.collection.JavaConversions._
new java.util.concurrent.ConcurrentHashMap[String,String]  ().toMap.put("abc","def")

Scala抛出java.lang.UnsupportedOperationException.

为什么？

我偶然发现了Java并发包中CyclicBarrier和Phaser实用程序之间的区别.

我知道CyclicBarrier允许一组线程等到所有线程到达特定点.Phaser也做同样的事情,但它支持多个阶段.我也明白,CyclicBarrier可以重复使用.我认为这个重用工具使其功能与Phaser相同.

考虑以下程序:

测试Phaser:

import java.util.concurrent.Phaser;

public class PhaserTest {

    public static void main(String[] args) {
        Phaser p = new Phaser(3);
        Thread t1 = new Thread(() -> process(p), "T1");
        Thread t2 = new Thread(() -> process(p), "T2");
        Thread t3 = new Thread(() -> process(p), "T3");
        t1.start();
        t2.start();
        t3.start();
    }

    private static void process(Phaser p) {
        try {
            System.out.println("Started Phase 1: "+Thread.currentThread().getName());
            p.arriveAndAwaitAdvance();
            System.out.println("Finished Phase 1: "+Thread.currentThread().getName());
            System.out.println("Started Phase 2: "+Thread.currentThread().getName());
            p.arriveAndAwaitAdvance();
            System.out.println("Finished Phase 2: "+Thread.currentThread().getName());
        } …

我最初使用的更复杂的子类看到此问题ThreadPoolExecutor，但是我已经对其进行了简化，因此现在只包含一些其他调试功能，并且仍然遇到相同的问题。

import com.jthink.songkong.cmdline.SongKong;
import com.jthink.songkong.ui.MainWindow;
import com.jthink.songkong.util.SongKongThreadFactory;

import java.util.concurrent.*;
import java.util.logging.Level;



public class TimeoutThreadPoolExecutor extends ThreadPoolExecutor
{
    /**
     * Uses the default CallerRunsPolicy when queue is full
     *  @param workerSize
     * @param threadFactory
     * @param queue
     */
    public TimeoutThreadPoolExecutor(int workerSize, ThreadFactory threadFactory, LinkedBlockingQueue<Runnable> queue)
    {
        super(workerSize, workerSize, 0L, TimeUnit.MILLISECONDS, queue, threadFactory, new CallerRunsPolicy());
    }

    /**
     * Allow caller to specify the RejectedExecutionPolicy
     *  @param workerSize
     * @param threadFactory
     * @param queue
     * @param reh
     */
    public TimeoutThreadPoolExecutor(int workerSize, …

我有一个递归的分治算法,在开始分割之前需要两个计算密集的基本案例任务.最初的基本案例是独立的任务,所以我想并行完成.在基本情况之后,除法运行相同的任务,在0和1之间输入不同的输入,并根据输出决定是否再次拆分.我通过创建一个伪造递归的任务包装器对象来使基本案例工作,但这感觉就像一个kludge,如下所示:

public static void doSomething () {
    ForkJoinPool pool = new ForkJoinPool();
    private ArrayList<Object> al = new ArrayList<Object>();
    TaskWrapper tw = new TaskWrapper(true,-1);

    al.addAll(pool.invoke(tw));
}

@SuppressWarnings("serial")
public static class TaskWrapper extends RecursiveTask<ArrayList<Object>> {
    private ArrayList<Object> al = new ArrayList<Object>();
    private boolean arg;
    private double input;
    private Object out;

    TaskWrapper(boolean ar, double in){
        arg = ar;
        input = in;
    }

    @Override
    public ArrayList<Object> compute() {
        if (arg == false) {
            out = new Object(runIntensiveTask(input));
            al.add(out);
        }
        else {
            // Right Base …

我将任务安排为：

ScheduledExecutorService dataService = Executors.newScheduledThreadPool(1);
Future<?> dataTimerHandle = dataService.scheduleAtFixedRate(runnable, 100, freq, TimeUnit.MILLISECONDS);

这工作正常，没有缺陷。

但是，当某个标志变为true用户操作时，便不再需要定期执行任务，而只需执行一次即可。然后，我尝试取消任务并仅提交一次，如下所示：

if(!dynamicUpdate) {
    dataTimerHandle.cancel(true); 
    dataTimerHandle = dataService.submit(runnable);
}
else { //Reschedule again:
    dataTimerHandle = dataService.scheduleAtFixedRate(runnable, 100, freq, TimeUnit.MILLISECONDS);
}

但是似乎可运行对象仍在定期执行并且cancel()未按预期工作。是否有其他替代策略？