前兩篇文章我介紹了AtomicInteger和AtomicIntegerArray,現在總結一下兩個類的特點。

1：AtomicInteger是對單個變量進行原子操作的。
2：AtomicIntegerArray是對數組中的元素進行原子操作的，而不是數組本身。

本篇文章介紹第三類原子操作:AtomicIntegerFieldUpdater.

1：關于private/protected/public訪問控制符
2：AtomicIntegerFieldUpdater的一些限制
3：AtomicIntegerFieldUpdater實例
4：AtomicIntegerFieldUpdater源碼解析

一、關于private/protected/public訪問控制符

由于下面要用到Java這個知識點，所以我們在復習一下關于Java的訪問控制符，在Java中主要定義三個訪問控制符，還有一個默認的(沒有被任何訪問控制符修飾default)，一共四個訪問控制符

1：private：私有的，只能自己能訪問，其他都訪問不到
2：默認的(default，如果沒有被任何訪問控制符修飾)：同一類或者同一個包中能夠訪問到，其他訪問不到。
3：protected：同一個類、子類、同一個包能放到，其他訪問不到。
4：public：所有類都能訪問到。

他們的訪問范圍如圖：

通過一個表格更加清晰的看一下：

這個知識點大家都非常熟悉了，理解了訪問控制符，AtomicIntegerFieldUpdater的一些知識點就好理解了。

二、AtomicIntegerFieldUpdater的一些限制

接下來的文章內容如果沒有特殊說明，AtomicIntegerFieldUpdater更新的字段簡稱為被操作的字段。

1：被操作的字段必須被volatile修飾
2：被操作的字段必須是int類型，不能是包裝類型，如Integer
3：被操作的字段只能是實例變量，不能是類變量，就是不能被static修飾
4：被操作的字段只能是可變變量，不能被final修飾，其實final和volatile不能同時存在，否則編譯不通過。
5：如果調用方無法直接訪問到被操作字段，則會拋出異常

關于第5點就是用到了上面所說的訪問控制權限：

1：如果調用方和被操作字段所在的類是同一類，那么被操作字段可以被private/defalut/protected/public修飾。
2：如果調用方和被操作字段所在的類是同一個包，那么被操作字段可以被defalut/protected/public修飾
3：如果調用方和被操作字段所在的類屬于子類，那么被操作字段可以被protected/public修飾
4：如果調用方和被操作字段所在的類不在同一個包，也不屬于子類關系，那么只能被public修飾。

三、AtomicIntegerFieldUpdater實例

上面提出了它的限制后，下面我們通過實例去一個一個的證明：

1：首先證明AtomicIntegerFieldUpdater可以原子更新一個對象中被volatile修飾的int類型的字段

下面的實例調用對象AtomicIntegerFieldUpdater和被操作字段所在的類在同一個包中

調用對象：AtomicIntegerFieldUpdater

package com.stqsht.juc.atomic;
public class AtomicIntegerFieldUpdaterTest {
//定義一個線程池
 private static ThreadPoolExecutor pool;
 static {
 pool=new ThreadPoolExecutor(5, 10, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<>(1000));
 }
 public static void main(String[] args) throws InterruptedException {
 Obj obj=new Obj(0, 0);
 AtomicIntegerFieldUpdater<Obj> afu=AtomicIntegerFieldUpdater.newUpdater(Obj.class, "age");
 for (int i=0; i < 5; i++) {
 pool.execute(() -> {
 for (int j=0; j < 10000; j++) {
 obj.setId(obj.getId() + 1);
 afu.incrementAndGet(obj);
 }
 });
 }
 pool.awaitTermination(5, TimeUnit.SECONDS);
 System.out.println("id=" + obj.getId());
 System.out.println("age=" + obj.getAge());
 pool.shutdown();
 }
}

被操作字段所在的類Obj中有兩個字段，一個字段沒有被volatile修飾，一個字段被volatile修飾

package com.stqsht.juc.atomic;
class Obj {
 private int id;
 volatile int age;
 public Obj(int id, int age) {
 this.id=id;
 this.age=age;
 }
//省略getter和setter方法
}

通過運行多次后，得出一個結論，每一次id的結果都不相同，而age得到的結果相同且是正確的，運行結果如下：

從上述案例可以證明，AtomicIntegerFieldUpdater可以原子的更新一個對象中的字段。

2：如果被操作的字段沒有關鍵字volatile，則會拋出異常：Must be volatile type

class Obj {
 private int id;
 int age;
 public Obj(int id, int age) {
 this.id=id;
 this.age=age;
 }
//setter和getter省略
}

