Java多線程目錄
在java5以后滞详，我們接觸到了線程原子性操作，也就是在修改時(shí)我們只需要保證它的那個(gè)瞬間是安全的即可锐极，經(jīng)過(guò)相應(yīng)的包裝后可以再處理對(duì)象的并發(fā)修改盒齿，本文總結(jié)一下Atomic系列的類的使用方法沿猜，其中包含：

1. 基本類型的使用

public class AtomicTest {
    /**
     * 常見(jiàn)的方法列表
     *
     * @see AtomicInteger#get()             直接返回值
     * @see AtomicInteger#getAndAdd(int)    增加指定的數(shù)據(jù)，返回變化前的數(shù)據(jù)
     * @see AtomicInteger#getAndDecrement() 減少1矢劲，返回減少前的數(shù)據(jù)
     * @see AtomicInteger#getAndIncrement() 增加1赦拘，返回增加前的數(shù)據(jù)
     * @see AtomicInteger#getAndSet(int)    設(shè)置指定的數(shù)據(jù)，返回設(shè)置前的數(shù)據(jù)
     * @see AtomicInteger#addAndGet(int)    增加指定的數(shù)據(jù)后返回增加后的數(shù)據(jù)
     * @see AtomicInteger#decrementAndGet() 減少1芬沉，返回減少后的值
     * @see AtomicInteger#incrementAndGet() 增加1躺同，返回增加后的值
     * @see AtomicInteger#lazySet(int)      僅僅當(dāng)get時(shí)才會(huì)set
     * @see AtomicInteger#compareAndSet(int, int) 嘗試新增后對(duì)比，若增加成功則返回true否則返回false
     **/

    public static void main(String[] args) {

        final AtomicTicket ticket = new AtomicTicket();
        for (int i = 0; i < 3; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    while (ticket.getCount() > 0) {
                        System.out.println(Thread.currentThread().getName() + " count: " + ticket.decrement());
                    }
                }
            }).start();
        }
    }
}


class AtomicTicket {

    public AtomicInteger count = new AtomicInteger(100);

    public int decrement() {

        return count.getAndDecrement();
    }

    public int getCount() {
        return count.get();

    }
}

Thread-0 count: 100
Thread-2 count: 98
Thread-1 count: 99
Thread-2 count: 96
Thread-0 count: 97
Thread-2 count: 94
Thread-2 count: 92
Thread-1 count: 95
中間省略...
Thread-1 count: 12
Thread-2 count: 7
Thread-0 count: 9
Thread-2 count: 5
Thread-1 count: 6
Thread-2 count: 3
Thread-0 count: 4
Thread-2 count: 1
Thread-1 count: 2

2. 數(shù)組類型的使用

public class AtomicIntegerArrayTest {

