`
micheal19840929
  • 浏览: 166281 次
  • 性别: Icon_minigender_1
  • 来自: 广州
社区版块
存档分类
最新评论

原子变量(AtomicLong, AtomicInteger, AtomicReference)

    博客分类：
  • J2SE
多线程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

分享到：
| J2ME下的点阵字实现
评论
发表评论

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

相关推荐

    JUC面试知识点手册快速版

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

    Java原子变量类原理及实例解析

    AtomicInteger是Java中的一个原子变量类，它可以对整型变量进行原子操作。它提供了许多有用的方法，例如get()、getAndSet()、getAndIncrement()、getAndDecrement()、getAndAdd()等。 例如，使用AtomicInteger可以...

    java并发工具包详解

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

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

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

    Java并发编程实践-电子书-08章实用.pdf

    为了解决这些问题，Java 5.0引入了**原子变量类**，如`AtomicInteger`、`AtomicLong`、`AtomicBoolean`和`AtomicReference`等，它们位于`java.util.concurrent.atomic`包中。这些类提供了无锁的、基于CAS操作...

    Java并发工具包java.util.concurrent用户指南中英文对照阅读版

    本资源包含两个 pdf 文档，一本根据 Jakob Jenkov 最新博客 (http://tutorials.jenkov.com/java-util-concurrent/index.html) 整理的 java_util_concurrent_user_guide_en.pdf，一...25. 原子性引用型 AtomicReference

    Java并发编程实践

    6. **原子变量**：分析AtomicInteger、AtomicLong和AtomicReference等原子变量类，以及它们如何实现无锁编程和高效并发操作。 7. **线程局部变量**：解释ThreadLocal类的工作原理，如何为每个线程提供独立的变量...

    java并发包资源

    本资源包含两个 pdf 文档，一本根据 Jakob Jenkov 最新博客 (http://tutorials.jenkov.com/java-util-concurrent/index.html) 整理的 java_util_concurrent_user_guide_en.pdf，一...25. 原子性引用型 AtomicReference

    java并发编程库

    例如，AtomicInteger、AtomicLong和AtomicReference等。原子变量的实现依赖于现代CPU提供的原子指令，如CAS（Compare-And-Swap）指令，这些指令能够确保在多线程环境下对变量的更新操作的原子性，从而避免复杂的加锁...

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

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

    java里的volatile关键字详解

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

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

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

    java 并发编程

    为了保证线程安全，可以采取以下几种策略：避免跨线程共享变量，使用不可变对象（final常量），使用ThreadLocal保存状态变量，控制变量的可见性（通过volatile关键字或原子变量如AtomicLong和AtomicReference等），...

    Java多线程Atomic包操作原子变量与原子类详解

    1. `AtomicBoolean`, `AtomicInteger`, `AtomicLong`: 这些类分别提供了对布尔值、整型和长整型的原子操作。它们提供了`get()`, `set()`, `compareAndSet()`, `incrementAndGet()`等方法，这些方法在多线程环境下...

    Java并发工具包

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

    【学习笔记】JUC基础基础程序

    原子类如AtomicInteger、AtomicLong和AtomicReference是线程安全的变量，它们提供了一种无锁编程的方式，可以在不使用synchronized的情况下保证更新的原子性。这些类在高并发场景下能提供更好的性能。 最后，...

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

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

    Java并发——无锁实现

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

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