上面的被修飾的字段age并沒有關鍵字volatile，運行代碼結果如下：

從運行結果可以看出，如果被操作的字段沒有被volatile修飾，那么它直接拋出異常，因為多線程下volatile具有可見性和有序性。

3：被操作的字段只能是int類型，不能是包裝類型Integer

class Obj {
 private int id;
 volatile Integer age;
 public Obj(int id, int age) {
 this.id=id;
 this.age=age;
 }
//setter和getter省略
}

上面的被操作字段是一個包裝類Integer，運行結果如下圖：

4：被操作的字段只能是實例變量，不能是類變量，也就是被操作字段不能被static修飾

class Obj {
 private int id;
 static volatile int age;
 public Obj(int id, int age) {
 this.id=id;
 this.age=age;
 }
//setter和getter省略
}

運行結果如下圖：

5：被操作的字段只能是可變變量，不能被final修飾，其實final和volatile不能同時存在，否則編譯不通過。

6：如果調用方無法直接訪問到被操作字段，則會拋出異常

6.1：如果調用方和被操作字段所在的類是同一個類，被操作字段可以被private/defalut/protected/public修飾

public class User {
 public static void main(String[] args) {
 AtomicIntegerFieldUpdater<User>ai=AtomicIntegerFieldUpdater.newUpdater(User.class,"age");
 User user=new User(0);
 ai.incrementAndGet(user);
 System.out.println(user.getAge());
 }
//可以被private/defalut/protected/public修飾
 private volatile int age;
 public User(int age) {
 this.age=age;
 }
//省略setter和gettter方法
}

大家可以親自測試以下上面的demo，無論成員變量age被什么訪問控制符修飾，都是可以的。

6.2：如果調用方和被操作字段所在的類在同一個包中，被操作字段可以被defalut/protected/public修飾，用private則會拋出異常

調用方：Caller

package com.stqsht.juc.other;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
//調用方
public class Caller {
 public static void main(String[] args) {
 User user=new User(0);
 AtomicIntegerFieldUpdater<User> ai=AtomicIntegerFieldUpdater.newUpdater(User.class,"age");
 ai.incrementAndGet(user);
 System.out.println(user.getAge());
 }
}

被操作字段所在的類:User

package com.stqsht.juc.other;
//調用方
public class User {
//可以被default/protected/public修飾
 volatile int age;
 public User(int age) {
 this.age=age;
 }
 //省略setter和getter方法
}

如果上面的例子如果被private修飾，則會拋出如圖的異常：

6.3：如果調用方和被操作字段所在的類屬于子類關系，被操作字段可以被protected/public修飾

調用方：com.stqsht.juc.other.Caller

package com.stqsht.juc.other;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
import com.stqsht.juc.common.User;
//調用方
public class Caller extends User {
 public static void main(String[] args) {
 Caller user=new Caller(0);
 AtomicIntegerFieldUpdater<User> ai=AtomicIntegerFieldUpdater.newUpdater(User.class,"age");
 ai.incrementAndGet(user);
 System.out.println(user.getAge());
 }
 public Caller(int age) {
 super(age);
 }
}

被操作字段所在的類:com.stqsht.juc.common.User

package com.stqsht.juc.common;
//被操作字段所在的類，可以被protect/public修飾
public class User {
 volatile int age;
 public User(int age) {
 this.age=age;
 }
 public int getAge() {
 return age;
 }
 public void setAge(int age) {
 this.age=age;
 }
}

如果上面的例子被private/defalut修飾，則會拋出以下異常。

6.4：如果調用方和被操作字段所在的類不在同一個包，也不屬于子類關系，那么只能被public修飾。

調用方：com.stqsht.juc.other.Caller

package com.stqsht.juc.other;
import com.stqsht.juc.common.User;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
//調用方
public class Caller {
 public static void main(String[] args) {
 User user=new User(0);
 AtomicIntegerFieldUpdater<User> ai=AtomicIntegerFieldUpdater.newUpdater(User.class, "age");
 ai.incrementAndGet(user);
 System.out.println(user.getAge());
 }
}

被操作字段所在的類:com.stqsht.juc.common.User

package com.stqsht.juc.common;
public class User {
 protected volatile int age;
 public User(int age) {
 this.age=age;
 }
 public int getAge() {
 return age;
 }
 public void setAge(int age) {
 this.age=age;
 }
}

如果上面的代碼被private/defalut/protected修飾，則會拋出如下異常

