标签: java.util.concurrent

使用 Java 1.6 和 AtomicLongArray，我想将原始 AtomicLongArray “复制”到一个新的 AtomicLongArray 中。有一个构造函数接受一个数组 (AtomicLongArray(long[]))，所以我想我可以从原始数组中获取数组并将其提供给构造函数。

可悲的是， AtomicLongArray 中的实际 long[] 是私有的，似乎没有吸气剂。有没有办法做到这一点，这意味着将值从一个 AtomicLongArray 复制到另一个？我无法基于这个类创建自己的类，因为 sun.misc.Unsafe 类对我不可用。

这是必需的，因为我将迭代这些值，并且我不希望它们在迭代过程中被另一个线程修改。所以我想我可以制作一个副本并将其用于迭代......

谢谢！菲利普

以下代码来自AbstractExecutorService：

 /**
 * Returns a <tt>RunnableFuture</tt> for the given callable task.
 *
 * @param callable the callable task being wrapped
 * @return a <tt>RunnableFuture</tt> which when run will call the
 * underlying callable and which, as a <tt>Future</tt>, will yield
 * the callable's result as its result and provide for
 * cancellation of the underlying task.
 * @since 1.6
 */
 protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
    return new FutureTask<T>(callable);
 }

我不明白为什么返回的对象的类newTaskFor()会被称为 RunnableFuture 而不是 CallableFuture？我在这里错过了什么？

如果异步方法返回一个Future对象，但我们不关心底层操作是成功还是失败，那么调用该方法而不存储返回的结果是否会产生不利影响Future？

提前致谢。

我正在尝试使用以下代码在 java 中的多线程应用程序中部署 TTAS：

AtomicBoolean state= new AtomicBoolean(false);
void lock(){
    while(true)
    {
      while(state.get())
      {
        if(!state.getAndSet(true))
        return;
      }
    }
}

但是，当我尝试旋转它的值时，我如何比较状态的值以检查它是真还是假，而每次遇到错误，说我正在尝试比较两个不同变量的类型？经验：

Lock lock = new Lock();
if(lock.state==true) // error ! 
{
   //do something
}

谢谢你！

以上（标题）是我主要关心的问题。而案例是

public class MyClass{
  CopyOnWriteArrayList<Stuff> min;
  ...
  public List<Stuff> get(){
    return min;
  }
}

生成的列表是从get()负债中获得的吗？它会影响发生的事情min还是它自己的副本？例如，如果我迭代结果，get()会产生什么影响？

另外，当我们这样做的时候，相反怎么样？如果我做

List<Stuff> stuffs = new ArrayList<Stuff>();
addABunchOfItems(stuffs);
CopyOnWriteArrayList safeStuff = (CopyOnWriteArrayList) stuffs;

关于并发支持，第三行及其之后safeStuff的状态是什么？stuffs

ScheduledExecutorService如果网络连接已打开超过几个小时，我将使用 a关闭它。然而，在大多数情况下，网络连接在超时之前关闭，所以我取消了ScheduledFuture. 在这种情况下，我还希望 executor 服务终止并释放其线程池。

令我惊讶的是，这不是开箱即用的：虽然我shutdown()在调度任务后调用了 executor 服务，但当它的唯一调度任务被取消时，executor 服务不会自动终止。从 JavaDoc 中ExecutorService.shutdown()这种行为甚至可能是正确的，因为可以说取消的任务尚未“执行”：

void java.util.concurrent.ExecutorService.shutdown()

启动有序关闭，其中执行先前提交的任务，但不会接受新任务。如果已经关闭，调用没有额外的效果。

我的问题是这是否可以更改：是否可以将执行程序服务配置为在其唯一的计划任务被取消时自动终止？

或者与 JUnit 测试相同的问题：

@Test
public void testExecutorServiceTerminatesWhenScheduledTaskIsCanceled() throws Exception {
    ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

    Runnable task = new Runnable() {
        @Override
        public void run() {
            // ...
        }
    };

    ScheduledFuture<?> scheduledTask = scheduler.schedule(task, 2000, TimeUnit.MILLISECONDS);
    scheduler.shutdown();
    // do more configuration here...

    Thread.sleep(1000);

    scheduledTask.cancel(false);

    Thread.sleep(100);
    assertThat(scheduler.isTerminated(), is(true)); // ... so that this passes!?
}

你怎么知道 ConcurrentHashMap 的函数 computeIfAbsent 必须调用给定的生成器方法（“mappingFunction”）？
从 Javadoc 我相信它会返回新值（如果生成了一个值，如果存在则返回旧值）。我可以从 lambda 生成器函数设置一个外部标志，但这会很尴尬......

我正在阅读Java ForkJoin框架.通过不直接调用(例如)invoke()的实现,但实例化和调用有什么额外的好处？当我们称这两种方法全部被调用时到底发生了什么？ForkJoinTaskRecursiveTaskForkJoinPoolpool.invoke(task)invoke

从源代码来看,似乎如果recursiveTask.invoke被调用,它将以托管线程池的方式调用它exec并最终调用它compute.因此,为什么我们有这个成语更令人困惑pool.invoke(task).

我写了一些简单的代码来测试性能差异,但我没有看到任何.也许测试代码错了？见下文:

public class MyForkJoinTask extends RecursiveAction {

    private static int totalWorkInMillis = 20000;
    protected static int sThreshold = 1000;

    private int workInMillis;


    public MyForkJoinTask(int work) {
        this.workInMillis = work;
    }

    // Average pixels from source, write results into destination.
    protected void computeDirectly() {
        try {

            ForkJoinTask<Object> objectForkJoinTask = new ForkJoinTask<>();
            Thread.sleep(workInMillis);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    protected void …

我正在尝试在 Java 中使用 TimeUnit，但它只是向我发送错误这就是我写的

import java.util.concurrent.TimeUnit ;

public class Anything { 
    public static void main( String[] args ) {
        System.out.println("hi");
        TimeUnit.SECONDS.sleep(6);
        System.out.println("hi");
    }
}

我正在用 java 开发一个 web 服务器，除其他外，它应该在几个用户之间实现一个挑战服务。
每个用户一次只能参加一项挑战。
实际上，我将“挑战”对象存储在 a 中ConcurrentHashMap<String, Challenge>，我使用的String是两个玩家用户名的并集作为映射键。
例如，如果两个玩家的用户名是“Mickey”和“Goofy”，那么Challenge里面的对象的键ConcurrentHashMap就是字符串：

Mickey:Goofy

在 中记录两个用户之间的新挑战时ConcurrentHashMap，我必须在实际将挑战放入 Map 之前检查他们是否已经参与其他挑战，换句话说，我必须检查 Map 中是否存储了一个密钥包含想要开始新挑战的玩家的两个用户名之一。

例如，给定ConcurrentHashMap<String, Challenge>对用户Mickey和的填充和挑战请求Goofy，我想以原子方式知道并且不锁定整个地图，如果他们中的一个（或最终两个）已经参与了地图中的其他注册挑战如果没有，则将新挑战放入地图中。
我希望已经足够清楚了。

你们有什么建议吗？

提前致谢。