相关疑难解决方法(0)

lazySet和set方法有AtomicInteger什么区别？该文件并没有太多的话要说lazySet:

最终设置为给定值.

似乎存储的值不会立即设置为所需的值,而是计划在将来的某个时间设置.但是,这种方法的实际用途是什么？任何例子？

HashMap的javadoc声明:

如果在创建迭代器之后的任何时候对映射进行结构修改,除了通过迭代器自己的remove方法之外,迭代器将抛出ConcurrentModificationException.

我构建了一个示例代码,根据规范,它应该几乎立即失败并抛出ConcurrentModificationException;

• 它会像Java 7那样立即失败
• 但它(似乎)始终使用Java 6(即它不会抛出承诺的异常).

注意:它有时不会因Java 7而失败(比如20次中的1次) - 我猜它与线程调度有关(即2个runnables不是交错的).

我错过了什么吗？为什么使用Java 6运行的版本不会抛出ConcurrentModificationException？

实质上,有2个Runnable任务并行运行(倒计时器用于使它们大约同时启动):

• 一个是向地图添加项目
• 另一个是在地图上迭代,读取键并将它们放入数组中

然后主线程检查已添加到阵列的键数.

Java 7典型输出(迭代立即失败):

java.util.ConcurrentModificationException
MAX i = 0

Java 6典型输出(整个迭代通过,数组包含所有添加的键):

MAX i = 99

使用的代码:

public class Test1 {

    public static void main(String[] args) throws InterruptedException {
        final int SIZE = 100;
        final Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        map.put(1, 1);
        map.put(2, 2);
        map.put(3, 3);
        final int[] list = new int[SIZE];
        final CountDownLatch start = new CountDownLatch(1);
        Runnable put …

所有其他原子对象都一样吗？解释AtomicInteger的问题更容易.由于超过1个线程正在访问对myInt的引用,因此对于此对象,一个线程是否可能看到已注册的缓存值,例如null,除非它也被声明为volatile？如果不是怎么来的？

我正在使用一个在发送请求时需要回调的框架.每个回调都必须实现此接口.回调中的方法是异步调用的.

public interface ClientCallback<RESP extends Response>
{
  public void onSuccessResponse(RESP resp);

  public void onFailureResponse(FailureResponse failure);

  public void onError(Throwable e);
}

要使用TestNG编写集成测试,我想要一个阻塞回调.所以我使用CountDownLatch来在线程之间进行同步.

这里真的需要AtomicReference还是原始引用好吗？我知道如果我使用原始引用和原始整数(而不是CountDownLatch),代码将无法工作,因为无法保证可见性.但由于CountDownLatch已经同步,我不确定是否需要AtomicReference的额外同步.注意:Result类是不可变的.

public class BlockingCallback<RESP extends Response> implements ClientCallback<RESP>
{
  private final AtomicReference<Result<RESP>> _result = new AtomicReference<Result<RESP>>();
  private final CountDownLatch _latch = new CountDownLatch(1);

  public void onSuccessResponse(RESP resp)
  {
    _result.set(new Result<RESP>(resp, null, null));
    _latch.countDown();
  }

  public void onFailureResponse(FailureResponse failure)
  {
    _result.set(new Result<RESP>(null, failure, null));
    _latch.countDown();
  }

  public void onError(Throwable e)
  {
    _result.set(new Result<RESP>(null, null, e));
    _latch.countDown();
  }

  public Result<RESP> …

我在java中有一个类,它读取UDP数据包并将它们放在一个对象中(基本上是无限循环).然后,可以在多个单独的线程中访问此对象,但显然,由于它是在同一时间填充的,因此所有这些getter/setter都采用同步方法.问题是,现在这些getter有这样的代码:

public synchronized SomeObject exampleGetter() {
    if(this.isReceiving)
        return oldCachedObject;
    else
        return currentObject;
}

显然,这不是最好的处理方式,所以我应该如何编写方法(许多不同的方法),将对象完全锁定到一个线程并阻塞其他线程(包括创建对象的线程)第一名)？我看了一下synchronized块,但是我对于"锁定对象"有什么影响感到困惑,是那个在给定时间可以访问块的对象？任何意见,将不胜感激.谢谢!