Java JUC Atomic

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

  
import java.util.concurrent.atomic.AtomicInteger;
  
public class AtomicIntegerTest { 

/**
       
* 常见的方法列表
       
* @see AtomicInteger#get() 直接返回值
       
* @see AtomicInteger#getAndAdd(int) 增加指定的数据,返回变化前的数据
       
* @see AtomicInteger#getAndDecrement() 减少1,返回减少前的数据
       
* @see AtomicInteger#getAndIncrement() 增加1,返回增加前的数据
       
* @see AtomicInteger#getAndSet(int) 设置指定的数据,返回设置前的数据
       
*
       
* @see AtomicInteger#addAndGet(int) 增加指定的数据后返回增加后的数据
       
* @see AtomicInteger#decrementAndGet() 减少1,返回减少后的值
       
* @see AtomicInteger#incrementAndGet() 增加1,返回增加后的值
       
* @see AtomicInteger#lazySet(int) 仅仅当get时才会set
       
*
       
* @see AtomicInteger#compareAndSet(int, int) 尝试新增后对比,若增加成功则返回true否则返回false
       
*/
      
public final static AtomicInteger TEST_INTEGER = new AtomicInteger(1); 

public static void main(String []args) throws InterruptedException {
          
final Thread []threads = new Thread[10];
           
for(int i = 0 ; i < 10 ; i++) {
               
final int num = i;
               
threads[i] = new Thread() {
                   
public void run() {
                       
try {
                          
Thread.sleep(1000);
                      
} catch (InterruptedException e) {
                          
e.printStackTrace();
                      
}
                      
int now = TEST_INTEGER.incrementAndGet();
                      
System.out.println("我是线程: " + num + ",我得到值了,增加后的值为: " + now);
                   
}
               
};
               
threads[i].start();
           
}
           
for(Thread t : threads) {
               
t.join();
           
}
           
System.out.println("最终运行结果: " + TEST_INTEGER.get());
      
}
  
}
  

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

  
import java.util.concurrent.atomic.AtomicBoolean; 

public class AtomicBooleanTest { 

/**
       
* 主要方法: 
       
* @see AtomicBoolean#compareAndSet(boolean, boolean) 第一个参数为原始值,第二个参数为要修改的新值,若修改成功则返回true,否则返回false
       
* @see AtomicBoolean#getAndSet(boolean) 尝试设置新的boolean值,直到成功为止,返回设置前的数据
       
*/
      
public final static AtomicBoolean TEST_BOOLEAN = new AtomicBoolean(); 

public static void main(String []args) {
          
for(int i = 0 ; i < 10 ; i++) {
              
new Thread() {
                  
public void run() {
                      
try {
                          
Thread.sleep(1000);
                      
} catch (InterruptedException e) {
                          
e.printStackTrace();
                      
}
                      
if(TEST_BOOLEAN.compareAndSet(false, true)) {
                          
System.out.println("我成功了！");
                      
}
                  
}
              
}.start();
          
}
      
}
  
}
  

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

  
import java.util.concurrent.atomic.AtomicReference; 

public class AtomicReferenceTest { 

/**
       
* 相关方法列表
       
* @see AtomicReference#compareAndSet(Object, Object) 对比设置值,参数1: 原始值,参数2: 修改目标引用
       
* @see AtomicReference#getAndSet(Object) 将引用的目标修改为设置的参数,直到修改成功为止,返回修改前的引用
       
*/
      
public final static AtomicReference <String>ATOMIC_REFERENCE = new AtomicReference<String>("abc"); 

public static void main(String []args) {
          
for(int i = 0 ; i < 100 ; i++) {
              
final int num = i;
              
new Thread() {
                  
public void run() {
                      
try {
                          
Thread.sleep(Math.abs((int)(Math.random() * 100)));
                      
} catch (InterruptedException e) {
                          
e.printStackTrace();
                      
}
                      
if(ATOMIC_REFERENCE.compareAndSet("abc", new String("abc"))) {
                          
System.out.println("我是线程: " + num + ",我获得了锁进行了对象修改！");
                      
}
                  
}
              
}.start();
          
}
      
}
  
}
  

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

  
import java.util.concurrent.atomic.AtomicReference; 

/**
   
* ABA问题模拟,线程并发中,导致ABA问题,解决方案是使用|AtomicMarkableReference
   
* 请参看相应的例子: AtomicStampedReferenceTest、AtomicMarkableReferenceTest
   
*
   
*/
  
public class AtomicReferenceABATest { 

public final static AtomicReference <String>ATOMIC_REFERENCE = new AtomicReference<String>("abc"); 

public static void main(String []args) {
          
for(int i = 0 ; i < 100 ; i++) {
              
final int num = i;
              
new Thread() {
                  
public void run() {
                      
try {
                          
Thread.sleep(Math.abs((int)(Math.random() * 100)));
                      
} catch (InterruptedException e) {
                          
e.printStackTrace();
                      
}
                      
if(ATOMIC_REFERENCE.compareAndSet("abc" , "abc2")) {
                          
System.out.println("我是线程: " + num + ",我获得了锁进行了对象修改！");
                      
}
                  
}
              
}.start();
          
}
          
new Thread() {
              
public void run() {
                  
while(!ATOMIC_REFERENCE.compareAndSet("abc2", "abc"));
                  
System.out.println("已经改为原始值！");
              
}
          
}.start();
      
}
  
}
  

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

