Synchronized內建鎖

阿新 • • 發佈：2020-09-15

理論:

　　多個執行緒之間共享資源就會發成資料上的衝突,我們往往會使用Synchronized關鍵字來實現鎖

　　這個鎖要不加在方法上,要麼以同步塊的形式來使用,它最大作用就是確保多個執行緒在同一時刻,只能有一個執行緒處於方法和同步塊之中,這樣它就保證了執行緒對變數的可見性和排他性

　　因為這個Synchronized關鍵字是由Java語言本身為我們提供的,所以習慣將Synchronized關鍵字稱之為內建鎖

物件鎖:

　　鎖的是類的物件例項

類鎖:

　　鎖的是每個類的Class物件,每個類的Class物件在一個虛擬機器中只有一個,所以類鎖也只有一個

package org.dance.day1.sync;

 
import org.dance.tools.SleepTools;

/**
 * 物件鎖和類鎖
 * @author ZYGisComputer
 */
public class SynClzAndInst {

    /**
     * 使用類鎖的執行緒
     */
    private static class SynClass extends Thread{
        @Override
        public void run() {
            System.out.println("TestClass is running...");
            synClass();
        }
    }

     
/**
     * 使用物件鎖的執行緒
     */
    private static class InstanceSyn implements Runnable{
        private SynClzAndInst synClzAndInst;

        public InstanceSyn(SynClzAndInst synClzAndInst) {
            this.synClzAndInst = synClzAndInst;
        }

        @Override
        public void run() {
            System.out.println( 
"TestInstance is running..."+synClzAndInst);
            synClzAndInst.instance();
        }
    }

    /**
     * 使用物件鎖的執行緒
     */
    private static class Instance2Syn implements Runnable{
        private SynClzAndInst synClzAndInst;

        public Instance2Syn(SynClzAndInst synClzAndInst) {
            this.synClzAndInst = synClzAndInst;
        }
        @Override
        public void run() {
            System.out.println("TestInstance2 is running..."+synClzAndInst);
            synClzAndInst.instance2();
        }
    }

    /**
     * 鎖物件
     */
    private synchronized void instance(){
        SleepTools.second(3);
        System.out.println("synInstance is going..."+this.toString());
        SleepTools.second(3);
        System.out.println("synInstance ended "+this.toString());
    }

    /**
     * 鎖物件
     */
    private synchronized void instance2(){
        SleepTools.second(3);
        System.out.println("synInstance2 is going..."+this.toString());
        SleepTools.second(3);
        System.out.println("synInstance2 ended "+this.toString());
    }

    /**
     * 類鎖，實際是鎖類的class物件
     */
    private static synchronized void synClass(){
        SleepTools.second(1);
        System.out.println("synClass going...");
        SleepTools.second(1);
        System.out.println("synClass end");
    }

    public static void main(String[] args) {
        // 測試鎖兩個物件
//        testTwoObject();
        // 測試鎖一個物件
//        testOneObject();
        // 測試類鎖
        testClass();
        SleepTools.second(1);
    }

    /**
     * 物件鎖
     * 因為是鎖的兩個物件 所以可以同時執行
     */
    public static void testTwoObject(){
        SynClzAndInst synClzAndInst = new SynClzAndInst();
        Thread t1 = new Thread(new InstanceSyn(synClzAndInst));
        SynClzAndInst synClzAndInst2 = new SynClzAndInst();
        Thread t2 = new Thread(new Instance2Syn(synClzAndInst2));
        t1.start();
        t2.start();
    }

    /**
     * 物件鎖
     * 因為是鎖的同一個物件 所以不可以同時執行
     */
    public static void testOneObject(){
        SynClzAndInst synClzAndInst = new SynClzAndInst();
        Thread t1 = new Thread(new InstanceSyn(synClzAndInst));
        Thread t2 = new Thread(new Instance2Syn(synClzAndInst));
        t1.start();
        t2.start();
    }
    /**
     * 類鎖
     * 類鎖鎖的是虛擬機器記憶體中的唯一一份的class映象
     */
    public static void testClass(){
        SynClzAndInst synClzAndInst = new SynClzAndInst();
        Thread t1 = new Thread(new InstanceSyn(synClzAndInst));
        t1.start();
        SynClass synClass = new SynClass();
        synClass.start();
    }


}