    /**
     * 常見(jiàn)的方法列表
     * @see AtomicIntegerArray#addAndGet(int, int) 執(zhí)行加法丸逸，第一個(gè)參數(shù)為數(shù)組的下標(biāo)蹋艺，第二個(gè)參數(shù)為增加的數(shù)量，返回增加后的結(jié)果
     * @see AtomicIntegerArray#compareAndSet(int, int, int) 對(duì)比修改黄刚，參數(shù)1：數(shù)組下標(biāo)捎谨，參數(shù)2：原始值，參數(shù)3憔维，修改目標(biāo)值涛救，修改成功返回true否則false
     * @see AtomicIntegerArray#decrementAndGet(int) 參數(shù)為數(shù)組下標(biāo)，將數(shù)組對(duì)應(yīng)數(shù)字減少1业扒，返回減少后的數(shù)據(jù)
     * @see AtomicIntegerArray#incrementAndGet(int) 參數(shù)為數(shù)組下標(biāo)检吆，將數(shù)組對(duì)應(yīng)數(shù)字增加1，返回增加后的數(shù)據(jù)
     *
     * @see AtomicIntegerArray#getAndAdd(int, int) 和addAndGet類似凶赁，區(qū)別是返回值是變化前的數(shù)據(jù)
     * @see AtomicIntegerArray#getAndDecrement(int) 和decrementAndGet類似咧栗，區(qū)別是返回變化前的數(shù)據(jù)
     * @see AtomicIntegerArray#getAndIncrement(int) 和incrementAndGet類似，區(qū)別是返回變化前的數(shù)據(jù)
     * @see AtomicIntegerArray#getAndSet(int, int) 將對(duì)應(yīng)下標(biāo)的數(shù)字設(shè)置為指定值虱肄，第二個(gè)參數(shù)為設(shè)置的值致板，返回是變化前的數(shù)據(jù)
     */
    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[10];
        for(int i = 0 ; i < 10 ; i++) {
            final int index = i;
            threads[i] = new Thread() {
                public void run() {
                    int original =  ATOMIC_INTEGER_ARRAY.get(index);
                    int result = ATOMIC_INTEGER_ARRAY.addAndGet(index, index + 1);
                    System.out.println("currentThread：" + Thread.currentThread().getName() + " , 原始值為：" + original + "，增加后的結(jié)果為：" + result);
                }
            };
            threads[i].start();
        }
        for(Thread thread : threads) {
            thread.join();
        }
        System.out.println("=========================>\n執(zhí)行已經(jīng)完成咏窿，結(jié)果列表：");
        for(int i = 0 ; i < ATOMIC_INTEGER_ARRAY.length() ; i++) {
            System.out.println(ATOMIC_INTEGER_ARRAY.get(i));
        }
    }
}

currentThread：Thread-0 , 原始值為：1斟或，增加后的結(jié)果為：2
currentThread：Thread-3 , 原始值為：4，增加后的結(jié)果為：8
currentThread：Thread-2 , 原始值為：3集嵌，增加后的結(jié)果為：6
currentThread：Thread-1 , 原始值為：2萝挤，增加后的結(jié)果為：4
currentThread：Thread-5 , 原始值為：6御毅，增加后的結(jié)果為：12
currentThread：Thread-4 , 原始值為：5，增加后的結(jié)果為：10
currentThread：Thread-6 , 原始值為：7怜珍，增加后的結(jié)果為：14
currentThread：Thread-7 , 原始值為：8端蛆，增加后的結(jié)果為：16
currentThread：Thread-8 , 原始值為：9，增加后的結(jié)果為：18
currentThread：Thread-9 , 原始值為：10酥泛，增加后的結(jié)果為：20
=========================>
執(zhí)行已經(jīng)完成今豆，結(jié)果列表：
2
4
6
8
10
12
14
16
18
20

3. 引用類型的使用

public class AtomicReferenceTest {

    public static void main(String[] args) {
        People people1 =new People("Bom", 0);
        People people2 =new People("Tom",10);

        //先初始化一個(gè)值，如果不初始化則默認(rèn)值為null
        AtomicReference<People> reference = new AtomicReference<>(people1);
        People people3 = reference.get();
        if (people3.equals(people1)) {
            System.out.println("people3:" + people3);
        } else {
            System.out.println("else:" + people3);
        }

        /**
         * 當(dāng)前值：拿當(dāng)前值和reference.get()獲取到的值去比較柔袁，如果相等則true并更新值為期望值
         * 期望值：如果返回true則更新為期望值呆躲，如果返回false則不更新值
         */
        boolean b = reference.compareAndSet(null, people2);
        System.out.println("myClass.main-"+b+"--"+reference.get());

        boolean b1 = reference.compareAndSet(people1, people2);
        System.out.println("myClass.main-"+b1+"--"+reference.get());


        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());

