• <nav id="wkkge"><strong id="wkkge"></strong></nav>
  • <menu id="wkkge"></menu>
  • 第一部分 Java基礎
    第二部分 Java進階

    Java多線程和并發面試題(附答案)第6題

     

     

    ● java.util.concurrent.atomic包

     

    ● AtomicBoolean原子性布爾

     

    AtomicBoolean是java.util.concurrent.atomic包下的原子變量,這個包里面提供了一組原子類。其基本的特性就是在多線程環境下,當有多個線程同時執行這些類的實例包含的方法時,具有排它性,即當某個線程進入方法,執行其中的指令時,不會被其他線程打斷,而別的線程就像自旋鎖一樣,一直等到該方法執行完成,才由JVM從等待隊列中選擇一個另一個線程進入,這只是一種邏輯上的理解。實際上是借助硬件的相關指令來實現的,不會阻塞線程(或者說只是在硬件級別上阻塞了)。

     

    AtomicBoolean,在這個Boolean值的變化的時候不允許在之間插入,保持操作的原子性。下面將解釋重點方法并舉例:

     

    boolean compareAndSet(expectedValue, updateValue);

     

    ● 這個方法主要有兩個作用:

     

    比較AtomicBoolean和expect的值,如果一致,執行方法內的語句。其實就是一個if語句。

     

    把AtomicBoolean的值設成update,比較最要的是這兩件事是一氣呵成的,這連個動作之間不會被打斷,任何內部或者外部的語句都不可能在兩個動作之間運行。為多線程的控制提供了解決的方案。

     

    ● 下面我們從代碼上解釋:

     

    首先我們看下在不使用 AtomicBoolean 情況下,代碼的運行情況:

     

    package com.bjpowernode;
    
    import java.util.concurrent.TimeUnit;
    
    public class BarWorker implements Runnable {
        //靜態變量
        private static boolean exists = false;
    
        private String name;
    
        public BarWorker(String name) {
            this.name = name;
        }
    
        @Override
        public void run() {
            if (!exists) {
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e1) {
                    // do nothing
                }
                exists = true;
                System.out.println(name + " enter");
                try {
                    System.out.println(name + " working");
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    // do nothing
                }
                System.out.println(name + " leave");
                exists = false;
            } else {
                System.out.println(name + " give up");
            }
    
        }
        
        public static void main(String[] args) {
            BarWorker bar1 = new BarWorker("bar1");
            BarWorker bar2 = new BarWorker("bar2");
            new Thread(bar1).start();
            new Thread(bar2).start();
        }
    }

     

    運行結果:

     

    bar1 enter

     

    bar2 enter

     

    bar1 working

     

    bar2 working

     

    bar1 leave

     

    bar2 leave

     

    從上面的運行結果我們可看到,兩個線程運行時,都對靜態變量exists同時做操作,并沒有保證exists靜態變量的原子性,也就是一個線程在對靜態變量exists進行操作到時候,其他線程必須等待或不作為。等待一個線程操作完后,才能對其進行操作。

     

    下面我們將靜態變量使用AtomicBoolean來進行操作。

     

    package com.bjpowernode;
    
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.atomic.AtomicBoolean;
    
    public class BarWorker2 implements Runnable {
        //靜態變量使用 AtomicBoolean 進行操作
        private static AtomicBoolean exists = new AtomicBoolean(false);
    
        private String name;
    
        public BarWorker2(String name) {
            this.name = name;
        }
    
        @Override
        public void run() {
            if (exists.compareAndSet(false, true)) {
    
                System.out.println(name + " enter");
    
                try {
                    System.out.println(name + " working");
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    // do nothing
                }
                System.out.println(name + " leave");
                exists.set(false);
            } else {
                System.out.println(name + " give up");
            }
        }
    
        public static void main(String[] args) {
            BarWorker2 bar1 = new BarWorker2("bar1");
            BarWorker2 bar2 = new BarWorker2("bar2");
            new Thread(bar1).start();
            new Thread(bar2).start();
        }
    }

     

    運行結果:

     

    bar1 enter

     

    bar1 working

     

    bar2 give up

     

    bar1 leave

     

    可以從上面的運行結果看出僅僅一個線程進行工作,因為exists.compareAndSet(false,true)提供了原子性操作,比較和賦值操作組成了一個原子操作,中間不會提供可乘之機。使得一個線程操作,其他線程等待或不作為。

     

    下面我們簡單介紹下AtomicBoolean的API

     

    ● 你可以這樣創建一個AtomicBoolean:

     

    AtomicBoolean atomicBoolean = new AtomicBoolean();  

     

    以上示例新建了一個默認值為false的AtomicBoolean。如果你想要為AtomicBoolean實例設置一個顯式的初始值,那么你可以將初始值傳給AtomicBoolean的構造子:

     

    AtomicBoolean atomicBoolean = new AtomicBoolean(true); 

     

    ● 獲得AtomicBoolean的值:

     

    你可以通過使用get()方法來獲取一個AtomicBoolean的值。示例如下:

     

    AtomicBoolean atomicBoolean = new AtomicBoolean(true);
    boolean value = atomicBoolean.get();

     

    ● 設置AtomicBoolean的值:

     

    你可以通過使用set()方法來設置一個AtomicBoolean的值。示例如下:

     

    AtomicBoolean atomicBoolean = new AtomicBoolean(true);
    atomicBoolean.set(false);

     

    以上代碼執行后AtomicBoolean的值為false。

     

    ● 交換AtomicBoolean的值:

     

    你可以通過 getAndSet()方法來交換一個AtomicBoolean實例的值。getAndSet()方法將返回AtomicBoolean當前的值,并將為AtomicBoolean設置一個新值。示例如下:

     

    AtomicBoolean atomicBoolean = new AtomicBoolean(true);
    boolean oldValue = atomicBoolean.getAndSet(false);

     

    以上代碼執行后oldValue變量的值為true,atomicBoolean實例將持有false值。代碼成功將AtomicBoolean當前值ture交換為false。

     

    ● 比較并設置 AtomicBoolean 的值:

     

    compareAndSet()方法允許你對AtomicBoolean的當前值與一個期望值進行比較,如果當前值等于期望值的話,將會對AtomicBoolean設定一個新值。compareAndSet()方法是原子性的,因此在同一時間之內有單個線程執行它。因此compareAndSet()方法可被用于一些類似于鎖的同步的簡單實現。以下是一個compareAndSet()示例:

     

    AtomicBoolean atomicBoolean = new AtomicBoolean(true);
    boolean expectedValue = true; boolean newValue = false;
    boolean wasNewValueSet = atomicBoolean.compareAndSet(expectedValue, newValue);

     

    本示例對AtomicBoolean的當前值與true值進行比較,如果相等,將AtomicBoolean的值更新為false。

     

    ● AtomicInteger原子性整型

     

    AtomicInteger,一個提供原子操作的Integer的類。在Java語言中,++i和i++操作并不是線程安全的,在使用的時候,不可避免的會用到synchronized關鍵字。而AtomicInteger則通過一種線程安全的加減操作接口。

     

    我們先來看看AtomicInteger給我們提供了什么方法:

     

    ublic final int get() //獲取當前的值
    public final int getAndSet(int newValue)//獲取當前的值,并設置新的值
    public final int getAndIncrement()//獲取當前的值,并自增
    public final int getAndDecrement() //獲取當前的值,并自減
    public final int getAndAdd(int delta) //獲取當前的值,并加上預期的值

     

    下面通過兩個簡單的例子來看一下AtomicInteger的優勢在哪?

     

    ● 普通線程同步:

     

    class Test2 {
        private volatile int count = 0;
        public synchronized void increment() {
            count++; //若要線程安全執行執行 count++,需要加鎖
        }
    
        public int getCount() {
            return count;
        }
    }

     

    ● 使用AtomicInteger:

     

    import java.util.concurrent.atomic.AtomicInteger;
    
    class Test2 {
        private AtomicInteger count = new AtomicInteger();
        public void increment() {
            count.incrementAndGet();
        }
        //使用 AtomicInteger 之后,不需要加鎖,也可以實現線程安全。
        public int getCount() {
            return count.get();
        }
    }

     

    從上面的例子中我們可以看出:使用AtomicInteger是非常安全的,而且因為AtomicInteger由硬件提供原子操作指令實現的,在非激烈競爭的情況下,開銷更小,速度更快。AtomicInteger是使用非阻塞算法來實現并發控制的。AtomicInteger的關鍵域只有以下3個:

     

    // setup to use Unsafe.compareAndSwapInt for updates
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;
    
    static {
        try {
            valueOffset = unsafe.objectFieldOffset(AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) {
            throw new Error(ex);
        }
    }
    
    private volatile int value;

     

    這里,unsafe是java提供的獲得對對象內存地址訪問的類,注釋已經清楚的寫出了,它的作用就是在更新操作時提供“比較并替換”的作用。實際上就是AtomicInteger中的一個工具。valueOffset是用來記錄value本身在內存的偏移地址的,這個記錄也主要是為了在更新操作在內存中找到value的位置,方便比較。

     

    注意:value是用來存儲整數的時間變量,這里被聲明為volatile,就是為了保證在更新操作時,當前線程可以拿到value最新的值(并發環境下,value可能已經被其他線程更新了)。

     

    優點:最大的好處就是可以避免多線程的優先級倒置和死鎖情況的發生,提升在高并發處理下的性能。

     

    ● 下面我們簡單介紹下 AtomicInteger 的 API

     

    ● 創建一個 AtomicInteger 示例如下:

     

    AtomicInteger atomicInteger = new AtomicInteger();

     

    本示例將創建一個初始值為0的AtomicInteger。如果你想要創建一個給

    定初始值的AtomicInteger,你可以這樣:

     

    AtomicInteger atomicInteger = new AtomicInteger(123);

     

    本示例將123作為參數傳給AtomicInteger的構造子,它將設置AtomicInteger實例的初始值為123。

     

    ● 獲得AtomicInteger的值

     

    你可以使用get()方法獲取AtomicInteger實例的值。示例如下:

     

    AtomicInteger atomicInteger = new AtomicInteger(123);
    int theValue = atomicInteger.get();

     

    ● 設置AtomicInteger的值

     

    你可以通過set()方法對AtomicInteger的值進行重新設置。以下是AtomicInteger.set()示例:

     

    AtomicInteger atomicInteger = new AtomicInteger(123);
    atomicInteger.set(234);

     

    以上示例創建了一個初始值為123的AtomicInteger,而在第二行將其值更新為234。

     

    ● 比較并設置AtomicInteger的值

     

    AtomicInteger類也通過了一個原子性的compareAndSet()方法。這一方法將AtomicInteger實例的當前值與期望值進行比較,如果二者相等,為AtomicInteger實例設置一個新值。 AtomicInteger.compareAndSet()代碼示例:

     

    AtomicInteger atomicInteger = new AtomicInteger(123);
    int expectedValue = 123;
    int newValue = 234;
    atomicInteger.compareAndSet(expectedValue,newValue);

     

    本示例首先新建一個初始值為123的AtomicInteger實例。然后將AtomicInteger與期望值123進行比較,如果相等,將AtomicInteger的值更新為234。

     

    ● 增加AtomicInteger的值

     

    AtomicInteger類包含有一些方法,通過它們你可以增加AtomicInteger的值,并獲取其值。這些方法如下:

     

    public final int addAndGet(int addValue)//在原來的數值上增加新的值,并返回新值
    public final int getAndIncrement()//獲取當前的值,并自增
    public final int incrementAndget() //自減,并獲得自減后的值
    public final int getAndAdd(int delta) //獲取當前的值,并加上預期的值

     

    第一個addAndGet()方法給AtomicInteger增加了一個值,然后返回增加后的值。getAndAdd()方法為AtomicInteger增加了一個值,但返回的是增加以前的AtomicInteger的值。具體使用哪一個取決于你的應用場景。以下是這兩種方法的示例:

     

    AtomicInteger atomicInteger = new AtomicInteger();
    System.out.println(atomicInteger.getAndAdd(10));
    System.out.println(atomicInteger.addAndGet(10));

     

    本示例將打印出0和20。例子中,第二行拿到的是加10之前的AtomicInteger的值。加10之前的值是0。第三行將AtomicInteger的值再加10,并返回加操作之后的值。該值現在是為20。你當然也可以使用這倆方法為AtomicInteger添加負值。結果實際是一個減法操作。getAndIncrement()和incrementAndGet()方法類似于getAndAdd()和addAndGet(),但每次只將AtomicInteger的值加1。

     

    ● 減小AtomicInteger的值

     

    AtomicInteger類還提供了一些減小AtomicInteger的值的原子性方法。這些方法是:

     

    public final int decrementAndGet()
    public final int getAndDecrement()

     

    decrementAndGet()將AtomicInteger的值減一,并返回減一后的值。getAndDecrement()也將AtomicInteger的值減一,但它返回的是減一之前的值。

     

    ● AtomicIntegerArray原子性整型數組

     

    java.util.concurrent.atomic.AtomicIntegerArray類提供了可以以原子方式讀取和寫入的底層int數組的操作,還包含高級原子操作。AtomicIntegerArray支持對底層int數組變量的原子操作。它具有獲取和設置方法,如在變量上的讀取和寫入。也就是說,一個集合與同一變量上的任何后續get相關聯。原子compareAndSet方法也具有這些內存一致性功能。

     

    AtomicIntegerArray本質上是對int[]類型的封裝。使用Unsafe類通過CAS的方式控制int[]在多線程下的安全性。它提供了以下幾個核心API:

     

    //獲得數組第 i 個下標的元素
    public final int get(int i)
    //獲得數組的長度
    public final int length()
    //將數組第 i 個下標設置為 newValue,并返回舊的值
    public final int getAndSet(int i, int newValue)
    //進行 CAS 操作,如果第 i 個下標的元素等于 expect,則設置為 update,設置成功返回 true 
    public final boolean compareAndSet(int i, int expect, int update)
    //將第 i 個下標的元素加 1
    public final int getAndIncrement(int i)
    //將第 i 個下標的元素減 1
    public final int getAndDecrement(int i)
    //將第 i 個下標的元素增加 delta(delta 可以是負數)
    public final int getAndAdd(int i,int delta)
    

     

    下面給出一個簡單的示例,展示 AtomicIntegerArray 使用:

     

    public class AtomicIntegerArrayDemo {
        static AtomicIntegerArray arr = new AtomicIntegerArray(10);
        public static class AddThread implements Runnable {
            public void run() {
                for (int k = 0; k < 10000; k++) 
    	     arr.getAndIncrement(k % arr.length());
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
            Thread[] ts = new Thread[10];
            for (int k = 0; k < 10; k++) {
                ts[k] = new Thread(new AddThread());
            }
            for (int k = 0; k < 10; k++) {
                ts[k].start();
            }
            for (int k = 0; k < 10; k++) {
                ts[k].join();
            }
            System.out.println(arr);
        }
    }

     

    輸出結果:

     

    [10000,10000,10000,10000,10000,10000,10000,10000,10000,10000]

     

    上述代碼第2行,申明了一個內含10個元素的數組。第3行定義的線程對數組內10個元素進行累加操作,每個元素各加1000次。第11行,開啟10個這樣的線程。因此,可以預測,如果線程安全,數組內10個元素的值必然都是10000。反之,如果線程不安全,則部分或者全部數值會小于10000。

     

    ● AtomicLong、AtomicLongArray原子性整型數組

     

    AtomicLong、AtomicLongArray的API跟AtomicInteger、AtomicIntegerArray在使用方法都是差不多的。區別在于用前者是使用原子方式更新的long值和long數組,后者是使用原子方式更新的Integer值和Integer數組。兩者的相同處在于它們此類確實擴展了Number,允許那些處理基于數字類的工具和實用工具進行統一訪問。在實際開發中,它們分別用于不同的場景。這個就具體情況具體分析了,下面將舉例說明AtomicLong的使用場景(使用AtomicLong生成自增長ID)。

     

    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.HashSet;
    import java.util.List;
    import java.util.Set;
    import java.util.concurrent.atomic.AtomicLong;
    
    public class AtomicLongTest {
    
        /**
         * @param args
         */
        public static void main(String[] args) {
            final AtomicLong orderIdGenerator = new AtomicLong(0);
            final List<Item> orders = Collections
                    .synchronizedList(new ArrayList<Item>());
            for (int i = 0; i < 10; i++) {
                Thread orderCreationThread = new Thread(new Runnable() {
                    public void run() {
                        for (int i = 0; i < 10; i++) {
                            long orderId = orderIdGenerator.incrementAndGet();
                            Item order = new Item(Thread.currentThread().getName(), orderId);
                            orders.add(order);
                        }
                    }
                });
                orderCreationThread.setName("Order Creation Thread " + i);
                orderCreationThread.start();
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Set<Long> orderIds = new HashSet<Long>();
            for (Item order : orders) {
                orderIds.add(order.getID());
                System.out.println("Order name:" + order.getItemName()
                        + "----" + "Order id:" + order.getID());
            }
        }
    }
    
    class Item {
        String itemName;
        long id;
    
        Item(String n, long id) {
            this.itemName = n;
            this.id = id;
        }
    
        public String getItemName() {
            return itemName;
        }
    
        public long getID() {
            return id;
        }
    }

     

    輸出:

     

    Order name:Order Creation Thread 0----Order id:1

     

    Order name:Order Creation Thread 1----Order id:2

     

    Order name:Order Creation Thread 0----Order id:4

     

    Order name:Order Creation Thread 1----Order id:5

     

    Order name:Order Creation Thread 3----Order id:3

     

    Order name:Order Creation Thread 0----Order id:7

     

    Order name:Order Creation Thread 1----Order id:6

     

    ........

     

    Order name:Order Creation Thread 2----Order id:100

     

    從運行結果我們看到,不管是哪個線程。它們獲得的ID是不會重復的,保證的ID生成的原子性,避免了線程安全上的問題。

     

    全部教程
  • <nav id="wkkge"><strong id="wkkge"></strong></nav>
  • <menu id="wkkge"></menu>
  • 面对面棋牌游戏