深入研究 synchronized 同步锁作用于静态方法和非静态方法的区别

最新推荐文章于 2022-10-16 14:48:52 发布

龙腾腾

最新推荐文章于 2022-10-16 14:48:52 发布

阅读量1k

点赞数 1

分类专栏： android知识回顾文章标签： java android

原文链接：https://www.cnblogs.com/c2g5201314/p/13110894.html

版权

android知识回顾专栏收录该内容

19 篇文章 1 订阅

订阅专栏

原文地址：https://www.cnblogs.com/c2g5201314/p/13110894.html

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);
        }

    }
}

（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();
    }
}

打印结果
在这里插入图片描述
结论：互斥，不能同时使用

（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();
    }
}

打印结果
在这里插入图片描述

结论：互斥，不能同时使用

（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();
    }
}

在这里插入图片描述
结论：可以同时使用

（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();
    }
}

打印结果
在这里插入图片描述
结论：互斥，不能同时使用

（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();
    }
}

打印结果

在这里插入图片描述

结论：互斥，不能同时使用

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

分割线

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

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();
    }
}

打印结果

在这里插入图片描述
结论：可以同时使用

（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();
    }
}

打印结果

在这里插入图片描述
结论：可以同时使用

（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();
    }
}

打印结果
在这里插入图片描述
结论：可以同时使用

（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();
    }
}

打印结果

在这里插入图片描述结论：互斥，不能同时使用

（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();
    }
}

打印结果
在这里插入图片描述
结论：互斥，不能同时使用

4.总结

（1）在多线程使用同一个对象的测试中，只允许同时使用一个对象锁，一个类锁，
其他操作搭配都互斥，只能等前一个线程解锁才能让下一个线程使用；
（2）在多线程分别 new 一个对象的测试中，允许同时使用任意的对象锁，也允许对象锁和
一个类锁同时使用，但是类锁不能够同时使用，会互斥，只能等前一个线程解锁才能让下一个线程使用；