此时再运行程序看到的结果就是我们想要的了,发现将abc修改为abc2的线程仅有一个被访问,虽然被修改回了原始值,但是其他线程也不会再将abc改为abc2。

而类: AtomicMarkableReference和AtomicStampedReference功能差不多,有点区别的是: 它描述更加简单的是与否的关系,通常ABA问题只有两种状态,而AtomicStampedReference是多种状态,那么为什么还要有AtomicMarkableReference呢,因为它在处理是与否上面更加具有可读性,而AtomicStampedReference过于随意定义状态,并不便于阅读大量的是和否的关系,它可以被认为是一个计数器或状态列表等信息,java提倡通过类名知道其意义,所以这个类的存在也是必要的,它的定义就是将数据变换为true|false如下: 

public final static AtomicMarkableReference <String>ATOMIC_MARKABLE_REFERENCE = new AtomicMarkableReference<String>("abc" , false);

操作时使用: 
  
ATOMIC_MARKABLE_REFERENCE.compareAndSet("abc", "abc2", false, true);

好了,reference的三个类的种类都介绍了,我们下面要开始说Atomic的数组用法,因为我们开始说到的都是一些简单变量和基本数据,操作数组呢？如果你来设计会怎么设计,Atomic的数组要求不允许修改长度等,不像集合类那么丰富的操作,不过它可以让你的数组上每个元素的操作绝对安全的,也就是它细化的力度还是到数组上的元素,为你做了二次包装,所以如果你来设计,就是在原有的操作上增加一个下标访问即可,我们来模拟一个Integer类型的数组,即: AtomicIntegerArray

实例代码5 (AtomicIntegerArrayTest.java) 

```java
  
import java.util.concurrent.atomic.AtomicIntegerArray; 

public class AtomicIntegerArrayTest { 

/**
       
* 常见的方法列表
       
* @see AtomicIntegerArray#addAndGet(int, int) 执行加法,第一个参数为数组的下标,第二个参数为增加的数量,返回增加后的结果
       
* @see AtomicIntegerArray#compareAndSet(int, int, int) 对比修改,参数1: 数组下标,参数2: 原始值,参数3,修改目标值,修改成功返回true否则false
       
* @see AtomicIntegerArray#decrementAndGet(int) 参数为数组下标,将数组对应数字减少1,返回减少后的数据
       
* @see AtomicIntegerArray#incrementAndGet(int) 参数为数组下标,将数组对应数字增加1,返回增加后的数据
       
*
       
* @see AtomicIntegerArray#getAndAdd(int, int) 和addAndGet类似,区别是返回值是变化前的数据
       
* @see AtomicIntegerArray#getAndDecrement(int) 和decrementAndGet类似,区别是返回变化前的数据
       
* @see AtomicIntegerArray#getAndIncrement(int) 和incrementAndGet类似,区别是返回变化前的数据
       
* @see AtomicIntegerArray#getAndSet(int, int) 将对应下标的数字设置为指定值,第二个参数为设置的值,返回是变化前的数据
       
*/
      
private final static AtomicIntegerArray ATOMIC_INTEGER_ARRAY = new AtomicIntegerArray(new int[]{1,2,3,4,5,6,7,8,9,10}); 

public static void main(String []args) throws InterruptedException {
          
Thread []threads = new Thread[100];
          
for(int i = 0 ; i < 100 ; i++) {
              
final int index = i % 10;
              
final int threadNum = i;
              
threads[i] = new Thread() {
                  
public void run() {
                      
int result = ATOMIC_INTEGER_ARRAY.addAndGet(index, index + 1);
                      
System.out.println("线程编号为: " + threadNum + " , 对应的原始值为: " + (index + 1) + ",增加后的结果为: " + result);
                  
}
              
};
              
threads[i].start();
          
}
          
for(Thread thread : threads) {
              
thread.join();
          
}
          
System.out.println("=========================>\n执行已经完成,结果列表: ");
          
for(int i = 0 ; i < ATOMIC_INTEGER_ARRAY.length() ; i++) {
              
System.out.println(ATOMIC_INTEGER_ARRAY.get(i));
          
}
      
}
  
}
  

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;

public class AtomicIntegerFieldUpdaterTest {
    private static final Logger logger = LoggerFactory.getLogger(AtomicIntegerFieldUpdaterTest.class);

    static class A {
        volatile int intValue = 100;
    }

    public final static AtomicIntegerFieldUpdater<A> ATOMIC_INTEGER_UPDATER = AtomicIntegerFieldUpdater.newUpdater(A.class, "intValue");

    public static void main(String[] args) {
        final A a = new A();
        for (int i = 0; i < 100; i++) {
            final int num = i;
            new Thread() {
                public void run() {
                    if (ATOMIC_INTEGER_UPDATER.compareAndSet(a, 100, 120)) {
                        logger.info("我是线程: " + num + ", changed intValue");
                    } else {
                        logger.info("thread: {}, change intValue failed", num);
                    }
                }
            }.start();
        }
    }
}