深入研究 synchronized 同步鎖作用於靜態方法和非靜態方法的區別

本文轉載自查看原文 2020-06-12 22:30 1126 Java/ java

1.前言

　　眾所周知， synchronized 是同步鎖，雖然在底層又細分了無鎖、偏向鎖、輕量級鎖、自旋鎖以及重量級鎖機制，

這些底層鎖知道一下原理即可，【想要了解這篇博文有解釋： https://blog.csdn.net/u013256816/article/details/51204385 】

我這篇隨筆專門研究與總結關於 synchronized 加在同一個類里的靜態和非靜態方法前有什么不一樣的影響。

這都是因為我看到的一道題引起的：

答案是 BE

我想問為什么？

查找博客資料，都是很籠統地解釋

static的方法屬於類方法，它屬於這個Class（注意：這里的Class不是指Class的某個具體對
象），那么static獲取到的鎖，是屬於類的鎖。而非static方法獲取到的鎖，是屬於當前對象
的鎖。所以，他們之間不會產生互斥。

看的我一臉懵逼。。。。。。

當然可以清楚地知道

加了synchronized 且有static 的方法稱為類鎖，

沒有static 的方法稱為對象鎖。

經過測試總結：

（1）多線程使用同一個對象，只允許同時使用一個對象鎖，一個類鎖，
    其他操作搭配都互斥，只能等前一個線程解鎖才能讓下一個線程使用；
（2）多線程分別 new 一個對象，允許同時使用任意的對象鎖，也允許對象鎖和
 一個類鎖同時使用，但是類鎖不能夠同時使用，會互斥，只能等前一個線程解鎖才能讓下一個線程使用；

2.操作

（1）目錄結構

（2）准備一個含有對象鎖和類鎖的類

package com.example.javabaisc.lock;

public class MSynchronized {
    public synchronized void method1(String name) throws InterruptedException {
        int i = 0;
        while (true) {
            i++;
            System.out.println(name + "我是方法1，當前數字是" + i);
            if (i > 4) {
                System.out.println(name + "我是方法1，退出");
                break;
            }
            Thread.sleep(1000);
        }
    }

    public synchronized void method2(String name) throws InterruptedException {
        int i = 0;
        while (true) {
            i++;
            System.out.println(name + "我是方法2，當前數字是" + i);
            if (i > 4) {
                System.out.println(name + "我是方法2，退出");
                break;
            }
            Thread.sleep(1000);
        }


    }

    public static synchronized void method3(String name) throws InterruptedException {
        int i = 0;
        while (true) {
            i++;
            System.out.println(name + "我是方法3，當前數字是" + i);
            if (i > 4) {
                System.out.println(name + "我是方法3，退出");
                break;
            }
            Thread.sleep(1000);
        }


    }

    public static synchronized void method4(String name) throws InterruptedException {
        int i = 0;
        while (true) {
            i++;
            System.out.println(name + "我是方法4，當前數字是" + i);
            if (i > 4) {
                System.out.println(name + "我是方法4，退出");
                break;
            }
            Thread.sleep(1000);
        }

    }
}

View Code

（3）測試類

package com.example.javabaisc.lock;


public class SynT {

    public static void main(String[] args){
    
    }
}

內容在測試里詳細補充【注意，不可使用@Test注解啟動用戶線程，否則所有線程都會隨用戶線程結束而結束】

3.測試

1）測試：多線程使用同一個對象

（1）同時使用同一個對象鎖

package com.example.javabaisc.lock;

public class SynT {

    public static void main(String[] args){
        //共用對象
        MSynchronized mSynchronized = new MSynchronized();

        Thread s1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
//                    System.out.println("=========我是線程1==========");
                    mSynchronized.method1("我是線程1");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });
        Thread s2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
//                    System.out.println("==========我是線程2========");
                    mSynchronized.method1("我是線程2");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });

        //啟動
        s1.start();
        s2.start();
    }
}

View Code

打印結果

結論：互斥，不能同時使用

（2）同時使用不同的的對象鎖

package com.example.javabaisc.lock;

public class SynT {

    public static void main(String[] args){
        //共用對象
        MSynchronized mSynchronized = new MSynchronized();

        Thread s1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
//                    System.out.println("=========我是線程1==========");
                    mSynchronized.method1("我是線程1");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });
        Thread s2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
//                    System.out.println("==========我是線程2========");
                    mSynchronized.method2("我是線程2");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });

        //啟動
        s1.start();
        s2.start();
    }
}

View Code

打印結果

結論：互斥，不能同時使用

（3）一個線程使用對象鎖，一個使用類鎖

package com.example.javabaisc.lock;

public class SynT {

    public static void main(String[] args){
        //共用對象
        MSynchronized mSynchronized = new MSynchronized();

        Thread s1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
//                    System.out.println("=========我是線程1==========");
                    mSynchronized.method1("我是線程1");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });
        Thread s2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
//                    System.out.println("==========我是線程2========");
                    mSynchronized.method4("我是線程2");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });

        //啟動
        s1.start();
        s2.start();
    }
}

View Code

打印結果

結論：可以同時使用

（4）同時使用同一個類鎖

package com.example.javabaisc.lock;

public class SynT {

    public static void main(String[] args){
        //共用對象
        MSynchronized mSynchronized = new MSynchronized();

        Thread s1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
//                    System.out.println("=========我是線程1==========");
                    mSynchronized.method4("我是線程1");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });
        Thread s2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
