【synchronized 关键字修饰静态、非静态方法的区别】

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

积善之家、必有余庆

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

阅读量109

点赞数

分类专栏： #java多线程文章标签：多线程 java thread 多进程并发编程

本文链接：https://blog.csdn.net/qq_44682003/article/details/110676739

版权

#java多线程专栏收录该内容

10 篇文章 0 订阅

订阅专栏

synchronized 锁

我之前写过两篇关于多线程的博客，对synchronized
锁的实现机制有详细的解释，有兴趣的朋友可以先跳转：多线程

测试总结：

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

下面我们来分组测试：

我们先准备一个含有对象锁和类锁的类：MSynchronized


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

    }
}

测试类

public class SynT {

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

测试一： 多线程使用同一个对象

同时使用同一个对象锁

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

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

同时使用不同的的对象锁


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

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

一个线程使用对象锁，一个使用类锁


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

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

同时使用同一个类锁


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

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

同时使用不同的的类锁


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

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

测试二： 多线程分别一个对象

同时使用同一个对象锁

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

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

同时使用不同的的对象锁

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

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

一个线程使用对象锁，一个使用类锁

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

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

同时使用同一个类锁

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

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

同时使用不同的的类锁

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

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

测试总结：

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

积善之家、必有余庆

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【synchronized 关键字修饰静态、非静态方法的区别】

synchronized 锁我之前写过两篇关于多线程的博客，对synchronized锁的实现机制有详细的解释，有兴趣的朋友可以先跳转：多线程测试总结：多线程使用同一个对象，只允许同时使用一个对象锁，一个类锁，其他操作搭配都互斥，只能等前一个线程解锁才能让下一个线程使用；多线程分别 new 一个对象，允许同时使用任意的对象锁，也允许对象锁和一个类锁同时使用，但是类锁不能够同时使用，会互斥，只能等前一个线程解锁才能让下一个线程使用；下面我们来分组测试：我们先准备一个含有对象锁和类锁的
复制链接

扫一扫