                People people = reference.get();
                people.setName("Tom"+Thread.currentThread().getName());
                people.setAge(people.getAge()+1);
                reference.getAndSet(people);
                System.out.println(Thread.currentThread().getName()+reference.get().toString());
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());

                People people = reference.get();
                people.setName("Tom"+Thread.currentThread().getName());
                people.setAge(people.getAge()+4);
                reference.getAndSet(people);
                System.out.println(Thread.currentThread().getName()+reference.get().toString());
            }
        }).start();

    }

}

 class People {
    private String name;
    private int age;

    public People(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "People{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

4.字段類型的使用

public class AtomicIntegerFieldUpdaterTest {

    /**
     * 可以直接訪問(wèn)對(duì)應(yīng)的變量，進(jìn)行修改和處理
     * 條件：要在可訪問(wèn)的區(qū)域內(nèi)捶索，如果是private或挎包訪問(wèn)default類型以及非父親類的protected均無(wú)法訪問(wèn)到
     * 其次訪問(wèn)對(duì)象不能是static類型的變量（因?yàn)樵谟?jì)算屬性的偏移量的時(shí)候無(wú)法計(jì)算）插掂，也不能是final類型的變量（因?yàn)楦緹o(wú)法修改），必須是普通的成員變量
     * <p>
     * 方法（說(shuō)明上和AtomicInteger幾乎一致腥例，唯一的區(qū)別是第一個(gè)參數(shù)需要傳入對(duì)象的引用）
     *
     * @see AtomicIntegerFieldUpdater#addAndGet(Object, int)
     * @see AtomicIntegerFieldUpdater#compareAndSet(Object, int, int)
     * @see AtomicIntegerFieldUpdater#decrementAndGet(Object)
     * @see AtomicIntegerFieldUpdater#incrementAndGet(Object)
     * @see AtomicIntegerFieldUpdater#getAndAdd(Object, int)
     * @see AtomicIntegerFieldUpdater#getAndDecrement(Object)
     * @see AtomicIntegerFieldUpdater#getAndIncrement(Object)
     * @see AtomicIntegerFieldUpdater#getAndSet(Object, int)
     */
    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 < 10; i++) {

            new Thread() {
                public void run() {
                    System.out.println(
                            Thread.currentThread().getName() + " " + ATOMIC_INTEGER_UPDATER.get(a));
                    ATOMIC_INTEGER_UPDATER.addAndGet(a, 11);
                    System.out.println(
                            Thread.currentThread().getName() + " " + ATOMIC_INTEGER_UPDATER.get(a));
                    if (ATOMIC_INTEGER_UPDATER.compareAndSet(a, ATOMIC_INTEGER_UPDATER.get(a), 120)) {
                        System.out.println(Thread.currentThread().getName() + " 對(duì)應(yīng)的值做了修改辅甥！");
                    }
                    System.out.println(
                            Thread.currentThread().getName() + " " + ATOMIC_INTEGER_UPDATER.get(a));
                }
            }.start();
        }
    }

    static class A {
        volatile int intValue = 100;
    }
}

Thread-0 100
Thread-2 100
Thread-1 100
Thread-2 122
Thread-3 111
Thread-5 120
Thread-0 111
Thread-5 142
Thread-3 131
Thread-2 對(duì)應(yīng)的值做了修改！
Thread-2 120
Thread-8 120
Thread-4 133
Thread-1 133
Thread-9 142
Thread-4 142
Thread-4 對(duì)應(yīng)的值做了修改院崇！
Thread-8 131
Thread-3 對(duì)應(yīng)的值做了修改肆氓！
Thread-3 120
Thread-7 120
Thread-7 131
Thread-5 對(duì)應(yīng)的值做了修改！
Thread-5 120
Thread-6 120
Thread-0 對(duì)應(yīng)的值做了修改底瓣！
Thread-6 131
Thread-7 對(duì)應(yīng)的值做了修改谢揪！
Thread-8 對(duì)應(yīng)的值做了修改！
Thread-4 120
Thread-9 131
Thread-1 對(duì)應(yīng)的值做了修改捐凭！
Thread-9 對(duì)應(yīng)的值做了修改拨扶！
Thread-8 120
Thread-7 120
Thread-6 對(duì)應(yīng)的值做了修改！
Thread-0 131
Thread-6 120
Thread-9 120
Thread-1 120