android開發(fā)之synchronized的用法

  1. 簡介
    synchronized是Java中的的關(guān)鍵字，是一種同步鎖，可以修飾以下幾種
    1.1>：類
    作用的范圍是：synchronized后邊括號括起來的部分
    作用的對象是：這個類當(dāng)中所有的對象
    1.2>：靜態(tài)方法
    作用的范圍是：整個靜態(tài)方法
    作用的對象是：這個類當(dāng)中的所有對象
    1.3>：代碼塊：被修飾的代碼塊稱為同步代碼塊
    作用的范圍是：大括號括起來的部分
    作用的對象是：調(diào)用這個代碼塊的對象
    1.4>：方法：被修飾的方法稱為同步方法
    作用的范圍是：整個方法
    作用的對象是：調(diào)用這個方法的對象
  2. 實例分析
    2.1>： synchronized修飾的代碼塊
public class MainActivity extends AppCompatActivity {

    private static final String TAG = "MainActivity" ;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        SyncThread syncThread = new SyncThread() ;
        Thread thread1 = new Thread(syncThread , "SyncThread1") ;
        Thread thread2 = new Thread(syncThread , "SyncThread2") ;
        thread1.start();
        thread2.start();
    }

    class SyncThread implements Runnable{
        private int count ;
        public SyncThread(){
            count = 0 ;
        }

        @Override
        public void run() {
            synchronized (this){
                for (int i = 0; i < 5; i++) {
                    try {
                        Log.d("mainActivity-->", Thread.currentThread().getName() + ":" + (count++)) ;
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
        public int getCount(){
            return count ;
        }
    }
}

上邊運(yùn)行結(jié)果是

//SyncThread2:0
//SyncThread2:1
//SyncThread2:2
//SyncThread2:3
//SyncThread2:4
//SyncThread1:5
//SyncThread1:6
//SyncThread1:7
//SyncThread1:8
//SyncThread1:9

由以上可知：
當(dāng)兩個線程thread1和thread2訪問 "同一個syncThread對象" 中的synchronized代碼塊，同一時刻只能一個執(zhí)行線程，另一個受阻，必須等當(dāng)前線程執(zhí)行完這個代碼塊后才能執(zhí)行，thread1在執(zhí)行synchronized代碼塊時會鎖定當(dāng)前對象，只有執(zhí)行完該代碼塊后才能釋放對象鎖，下一個線程才能執(zhí)行并鎖定該對象

我們現(xiàn)在把

Thread thread1 = new Thread(syncThread , "SyncThread1") ;
Thread thread2 = new Thread(syncThread , "SyncThread2") ;

這兩句修改為

Thread thread1 = new Thread(new SyncThread() , "SyncThread1") ;
Thread thread2 = new Thread(new SyncThread() , "SyncThread2") ;

運(yùn)行結(jié)果是

//SyncThread1:0
//SyncThread2:0
//SyncThread1:1
//SyncThread2:1
//SyncThread1:2
//SyncThread2:2
//SyncThread1:3
//SyncThread2:3
//SyncThread1:4
//SyncThread2:4

現(xiàn)象：
thread1和thread2同時在執(zhí)行
原因：
synchronized修飾代碼塊時，只鎖定代碼塊中的對象，一個對象只有一個鎖 [ lock ] 與之關(guān)聯(lián)，而上邊代碼等同于

SyncThread syncThread1 = new SyncThread();
SyncThread syncThread2 = new SyncThread();
Thread thread1 = new Thread(syncThread1, "SyncThread1");
Thread thread2 = new Thread(syncThread2, "SyncThread2");
thread1.start();
thread2.start();

這個時候創(chuàng)建了2個對象，分別為 syncThread1何syncThread2，線程thread1執(zhí)行syncThread1對象中對應(yīng)synchronized的代碼，線程thread2執(zhí)行syncThread2中對應(yīng)的synchronized對象，我們都知道synchronized鎖定的是對象，這個時候會有兩把鎖分別鎖定syncThread1對象和syncThread2對象，而這兩把鎖互補(bǔ)干擾，所以兩個線程可以同時執(zhí)行

代碼：https://github.com/shuai999/ThreadDemo

2.2：當(dāng)一個線程訪問一個對象的synchronized(this)代碼塊時，其他線程也可以訪問該對象的非synchronized(this)代碼塊，并且不受阻塞
多個線程訪問同一個對象的synchronized(this)代碼塊和非synchronized(this)代碼塊，示例如下：

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        Counter counter = new Counter() ;
        //參數(shù)一：Runnable的實現(xiàn)類 參數(shù)二：線程名
        Thread thread1 = new Thread(counter , "A") ;
        Thread thread2 = new Thread(counter , "B") ;
        thread1.start();
        thread2.start();
        
    }

    class Counter implements Runnable{

        private int count ;
        public Counter(){
            count = 0 ;
        }

        public void countAdd(){
            //synchronized代碼塊
            synchronized (this){
                for (int i = 0; i < 5; i++) {
                    try {
                        Log.d("threadName--->" , Thread.currentThread().getName() +":" + (count++)) ;
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }


        //非synchronized代碼塊，未對count進(jìn)行讀寫操作，所以可以不用synchronized
        public void printAdd(){
            for (int i = 0; i < 5; i++) {
                try {
                    Log.d("threadName--->" , Thread.currentThread().getName() + "count:" + count) ;
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }


        @Override
        public void run() {
            String threadName = Thread.currentThread().getName() ;
            if (threadName.equals("A")){
                countAdd();
            }else if (threadName.equals("B")){
                printAdd();
            }
        }
    }

//    Bcount:0
//    A:0
//    Bcount:1
//    A:1
//    Bcount:2
//    A:2
//    Bcount:3
//    A:3
//    Bcount:4
//    A:4
    /* 以上是運(yùn)行結(jié)果 */
    /* 由結(jié)果可知，countAdd()方法是synchronized代碼塊，printAdd()不是synchronized代碼塊。
       當(dāng)一個線程訪問一個對象的synchronized代碼塊時，其他的線程可以訪問該對象的非synchronized代碼塊而不受阻塞*/
}

具體代碼已上傳至github：
https://github.com/shuai999/ThreadDemo3

2.3：指定給某個對象加鎖
代碼如下：

/**
 * @author : Created by ces
 * @date: on 2018/1/28.
 * @function: 指定給某個對象加鎖
 */
public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Account account = new Account("zhangsan" , 10000.0f) ;
        AccountOperator operator = new AccountOperator(account) ;

        final int THREAD_NUM = 5 ;
        Thread threads[] = new Thread[THREAD_NUM] ;
        for (int i = 0; i < THREAD_NUM; i++) {
            threads[i] = new Thread(operator , "Thread" + i);
            threads[i].start();
        }
    }

    public class AccountOperator implements Runnable{

        private Account account ;
        public AccountOperator(Account account){
            this.account = account ;
        }

        @Override
        public void run() {
            synchronized (account){
                //存錢500
                account.deposit(500);
                //取錢500
                account.withDraw(500);
                Log.e("cesAccount--->", Thread.currentThread().getName() + ":" + account.getBalance()) ;
                //運(yùn)行結(jié)果如下
//                Thread0:10000.0
//                Thread1:10000.0
//                Thread2:10000.0
//                Thread3:10000.0
//                Thread4:10000.0
            }
        }
    }
}

/**
 * @author : Created by ces
 * @date: on 2018/1/28.
 * @function: 指定給某個對象加鎖
 */
public class Account {
    String name ;
    float amount ;

    public Account(String name , float amount){
        this.name = name ;
        this.amount = amount ;
    }

    //存錢
    public void deposit(float amt){
        amount +=amt;
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    //取錢
    public void withDraw(float amt){
        amount -=amt ;
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public float getBalance(){
        return  amount ;
    }

}

在AccountOperator類中，我們給account對象加了鎖，這時當(dāng)一個線程訪問account對象時，其他線程就會阻塞，直到該線程訪問account對象結(jié)束，也就是說誰拿到那個鎖，誰就可以運(yùn)行它所控制的那段代碼。
具體代碼已上傳至github
https://github.com/shuai999/ThreadDemo4.git

2.4 修飾一個方法

格式：public synchronized void method(){//todo};

synchronized修飾方法和代碼塊類似，只是作用范圍不一樣：
修飾的代碼塊是大括號括起來的范圍；
修飾的方法是整個函數(shù)；

在用synchronized修飾方法時注意以下幾點：
1.synchronized關(guān)鍵字不能被繼承
1.1 ：如果在父類中某個方法使用了synchronized，而在子類中覆蓋此方法，在子類中這個方法默認(rèn)并不是同步的，必須顯式的在方法中加synchronized才可以；
1.2：還可以在子類方法中調(diào)用父類中相應(yīng)的方法，這樣雖然子類中方法不是同步的，但子類調(diào)用了父類的同步方法，因此，子類的方法也就相當(dāng)于同步了，這兩種方式代碼如下：

在子類方法上邊加上synchronized：
    class Parent{
        public synchronized void method(){}
    }
   class Child extends Parent{
        public synchronized void method(){}
    }
在子類方法中調(diào)用父類的同步方法：
    class Parent{
        public synchronized void method(){}
    }
    class Childe extends Parent{
        public void method(){
            super.method() ;
        }
    }

注意：
1>：在定義接口方法時不能使用synchronized
2>：在構(gòu)造方法中不能用synchronized，但可以使用synchronized代碼塊來進(jìn)行同步

2.5：修飾一個靜態(tài)方法,，代碼如下

public synchronized static void method() {
   // todo
}

2.6：修飾一個類，代碼如下：

class ClassName {
   public void method() {
      synchronized(ClassName.class) {
         // todo
      }
   }
}

總結(jié)：
1>：無論synchronized加在方法上還是對象上，如果它作用的對象是非靜態(tài)的，則它取得的鎖是對象；如果synchronized作用的是一個靜態(tài)方法或一個類，則它取得的對象是該類，該類所有的對象是同一把鎖；
2>：每個對象只有一個鎖 [ lock ]與之相關(guān)聯(lián)，誰拿到這個鎖，誰就可以運(yùn)行它所控制的那段代碼；
3>：實現(xiàn)同步是需要很大的系統(tǒng)開銷作為代價，甚至造成死鎖，所以盡量避免無謂的同步控制。

最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

  • synchronized是Java中的關(guān)鍵字，是一種同步鎖。它修飾的對象有以下幾種： 修飾一個代碼塊，被修飾的代碼...
    明教de教主閱讀 710評論 0贊 2
  • Java8張圖 11、字符串不變性 12、equals()方法、hashCode()方法的區(qū)別 13、...
    Miley_MOJIE閱讀 3,886評論 0贊 11
  • 本文主要講了java中多線程的使用方法、線程同步、線程數(shù)據(jù)傳遞、線程狀態(tài)及相應(yīng)的一些線程函數(shù)用法、概述等。 首先講...
    李欣陽閱讀 2,591評論 1贊 15
  • Java多線程學(xué)習(xí) [-] 一擴(kuò)展javalangThread類 二實現(xiàn)javalangRunnable接口 三T...
    影馳閱讀 3,106評論 1贊 18
  • 我多么希望，有一個門口 早晨，陽光照在草上 我們站著 扶著自己的門扇 門很低，但太陽是明亮的 草在結(jié)它的種子 風(fēng)在...
    如是一一閱讀 316評論 5贊 0

友情鏈接更多精彩內(nèi)容