标签: java.util.concurrent

我有两个独立的线程F1和F2(确切地说,两个java.util.concurrent.FutureTask实例)并行运行.

F1进行一些处理,然后将结果复制到XML文件中.然后,它重复这些步骤,直到它无关(创建了许多XML文件).F2查看F1输出目录,取一个文件,解析它,并对其执行一些处理.

这非常有效,除了有时F2从文件中获取截断的XML数据.我的意思是一个不完整的XML,其中一些XML节点不存在.问题是它并不总是可再现的,并且被截断的文件并不总是相同的.因此,我认为当F1在磁盘上写入一个文件时,F2正在尝试读取同一个文件.这就是为什么有时我会遇到这种错误.

我的问题:我想知道是否有一些机制锁定(甚至读取)文件F1当前正在写入,直到它完全完成将其写入磁盘,因此在文件解锁之前F2将无法读取它.或任何其他方式来解决我的问题将是受欢迎的!

F1正在以这种方式编写文件:

try {
    file = new File("some-file.xml");
    FileUtils.writeStringToFile(file, xmlDataAsString);
} catch (IOException ioe) {
    LOGGER.error("Error occurred while storing the XML in a file.", ioe);
}

F2正在以这种方式读取文件:

private File getNextFileToMap() {
    File path = getPath(); // Returns the directory where F1 stores the results...
    File[] files = path.listFiles(new FilenameFilter() {
        public boolean accept(File file, String name) {
            return name.toLowerCase().endsWith(".xml");
        }
    });
    if (files.length > 0) {
        return files[0];
    }
    return null;
}

// Somewhere in my …

根据Javadoc:使用给定计数初始化CountDownLatch.等待方法阻塞,直到当前计数达到零.

这意味着在下面的代码中,因为我将CountDownLatch初始化为1.一旦锁存器调用倒计时,所有线程都应该从其await方法中解除阻塞.

但是,主线程正在等待所有线程完成.而且,我没有加入主线程来结束其他线程.为什么主线程在等待？

    import java.util.concurrent.CountDownLatch;
    import java.util.concurrent.atomic.AtomicLong;

public class Sample implements Runnable {

    private CountDownLatch latch;

    public Sample(CountDownLatch latch)
    {
        this.latch = latch;
    }
    private static AtomicLong number = new AtomicLong(0);

    public long next() {
         return number.getAndIncrement();
    }

    public static void main(String[] args) {

        CountDownLatch latch = new CountDownLatch(1);
        for (int threadNo = 0; threadNo < 4000; threadNo++) {
          Runnable t = new Sample(latch);
          new Thread(t).start();
        }
        try {
            latch.countDown();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public …

我想知道size()调用ConcurrentHashMap的size()方法是否与通常的HashMap方法具有相同的复杂性.

我意识到你获得了更多的自定义,但是使用并发库类而不仅仅是使用库存AsyncTask还是仅创建线程并调用run,是否有性能(内存/速度)优势？

我会描述我的问题:

• 我正在开发异步模式下的文档生成(Office文档)应用程序,所以我使用Threads

• 由于性能限制,我必须同时启动2个线程,

• 为了在两个线程运行时不阻止用户启动文档生成,我想开发一个包含ArrayDeque对象作为线程堆栈的主线程,用户可以在其中添加创建请求(作为实现Collable或Runnable接口的对象)并使用Concurrent API在FIFO模式下启动线程

  问题是:

• 如何确保将主线程作为所有用户的单例运行？

• 如何在主运行线程上调用ArrayDeque

我找不到使用最新JAVA并发例程的这种特定情况的示例.

我打算用来threads处理开放队列中的项目,这些项目可能包含0到数千个请求.我想限制所以在任何给定时间,不少于0并且不超过10个线程处理队列项.

是否有针对此特定类型案例的Java并发流程？

我有N个任务,我希望它们与N个线程并行处理.我想等到所有任务完成,存储结果,然后运行下N个任务(依次循环).

来自java util并发的哪些抽象可以帮助我？

我查看了ExecutorService.invokeAll(),但是它返回了一个期货列表,所以我应该循环遍历它们直到所有这些完成.

我想,应该有更简单的方法来计算一组任务.

是否存在满足以下规则的锁或其他同步原语:

• 锁具有无限许可,
• 任何单个线程最多只能获得一个许可,
• 没有持有许可证的线程可以随时获得许可证,
• 当一个线程被拒绝一个许可证(即它已经拥有一个)时,它应该返回一个boolean而不是一个块(duh).

我知道我可以使用一个自己构建这个,AbstractQueuedSynchronizer但我从来没有玩过这个,目前我只需要一个开箱即用的无问题解决方案.(我很好奇,如果它存在)

还有一件事:

• 除了添加一个或两个额外类之外,不允许使用库

我理解(或者至少我认为我做;))volatile关键词背后的原则.在查看ConcurrentHashMap源代码时,您可以看到所有节点和值都已声明volatile,这是有道理的,因为可以从多个线程写入/读取值:

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    volatile V val;
    volatile Node<K,V> next;
    ...
}

但是,查看ArrayBlockingQueue源代码,它是一个正在从多个线程更新/读取的普通数组:

private void enqueue(E x) {
    // assert lock.getHoldCount() == 1;
    // assert items[putIndex] == null;
    final Object[] items = this.items;
    items[putIndex] = x;
    if (++putIndex == items.length)
        putIndex = 0;
    count++;
    notEmpty.signal();
}

如果保证插入的值items[putIndex]在另一个线程中是可见的,只要数组中的元素不是volatile(我知道声明数组本身对元素本身无论如何都没有任何影响)如何保证？另一个线程无法保存数组的缓存副本吗？

谢谢

我有一个ConcurrentSkipListMap。我需要删除低于的元素key。

这是我可以执行的方法：

private ConcurrentNavigableMap<Double, MyObject> myObjectsMap = new ConcurrentSkipListMap<>();

//...

myObjectsMap = myObjectsMap.tailMap(10.25, false);

看起来还不错，但是我对这些事实感到困惑：

1。

返回的地图受此地图支持，因此返回的地图中的更改会反映在此地图中，反之亦然。

这是否意味着垃圾回收器不会删除旧值？
即，我们删除了旧地图，现在有了新地图。但是此新地图得到了旧地图的支持。那么，旧地图会怎样？是将其删除还是将其永久保存在内存中？

2。

尝试插入超出其范围的键时，返回的映射将抛出IllegalArgumentException。

因此，现在我不能放置小于10.25且大于最后一个最大值的新键了吗？

我很困惑。然后如何正确地需要从ConcurrentSkipListMap中删除元素？