history linux 网络视频直播系统 Zookeeper 个人收款码 vector pyspark constructor alertifyjs cad怎么重复上一次命令 java常用的包 ubuntu显示隐藏文件夹 pyhton中异常和模块 mysql学习 python程序 javaswitch语句 javarandom java的date java小程序 枪神传说辅助 图解深度学习 max电池容量 心理学与生活pdf fdisk下载 skycc组合营销软件 为什么英雄联盟无法连接服务器 pr蒙版 暴力猴插件 光头强换肤助手 计划任务软件 pp安卓助手 视频旋转软件 饥荒黄油 origin怎么画图 平衡德天赋 苹果x有几个颜色 ps退出全屏 js读取本地文件 查看端口号 游戏超人吃鸡
当前位置: 首页 > 学习教程  > 编程语言

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

2020/12/5 9:38:05 文章标签:

synchronized 锁我之前写过两篇关于多线程的博客,对synchronized 锁的实现机制有详细的解释,有兴趣的朋友可以先跳转:多线程 测试总结: 多线程使用同一个对象,只允许同时使用一个对象锁,一个类锁&#xff…

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 一个对象,允许同时使用任意的对象锁,也允许对象锁和 一个类锁同时使用,但是类锁不能够同时使用,会互斥,只能等前一个线程解锁才能让下一个线程使用;

本文链接: http://www.dtmao.cc/news_show_450048.shtml

附件下载

相关教程

    暂无相关的数据...

共有条评论 网友评论

验证码: 看不清楚?