`
379427555
  • 浏览: 18952 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

原子计量器类AtomicLong, AtomicInteger, AtomicReference

    博客分类：
  • jvee
多线程CC++C#thread 
阅读更多

J2SE 5.0提供了一组atomic class来帮助我们简化同步处理。基本工作原理是使用了同步synchronized的方法实现了对一个long, integer, 对象的增、减、赋值（更新）操作. 比如对于++运算符AtomicInteger可以将它持有的integer 能够atomic 地递增。在需要访问两个或两个以上 atomic变量的程序代码（或者是对单一的atomic变量执行两个或两个以上的操作）通常都需要被synchronize以便两者的操作能够被当作是一个atomic的单元。

对array atomic变量来说，一次只有一个索引变量可以变动，并没有功能可以对整个array做atomic化的变动。

关于Atomic的几个方法
getAndSet() : 设置新值，返回旧值.
compareAndSet(expectedValue, newValue) : 如果当前值(current value)等于期待的值(expectedValue), 则原子地更新指定值为新值(newValue), 如果更新成功，返回true, 否则返回false, 换句话可以这样说: 将原子变量设置为新的值, 但是如果从我上次看到的这个变量之后到现在被其他线程修改了(和我期望看到的值不符), 那么更新失败

从effective java (2)中拿来的一个关于AtomicReference的一个例子:
Java代码

Java代码
  1. public class AtomicTest {      
  2.     private int x, y;      
  3.      
  4.     private enum State {      
  5.         NEW, INITIALIZING, INITIALIZED      
  6.     };      
  7.      
  8.     private final AtomicReference<State> init = new AtomicReference<State>(State.NEW);      
  9.           
  10.     public AtomicTest() {      
  11.     }      
  12.           
  13.     public AtomicTest(int x, int y) {      
  14.         initialize(x, y);      
  15.     }      
  16.      
  17.     private void initialize(int x, int y) {      
  18.         if (!init.compareAndSet(State.NEW, State.INITIALIZING)) {      
  19.             throw new IllegalStateException("initialize is error");      
  20.         }      
  21.         this.x = x;      
  22.         this.y = y;      
  23.         init.set(State.INITIALIZED);      
  24.     }      
  25.      
  26.     public int getX() {      
  27.         checkInit();      
  28.         return x;      
  29.     }      
  30.      
  31.     public int getY() {      
  32.         checkInit();      
  33.         return y;      
  34.     }      
  35.           
  36.     private void checkInit() {      
  37.         if (init.get() == State.INITIALIZED) {      
  38.             throw new IllegalStateException("uninitialized");      
  39.         }      
  40.     }      
  41.           
  42. }     
  43.   
  44. public class AtomicTest {   
  45.     private int x, y;   
  46.   
  47.     private enum State {   
  48.         NEW, INITIALIZING, INITIALIZED   
  49.     };   
  50.   
  51.     private final AtomicReference<State> init = new AtomicReference<State>(State.NEW);   
  52.        
  53.     public AtomicTest() {   
  54.     }   
  55.        
  56.     public AtomicTest(int x, int y) {   
  57.         initialize(x, y);   
  58.     }   
  59.   
  60.     private void initialize(int x, int y) {   
  61.         if (!init.compareAndSet(State.NEW, State.INITIALIZING)) {   
  62.             throw new IllegalStateException("initialize is error");   
  63.         }   
  64.         this.x = x;   
  65.         this.y = y;   
  66.         init.set(State.INITIALIZED);   
  67.     }   
  68.   
  69.     public int getX() {   
  70.         checkInit();   
  71.         return x;   
  72.     }   
  73.   
  74.     public int getY() {   
  75.         checkInit();   
  76.         return y;   
  77.     }   
  78.        
  79.     private void checkInit() {   
  80.         if (init.get() == State.INITIALIZED) {   
  81.             throw new IllegalStateException("uninitialized");   
  82.         }   
  83.     }   
  84.        
  85. }  
public class AtomicTest {   
    private int x, y;   
  
    private enum State {   
        NEW, INITIALIZING, INITIALIZED   
    };   
  
    private final AtomicReference<State> init = new AtomicReference<State>(State.NEW);   
       
    public AtomicTest() {   
    }   
       
    public AtomicTest(int x, int y) {   
        initialize(x, y);   
    }   
  
    private void initialize(int x, int y) {   
        if (!init.compareAndSet(State.NEW, State.INITIALIZING)) {   
            throw new IllegalStateException("initialize is error");   
        }   
        this.x = x;   
        this.y = y;   
        init.set(State.INITIALIZED);   
    }   
  
    public int getX() {   
        checkInit();   
        return x;   
    }   
  
    public int getY() {   
        checkInit();   
        return y;   
    }   
       
    private void checkInit() {   
        if (init.get() == State.INITIALIZED) {   
            throw new IllegalStateException("uninitialized");   
        }   
    }   
       
}  

public class AtomicTest {
 private int x, y;

 private enum State {
  NEW, INITIALIZING, INITIALIZED
 };

 private final AtomicReference<State> init = new AtomicReference<State>(State.NEW);
 
 public AtomicTest() {
 }
 
 public AtomicTest(int x, int y) {
  initialize(x, y);
 }

 private void initialize(int x, int y) {
  if (!init.compareAndSet(State.NEW, State.INITIALIZING)) {
   throw new IllegalStateException("initialize is error");
  }
  this.x = x;
  this.y = y;
  init.set(State.INITIALIZED);
 }

 public int getX() {
  checkInit();
  return x;
 }

 public int getY() {
  checkInit();
  return y;
 }
 
 private void checkInit() {
  if (init.get() == State.INITIALIZED) {
   throw new IllegalStateException("uninitialized");
  }
 }
 
}



上面的例子比较容易懂, 不过貌似没什么价值, 而在实际的应用中, 我们一般采用下面的方式来使用atomic class:
Java代码

Java代码
  1. public class CounterTest {      
  2.     AtomicInteger counter = new AtomicInteger(0);      
  3.      
  4.     public int count() {      
  5.         int result;      
  6.         boolean flag;      
  7.         do {      
  8.             result = counter.get();      
  9.             // 断点      
  10.             // 单线程下, compareAndSet返回永远为true,      
  11.             // 多线程下, 在与result进行compare时, counter可能被其他线程set了新值, 这时需要重新再取一遍再比较,      
  12.             // 如果还是没有拿到最新的值, 则一直循环下去, 直到拿到最新的那个值      
  13.             flag = counter.compareAndSet(result, result + 1);      
  14.         } while (!flag);      
  15.      
  16.         return result;      
  17.     }      
  18.      
  19.     public static void main(String[] args) {      
  20.         final CounterTest c = new CounterTest();      
  21.         new Thread() {      
  22.             @Override     
  23.             public void run() {      
  24.                 c.count();      
  25.             }      
  26.         }.start();      
  27.      
  28.         new Thread() {      
  29.             @Override     
  30.             public void run() {      
  31.                 c.count();      
  32.             }      
  33.         }.start();      
  34.      
  35.         new Thread() {      
  36.             @Override     
  37.             public void run() {      
  38.                 c.count();      
  39.             }      
  40.         }.start();      
  41.     }      
  42. }     
  43.   
  44. public class CounterTest {   
  45.     AtomicInteger counter = new AtomicInteger(0);   
  46.   
  47.     public int count() {   
  48.         int result;   
  49.         boolean flag;   
  50.         do {   
  51.             result = counter.get();   
  52.             // 断点   
  53.             // 单线程下, compareAndSet返回永远为true,   
  54.             // 多线程下, 在与result进行compare时, counter可能被其他线程set了新值, 这时需要重新再取一遍再比较,   
  55.             // 如果还是没有拿到最新的值, 则一直循环下去, 直到拿到最新的那个值   
  56.             flag = counter.compareAndSet(result, result + 1);   
  57.         } while (!flag);   
  58.   
  59.         return result;   
  60.     }   
  61.   
  62.     public static void main(String[] args) {   
  63.         final CounterTest c = new CounterTest();   
  64.         new Thread() {   
  65.             @Override  
  66.             public void run() {   
  67.                 c.count();   
  68.             }   
  69.         }.start();   
  70.   
  71.         new Thread() {   
  72.             @Override  
  73.             public void run() {   
  74.                 c.count();   
  75.             }   
  76.         }.start();   
  77.   
  78.         new Thread() {   
  79.             @Override  
  80.             public void run() {   
  81.                 c.count();   
  82.             }   
  83.         }.start();   
  84.     }   
  85. }  
public class CounterTest {   
    AtomicInteger counter = new AtomicInteger(0);   
  
    public int count() {   
        int result;   
        boolean flag;   
        do {   
            result = counter.get();   
            // 断点   
            // 单线程下, compareAndSet返回永远为true,   
            // 多线程下, 在与result进行compare时, counter可能被其他线程set了新值, 这时需要重新再取一遍再比较,   
            // 如果还是没有拿到最新的值, 则一直循环下去, 直到拿到最新的那个值   
            flag = counter.compareAndSet(result, result + 1);   
        } while (!flag);   
  
        return result;   
    }   
  
    public static void main(String[] args) {   
        final CounterTest c = new CounterTest();   
        new Thread() {   
            @Override  
            public void run() {   
                c.count();   
            }   
        }.start();   
  
        new Thread() {   
            @Override  
            public void run() {   
                c.count();   
            }   
        }.start();   
  
        new Thread() {   
            @Override  
            public void run() {   
                c.count();   
            }   
        }.start();   
    }   
}  

public class CounterTest {
 AtomicInteger counter = new AtomicInteger(0);

 public int count() {
  int result;
  boolean flag;
  do {
   result = counter.get();
   // 断点
   // 单线程下, compareAndSet返回永远为true,
   // 多线程下, 在与result进行compare时, counter可能被其他线程set了新值, 这时需要重新再取一遍再比较,
   // 如果还是没有拿到最新的值, 则一直循环下去, 直到拿到最新的那个值
   flag = counter.compareAndSet(result, result + 1);
  } while (!flag);

  return result;
 }

 public static void main(String[] args) {
  final CounterTest c = new CounterTest();
  new Thread() {
   @Override
   public void run() {
    c.count();
   }
  }.start();

  new Thread() {
   @Override
   public void run() {
    c.count();
   }
  }.start();

  new Thread() {
   @Override
   public void run() {
    c.count();
   }
  }.start();
 }
}


类似i++这样的"读-改-写"复合操作(在一个操作序列中, 后一个操作依赖前一次操作的结果), 在多线程并发处理的时候会出现问题, 因为可能一个线程修改了变量, 而另一个线程没有察觉到这样变化, 当使用原子变量之后, 则将一系列的复合操作合并为一个原子操作,从而避免这种问题, i++=>i.incrementAndGet()
原子变量只能保证对一个变量的操作是原子的, 如果有多个原子变量之间存在依赖的复合操作, 也不可能是安全的, 另外一种情况是要将更多的复合操作作为一个原子操作, 则需要使用synchronized将要作为原子操作的语句包围起来. 因为涉及到可变的共享变量(类实例成员变量)才会涉及到同步, 否则不必使用synchronized

分享到：
| 关于android adt eclipse myeclipse 的安 ...
评论
1 楼 543089122 2011-09-29  
LZ这代码贴的。。。惨不忍睹
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    JUC面试知识点手册快速版

    5.1 AtomicInteger与AtomicLong 5.2 AtomicReference 第六章：线程池及其应用 6.1 ThreadPoolExecutor 6.2 ScheduledThreadPoolExecutor 第七章：Fork/Join框架 7.1 ForkJoinPool 等等

    Java concurrency之AtomicLong原子类_动力节点Java学院整理

    Java concurrency之AtomicLong原子类_动力节点Java学院整理，动力节点口口相传的Java黄埔军校

    聊聊并发（5）原子操作的实现原理Java开发Java经验技

    Java中提供了`java.util.concurrent.atomic`包，该包包含了一系列的原子类，如AtomicInteger、AtomicLong、AtomicReference等。这些类提供的原子操作主要基于硬件层面的CAS（Compare and Swap，比较并交换）指令来...

    原子类测试

    - `AtomicIntegerFieldUpdater`、`AtomicLongFieldUpdater`和`AtomicReferenceFieldUpdater`：动态生成特定类的某个字段的原子更新器，适用于无法直接访问的类的字段。 4. 原子类的工作原理： 原子类内部利用了...

    java并发工具包详解

    1. java.util.concurrent - Java 并发工具包 2. 阻塞队列 BlockingQueue 3. 数组阻塞队列 ArrayBlockingQueue 4. 延迟队列 DelayQueue 5. 链阻塞队列 LinkedBlockingQueue ...25. 原子性引用型 AtomicReference

    Java多线程中提到的原子性和可见性、有序性1

    为了解决这个问题，Java提供了`java.util.concurrent.atomic`包下的原子类，如AtomicInteger、AtomicLong和AtomicReference等。这些原子类的更新操作由Java内存模型直接保证原子性。此外，`synchronized`关键字的...

    java并发工具包 java.util.concurrent中文版用户指南pdf

    1. java.util.concurrent - Java 并发工具包 2. 阻塞队列 BlockingQueue 3. 数组阻塞队列 ArrayBlockingQueue 4. 延迟队列 DelayQueue 5. 链阻塞队列 LinkedBlockingQueue ...25. 原子性引用型 AtomicReference

    java里的volatile关键字详解

    1. AtomicInteger、AtomicLong、AtomicReference等，这些原子类提供了一些原子操作，可以用来实现原子性。 2. 这些原子类可以用来解决线程安全问题，例如，使用AtomicInteger可以实现原子性的自增操作。 五、Java中...

    一个小的java Demo , 非常适合Java初学者学习阅读.rar

    数组阻塞队列ArrayBlockingQueue,延迟队列DelayQueue, ...原子性长整型 AtomicLong,原子性引用型 AtomicReference 修改数据: 一 服务端修改数据: 一 文章知识点与官方知识档案匹配，可进一步学习相关知识

    Java16个原子类介绍-基于JDK8.docx

    Java 原子类是Java并发编程中非常重要的工具，它们提供了一种高效且线程安全的方式来更新变量，尤其在处理共享数据时。在JDK 7及之前，共有12个原子类，而在JDK 8中，又新增了4个。下面，我们将详细介绍这些原子类...

    Java并发——无锁实现

    这些类包括AtomicInteger、AtomicLong、AtomicReference等，它们都是通过底层的CAS操作来实现无锁线程安全访问的。例如，AtomicInteger类提供了如compareAndSet、getAndIncrement等原子操作方法，这些方法内部都使用...

    Java中对AtomicInteger和int值在多线程下递增操作的测试

    为了确保数据在并发访问时的正确性，Java提供了一系列的原子类，包括`AtomicInteger`，它为整数类型的变量提供了线程安全的更新操作。这个话题将深入探讨`AtomicInteger`与普通`int`变量在多线程环境下进行递增操作...

    java多线程中的原子操作

    在Java中，`java.util.concurrent.atomic`包提供了多种原子类，如AtomicInteger、AtomicLong等，这些类支持原子性的增加、减小、更新等操作，避免了显式的同步锁的使用，提高了并发性能。例如，AtomicInteger的...

    关于 java.util.concurrent 您不知道的 5 件事，第 2 部分

    原子类如AtomicInteger、AtomicLong和AtomicReference等提供了一种无锁的更新机制，保证了在高并发场景下的数据一致性。它们通过CAS（Compare and Swap）操作实现原子性，避免了synchronized关键字带来的开销，提高...

    concurrent-1.3.4.jar

    原子操作：concurrent包提供了一些原子操作类，如AtomicInteger、AtomicLong等，可以实现无锁的线程安全操作，避免了使用锁带来的性能损耗。 线程池：concurrent包提供了Executor框架，可以方便地创建和管理线程池，...

    kotlinx.atomicfu,在kotlin中使用原子操作的惯用方法.zip

    在Kotlinx.AtomicFu中，主要包含了一些原子类，如`AtomicInt`, `AtomicLong`, `AtomicReference`等，它们提供了原子性的增加、减少、比较并交换（compareAndSet）等操作。 1. **AtomicInt**: 这个类提供了对整型值...

    并发编程——原子操作CAS.pdf

    文档重点介绍了基本类型原子更新类，如AtomicInteger、AtomicLong和AtomicBoolean。这类类能够以原子方式更新基本数据类型的值。文档中的示例代码展示了如何通过这些类来确保多线程环境下对共享变量的并发安全访问。...

    Java并发工具包

    Atomic类，如AtomicInteger、AtomicLong和AtomicReference，提供了在不使用锁的情况下实现原子更新的能力。这些类提供了原子操作，如incrementAndGet()，decrementAndGet()，compareAndSet()等，用于在高并发环境下...

Magicbox
Global site tag (gtag.js) - Google Analytics