java并發(fā)中的Synchronized關(guān)鍵詞

如果在多線程的環(huán)境中，我們經(jīng)常會遇到資源競爭的情況拷况，比如多個線程要去同時修改同一個共享變量赚瘦，這時候，就需要對資源的訪問方法進(jìn)行一定的處理鹰服，保證同一時間只有一個線程訪問揽咕。

java提供了synchronized關(guān)鍵字，方便我們實現(xiàn)上述操作舔涎。

為什么要同步

我們舉個例子，我們創(chuàng)建一個類嚎于，提供了一個setSum的方法：


public class SynchronizedMethods {

    private int sum = 0;

    public void calculate() {
        setSum(getSum() + 1);
    }
}

如果我們在多線程的環(huán)境中調(diào)用這個calculate方法：

    @Test
    public void givenMultiThread_whenNonSyncMethod() throws InterruptedException {
        ExecutorService service = Executors.newFixedThreadPool(3);
        SynchronizedMethods summation = new SynchronizedMethods();

        IntStream.range(0, 1000)
                .forEach(count -> service.submit(summation::calculate));
        service.shutdown();
        service.awaitTermination(1000, TimeUnit.MILLISECONDS);

        assertEquals(1000, summation.getSum());
    }

按照上面的方法，我們預(yù)計要返回1000挟冠，但是實際上基本不可能得到1000這個值于购，因為在多線程環(huán)境中，對同一個資源進(jìn)行同時操作帶來的不利影響知染。

那我們怎么才能夠建線程安全的環(huán)境呢肋僧？

Synchronized關(guān)鍵詞

java提供了多種線程安全的方法，本文主要講解Synchronized關(guān)鍵詞控淡，Synchronized關(guān)鍵詞可以有很多種形式：

Instance methods
Static methods
Code blocks

當(dāng)我們使用synchronized時嫌吠，java會在相應(yīng)的對象上加鎖，從而在同一個對象等待鎖的方法都必須順序執(zhí)行掺炭，從而保證了線程的安全辫诅。

Synchronized Instance Methods

Synchronized關(guān)鍵詞可以放在實例方法的前面：

    public synchronized void synchronisedCalculate() {
        setSum(getSum() + 1);
    }

看下調(diào)用結(jié)果：

@Test
public void givenMultiThread_whenMethodSync() {
    ExecutorService service = Executors.newFixedThreadPool(3);
    SynchronizedMethods method = new SynchronizedMethods();

    IntStream.range(0, 1000)
      .forEach(count -> service.submit(method::synchronisedCalculate));
    service.awaitTermination(1000, TimeUnit.MILLISECONDS);

    assertEquals(1000, method.getSum());
}

這里synchronized將會鎖住該方法的實例對象涧狮，多個線程中只有獲得該實例對象鎖的線程才能夠執(zhí)行炕矮。

Synchronized Static Methods

Synchronized關(guān)鍵詞也可以用在static方法前面：

    public static synchronized void syncStaticCalculate() {
        staticSum = staticSum + 1;
    }

Synchronized放在static方法前面和實例方法前面鎖住的對象不同。放在static方法前面鎖住的對象是這個Class本身者冤，因為一個Class在JVM中只會存在一個肤视，所以不管有多少該Class的實例，在同一時刻只會有一個線程可以執(zhí)行該放方法涉枫。

    @Test
    public void givenMultiThread_whenStaticSyncMethod() throws InterruptedException {
        ExecutorService service = Executors.newCachedThreadPool();

        IntStream.range(0, 1000)
                .forEach(count ->
                        service.submit(SynchronizedMethods::syncStaticCalculate));
        service.shutdown();
        service.awaitTermination(100, TimeUnit.MILLISECONDS);

        assertEquals(1000, SynchronizedMethods.staticSum);
    }

Synchronized Blocks

有時候钢颂，我們可能不需要Synchronize整個方法，而是同步其中的一部分拜银，這時候殊鞭，我們可以使用Synchronized Blocks：

    public void performSynchronizedTask() {
        synchronized (this) {
            setSum(getSum() + 1);
        }
    }

我們看下怎么測試：

    @Test
    public void givenMultiThread_whenBlockSync() throws InterruptedException {
        ExecutorService service = Executors.newFixedThreadPool(3);
        SynchronizedMethods synchronizedBlocks = new SynchronizedMethods();

        IntStream.range(0, 1000)
                .forEach(count ->
                        service.submit(synchronizedBlocks::performSynchronizedTask));
        service.shutdown();
        service.awaitTermination(100, TimeUnit.MILLISECONDS);

        assertEquals(1000, synchronizedBlocks.getSum());
    }

上面我們同步的是實例，如果在靜態(tài)方法中尼桶，我們也可以同步class：

    public static void performStaticSyncTask(){
        synchronized (SynchronizedMethods.class) {
            staticSum = staticSum + 1;
        }
    }