上面列出了AtomicIntegerFieldUpdater的一些限制，我們知道了怎么使用AtomicIntegerFieldUpdaterle ，那從源碼角度，它是怎么有這些限制呢，我們進入它的源碼一探究竟。

四、AtomicIntegerFieldUpdater源碼解析

當我們跟進源碼中看到它是一個抽象類,它只有一個方法能夠獲取一個實例對象。

public abstract class AtomicIntegerFieldUpdater<T> {
 
 @CallerSensitive
 public static <U> AtomicIntegerFieldUpdater<U> newUpdater(Class<U> tclass,
 String fieldName) {
 return new AtomicIntegerFieldUpdaterImpl<U>
 (tclass, fieldName, Reflection.getCallerClass());
 }
//省略其他代碼
}
參數1：tclass：實例的Class對象，例如上面例子User.class
參數2：fieldName:被操作的字段的名稱，例如上面例子成員變量age

通過一個newUpdater()方法獲取一個實例對象，從這個方法中可以看出他的實現類是AtomicIntegerFieldUpdaterImpl，這個實現類在它的內部，我們一起跟進它的實現類。

private static final class AtomicIntegerFieldUpdaterImpl<T>
extends AtomicIntegerFieldUpdater<T> {
//原子操作封裝對象
private static final sun.misc.Unsafe U=sun.misc.Unsafe.getUnsafe();
private final long offset;
//調用方的Class對象，如上面例子Caller.class
private final Class<?> cclass;
//被操作字段所在的類的Class對象，如上面例子User.class
private final Class<T> tclass;

上面是子類的幾個重要的成員變量，下面我們看一下它的核心構造函數

//參數一：tclass:被操作字段所在類的Class對象
//參數二：被操作字段的名稱
//參數三：調用方的Class對象
AtomicIntegerFieldUpdaterImpl(final Class<T> tclass,
 final String fieldName,
 final Class<?> caller) {
 final Field field;
 final int modifiers;
 try {
//通過反射獲取被操作字段
 field=AccessController.doPrivileged(
 new PrivilegedExceptionAction<Field>() {
 public Field run() throws NoSuchFieldException {
 return tclass.getDeclaredField(fieldName);
 }
 });
//獲取被操作字段修飾符
 modifiers=field.getModifiers();
//判斷訪問控制符的權限
 sun.reflect.misc.ReflectUtil.ensureMemberAccess(
 caller, tclass, null, modifiers);
 ClassLoader cl=tclass.getClassLoader();
 ClassLoader ccl=caller.getClassLoader();
 if ((ccl !=null) && (ccl !=cl) &&
 ((cl==null) || !isAncestor(cl, ccl))) {
 sun.reflect.misc.ReflectUtil.checkPackageAccess(tclass);
 }
 } catch (PrivilegedActionException pae) {
 throw new RuntimeException(pae.getException());
 } catch (Exception ex) {
//$5：如果調用方不能直接訪問被操作字段，則拋出異常
 throw new RuntimeException(ex);
 }
 if (field.getType() !=int.class)
//$2:如果不是int類型，則會拋出異常
 throw new IllegalArgumentException("Must be integer type");
 if (!Modifier.isVolatile(modifiers))
//$1:如果沒有被volatile修飾，則拋出異常
 throw new IllegalArgumentException("Must be volatile type");
 
 this.cclass=(Modifier.isProtected(modifiers) &&
 tclass.isAssignableFrom(caller) &&
 !isSamePackage(tclass, caller))
 ? caller : tclass;
 this.tclass=tclass;
//$3:objectFieldOffset()方法的作用：獲取某個字段相對Java對象的起始地址的偏移地址
 this.offset=U.objectFieldOffset(field);
}

這個構造函數涵蓋了AtomicIntegerFieldUpdater的所有限制，所以從源碼角度也證明了上面總結的限制。這個構造函數的流程圖如下：

AtomicIntegerFieldUpdater的核心方法和AtomicInteger類似，功能也是一樣的：原子更新一個被volatile修飾的變量，這里就不在介紹了，如果不太明白這些方法的用法，請進入我的主頁查看

接下來介紹幾個特殊的方法：判斷調用方和被操作字段所在的類是否在同一個包，是否是子類關系。

第一個方法：isAncestor：判斷是否屬于子類關系

private static boolean isAncestor(ClassLoader first, ClassLoader second) {
 ClassLoader acl=first;
 do {
 acl=acl.getParent();
 if (second==acl) {
//屬于子類，返回true
 return true;
 }
 } while (acl !=null);
 return false;
}

第二個方法：isSamePackage：判斷是否在同一個包