//                    System.out.println("==========我是線程2========");
                    mSynchronized.method4("我是線程2");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });

        //啟動
        s1.start();
        s2.start();
    }
}

View Code

打印結果

結論：互斥，不能同時使用

（5）同時使用不同的的類鎖

package com.example.javabaisc.lock;

public class SynT {

    public static void main(String[] args){
        //共用對象
        MSynchronized mSynchronized = new MSynchronized();

        Thread s1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
//                    System.out.println("=========我是線程1==========");
                    mSynchronized.method3("我是線程1");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });
        Thread s2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
//                    System.out.println("==========我是線程2========");
                    mSynchronized.method4("我是線程2");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });

        //啟動
        s1.start();
        s2.start();
    }
}

View Code

打印結果

結論：互斥，不能同時使用

===================================================================================

　　　　　　　　　　　　　　　　　　分割線

===================================================================================

2）測試：多線程分別 new 一個對象

（1）同時使用同一個對象鎖

package com.example.javabaisc.lock;

public class SynT {

    public static void main(String[] args){

        Thread s1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
//                    System.out.println("=========我是線程1==========");
                    MSynchronized mSynchronized = new MSynchronized();
                    mSynchronized.method1("我是線程1");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });
        Thread s2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
//                    System.out.println("==========我是線程2========");
                    MSynchronized mSynchronized2 = new MSynchronized();
                    mSynchronized2.method1("我是線程2");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });

        //啟動
        s1.start();
        s2.start();
    }
}

View Code

打印結果

結論：可以同時使用

（2）同時使用不同的的對象鎖

package com.example.javabaisc.lock;

public class SynT {

    public static void main(String[] args){

        Thread s1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
//                    System.out.println("=========我是線程1==========");
                    MSynchronized mSynchronized = new MSynchronized();
                    mSynchronized.method1("我是線程1");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });
        Thread s2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
//                    System.out.println("==========我是線程2========");
                    MSynchronized mSynchronized2 = new MSynchronized();
                    mSynchronized2.method2("我是線程2");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });

        //啟動
        s1.start();
        s2.start();
    }
}

View Code

打印結果

結論：可以同時使用

（3）一個線程使用對象鎖，一個使用類鎖

package com.example.javabaisc.lock;

public class SynT {

    public static void main(String[] args){

        Thread s1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
//                    System.out.println("=========我是線程1==========");
                    MSynchronized mSynchronized = new MSynchronized();
                    mSynchronized.method1("我是線程1");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });
        Thread s2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
//                    System.out.println("==========我是線程2========");
                    MSynchronized mSynchronized2 = new MSynchronized();
                    mSynchronized2.method4("我是線程2");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });

        //啟動
        s1.start();
        s2.start();
    }
}

View Code

打印結果

結論：可以同時使用

（4）同時使用同一個類鎖

package com.example.javabaisc.lock;

public class SynT {

    public static void main(String[] args){

        Thread s1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
//                    System.out.println("=========我是線程1==========");
                    MSynchronized mSynchronized = new MSynchronized();
                    mSynchronized.method4("我是線程1");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });
        Thread s2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
//                    System.out.println("==========我是線程2========");
                    MSynchronized mSynchronized2 = new MSynchronized();
                    mSynchronized2.method4("我是線程2");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });

        //啟動
        s1.start();
        s2.start();
    }
}

View Code

打印結果

結論：互斥，不能同時使用

（5）同時使用不同的的類鎖

package com.example.javabaisc.lock;

public class SynT {

    public static void main(String[] args){

        Thread s1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
//                    System.out.println("=========我是線程1==========");
                    MSynchronized mSynchronized = new MSynchronized();
                    mSynchronized.method3("我是線程1");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });
        Thread s2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
//                    System.out.println("==========我是線程2========");
                    MSynchronized mSynchronized2 = new MSynchronized();
                    mSynchronized2.method4("我是線程2");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });

        //啟動
        s1.start();
        s2.start();
    }
}

View Code

打印結果

結論：互斥，不能同時使用

4.總結

（1）在多線程使用同一個對象的測試中，只允許同時使用一個對象鎖，一個類鎖，
    其他操作搭配都互斥，只能等前一個線程解鎖才能讓下一個線程使用；
（2）在多線程分別 new 一個對象的測試中，允許同時使用任意的對象鎖，也允許對象鎖和
 一個類鎖同時使用，但是類鎖不能夠同時使用，會互斥，只能等前一個線程解鎖才能讓下一個線程使用；

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 synchronized 作用在普通方法與靜態方法的區別靜態方法和非靜態方法的區別靜態方法與非靜態方法的區別 c#靜態方法和非靜態方法區別 Java 中靜態方法與非靜態方法的區別靜態方法加鎖，和非靜態方法加鎖區別靜態方法和非靜態方法的區別 beforeEach的深入研究，及beforeEach和beforeRouteEnter區別？ PHP中靜態方法(static)與非靜態方法的使用及區別 C#中靜態方法和非靜態方法的區別

深入研究 synchronized 同步鎖 作用於 靜態方法 和 非靜態方法 的 區別

1.前言

我想問為什么？

經過測試總結：

2.操作

3.測試

4.總結

免責聲明！

深入研究 synchronized 同步鎖作用於靜態方法和非靜態方法的區別