Java的类锁、对象锁和方法锁

最新推荐文章于 2024-03-22 19:27:17 发布
最新推荐文章于 2024-03-22 19:27:17 发布
阅读量435 收藏 1
点赞数 1
分类专栏： JavaSE 文章标签： 多线程 java thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37888382/article/details/105748943
版权

Java的类锁、对象锁和方法锁

在Java中，对于synchronized关键字，大家看到的第一反应就是这个关键字是进行同步操作的，即得名“同步锁”。

  • 当用它来修饰方法和代码块时，默认当前的对象为锁的对象，即对象锁。

  • 当用来修饰类和静态方法时，默认当前的类为锁的对象

1.对象锁

修饰在方法上时，多个线程调用同一对象的同步方法时会阻塞，调用不同对象的同步方法时不会阻塞。

在多线程环境下，调用不同对象的同步方法：

public class SynchronizedDemo {

    public synchronized void synTest(){
        int i = 5;
        while (i-- > 0){
            System.out.println(Thread.currentThread().getName() + " : " + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        SynchronizedDemo demo1 = new SynchronizedDemo();
        SynchronizedDemo demo2 = new SynchronizedDemo();

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                demo1.obj3();
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                demo2.obj3();
            }
        });

        t1.start();
        t2.start();
    }
}

Output：

Thread-0 : 4
Thread-1 : 4
Thread-0 : 3
Thread-1 : 3
Thread-0 : 2
Thread-1 : 2
Thread-0 : 1
Thread-1 : 1
Thread-0 : 0
Thread-1 : 0

在多线程环境下，调用同一对象的同步方法：

public class SynchronizedDemo {

    public synchronized void synTest(){
        int i = 5;
        while (i-- > 0){
            System.out.println(Thread.currentThread().getName() + " : " + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        SynchronizedDemo demo1 = new SynchronizedDemo();
        SynchronizedDemo demo2 = new SynchronizedDemo();

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                demo1.synTest();
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                demo1.synTest();
            }
        });

        t1.start();
        t2.start();
    }
}

Output：

Thread-0 : 4
Thread-0 : 3
Thread-0 : 2
Thread-0 : 1
Thread-0 : 0
Thread-1 : 4
Thread-1 : 3
Thread-1 : 2
Thread-1 : 1
Thread-1 : 0

在多线程环境下，调用不同对象通过this修饰的局部代码块

public class SynchronizedDemo {

    public void synTest(){
        synchronized (this){
            int i = 5;
            while (i-- > 0){
                System.out.println(Thread.currentThread().getName() + " : " + i);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }

    public static void main(String[] args) {

        SynchronizedDemo demo1 = new SynchronizedDemo();
        SynchronizedDemo demo2 = new SynchronizedDemo();

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                demo1.synTest();
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                demo2.synTest();
            }
        });

        t1.start();
        t2.start();
    }
}

Output：

Thread-0 : 4
Thread-1 : 4
Thread-0 : 3
Thread-1 : 3
Thread-0 : 2
Thread-1 : 2
Thread-0 : 1
Thread-1 : 1
Thread-0 : 0
Thread-1 : 0

对于this修饰的其实指的就是类的实例，所以它也属于对象锁，并不是类锁。

在多线程环境下，调用不同对象通过其他实例类修饰的局部代码块

public class SynchronizedDemo {

    public void synTest(){
        String str = new String("lock");
        synchronized (str){
            int i = 5;
            while (i-- > 0){
                System.out.println(Thread.currentThread().getName() + " : " + i);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }

    public static void main(String[] args) {

        SynchronizedDemo demo1 = new SynchronizedDemo();
        SynchronizedDemo demo2 = new SynchronizedDemo();

        Thread t1 = new Thread(() -> {
            demo1.synTest();
        });

        Thread t2 = new Thread(() -> {
            demo2.synTest();
        });

        t1.start();
        t2.start();
    }
}

Output：

Thread-0 : 4
Thread-1 : 4
Thread-1 : 3
Thread-0 : 3
Thread-1 : 2
Thread-0 : 2
Thread-1 : 1
Thread-0 : 1
Thread-1 : 0
Thread-0 : 0

我们可以看到，我们通过每次调用时实例一个String来进行同步代码块，但是并没有发生阻塞，因为每次生成的是一个实例String，锁的是String，每次都是不一样的，所以不会发生阻塞。

可以通过上述的运行结果可以得到一下结论：

在多线程环境下：

  • 调用不同对象的同步方法，不会发生阻塞
  • 调用相同对象的同步方法，会发生阻塞
  • 调用不同对象通过this修饰的局部代码块，不会发生阻塞
  • 调用不同对象通过其他实例类修饰的同步代码块，不会发生阻塞

2.类锁

在多线程环境下，多次调用类的静态同步方法：

public class SynchronizedDemo {

    public static synchronized void synTest(){
        int i = 5;
        while (i-- > 0){
            System.out.println(Thread.currentThread().getName() + " : " + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                SynchronizedDemo.synTest();
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                SynchronizedDemo.synTest();
            }
        });

        t1.start();
        t2.start();
    }

Output：

Thread-0 : 4
Thread-0 : 3
Thread-0 : 2
Thread-0 : 1
Thread-0 : 0
Thread-1 : 4
Thread-1 : 3
Thread-1 : 2
Thread-1 : 1
Thread-1 : 0

在多线程环境下，多次调用被类锁的代码块：

public class SynchronizedDemo {
    
    public void synTest(){
        synchronized (SynchronizedDemo.class){
            int i = 5;
            while (i-- > 0){
                System.out.println(Thread.currentThread().getName() + " : " + i);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }

    public static void main(String[] args) {

        SynchronizedDemo demo1 = new SynchronizedDemo();
        SynchronizedDemo demo2 = new SynchronizedDemo();

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                demo1.synTest();
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                demo2.synTest();
            }
        });

        t1.start();
        t2.start();
    }
}

Output:

Thread-1 : 4
Thread-1 : 3
Thread-1 : 2
Thread-1 : 1
Thread-1 : 0
Thread-0 : 4
Thread-0 : 3
Thread-0 : 2
Thread-0 : 1
Thread-0 : 0

对于对象SynchronizedDemo.class，实际上就是SynchronizedDemo这个类，也就是对类进行加锁。

可以通过上述的运行结果可以得到一下结论：

在多线程环境下：

  • 多次调用静态的同步方法，会进行阻塞
  • 不同对象调用被类锁的同步代码块，会进行阻塞

3.类锁和对象锁同时存在

在多线程环境下，同时调用同一对象的类锁和对象锁

public class SynchronizedDemo {

    public static synchronized void synTestStatic() {
        int i = 5;
        while (i-- > 0) {
            System.out.println(Thread.currentThread().getName() + " : " + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void synTest() {
        int i = 5;
        while (i-- > 0) {
            System.out.println(Thread.currentThread().getName() + " : " + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {

        SynchronizedDemo demo1 = new SynchronizedDemo();

        Thread t1 = new Thread(() -> {
            demo1.synTest();
        });

        Thread t2 = new Thread(() -> {
            SynchronizedDemo.synTestStatic();
        });

        t1.start();
        t2.start();
    }
}

Output：

Thread-1 : 4
Thread-0 : 4
Thread-1 : 3
Thread-0 : 3
Thread-1 : 2
Thread-0 : 2
Thread-1 : 1
Thread-0 : 1
Thread-1 : 0
Thread-0 : 0

我们可以到看到，在多线程环境下，类锁和对象锁同时存在的情况下，多线程访问时不会阻塞，因为他们不是同一个锁。

可以通过上述的运行结果可以得到一下结论：

在多线程环境下：

  • 类锁和对象锁同时存在的情况下，不会发生阻塞

4.总结

在这里插入图片描述

ArvinYL
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解java 对象锁与类锁
09-07
主要介绍了java 对象锁与类锁的相关资料，帮助大家更好的理解和学习Java，感兴趣的朋友可以了解下
Synchronized方法锁、对象锁、类锁区别
ratel的博客
03-03 2160
Synchronized方法锁、对象锁、类锁区别
JAVA Synchronized对象锁和类锁区别（牛逼）
最新发布
pengweid专栏
03-22 9511
一个类就像一个四合院，四合院的大门叫做构造方法，盖房子必须经过大门，每new一个对象，就表示在四合院里再盖一间新房子，大门上面的锁，叫做构造锁，里面每一间房子就是一个实例，每间房子里边都有一个锁叫做实例锁。 四合院里有厕所，水龙头，洗衣机等等都是公共设施，都叫做static资源）你想获得洗衣机，就需要调用static的洗衣机方法，也就是行为） 假如一天来了3个人租房子，第一个人租了一间小房子，那...
方法锁、对象锁、类锁
qq_35124535的博客
03-29 534
java synchronized同步方法调用另一个同步方法，锁机制问题 public synchronized void methodA(int a, int b); public synchronized void methodB(int a）{ methodA(a, 0); } 要明白两个问题，1.锁的对象是谁，2.谁持有了锁。 假设方法A和B
方法锁、对象锁和类锁区别
qq_35181209的博客
05-22 5865
引言：结合synchronized进行分析。 synchronized用来处理多个线程同时访问同一个类的一个代码块、方法，甚至这个类。 （1）修饰代码块时，需要一个reference对象作为锁的对象。 （2）修饰方法时，默认是当前对线作为锁的对象。 （3）修饰类时，默认是当前类的Class对象作为锁的对象。 1、对象锁 当一个对象中有同步方法或者同步块，线程调用此对象进入该同步区域
java 变量锁类型的区别_Java 对象锁和类锁全面解析
weixin_42303003的博客
02-13 285
原标题：Java 对象锁和类锁全面解析来源：小宝鸽，blog.csdn.net/u013142781/article/details/51697672最近工作有用到一些多线程的东西，之前吧，有用到synchronized同步块，不过是别人怎么用就跟着用，并没有搞清楚锁的概念。最近也是遇到一些问题，不搞清楚锁的概念，很容易碰壁，甚至有些时候自己连用没用对都不知道。今天把一些疑惑都解开了，写篇文章分享...
方法锁、对象锁、类锁的意义和区别
XiaoArea的博客
02-22 295
方法锁、对象锁、类锁的意义和区别
java 方法锁 对象锁_Java的类锁、对象锁和方法锁
weixin_42525551的博客
02-12 252
在Java中，对于synchronized关键字，大家看到的第一反应就是这个关键字是进行同步操作的，即得名“同步锁”。当用它来修饰方法和代码块时，默认当前的对象为锁的对象，即对象锁。当用来修饰类和静态方法时，默认当前的类为锁的对象对象锁修饰在方法上时，多个线程调用同一对象的同步方法时会阻塞，调用不同对象的同步方法时不会阻塞。在多线程环境下，调用不同对象的同步方法：public class Sync...
java对一个对象加锁，锁的是什么东西？
分享Java技术知识，共同成长进步！
09-19 1238
线程同步相关知识详解。 一、同步代码块 作用：把出现线程安全问题的核心代码给上锁 原理：每次只能一个线程进入，执行完毕后自动解决，其他线程才可以进来执行。 synchronized(同步锁对象) { 操作共享资源的代码(核心代码) } 锁对象要求 理论上：锁对象只要对于当前同时执行的现成来说是同一个对象即可。 锁对象用任意唯一的对象好不好呢？ 不好，会影响其他无关线程的执行。 锁对象的规范要求 规范上：建议使用共享资源作为锁对象。 对于实例方法建议使用this作为锁对象。
Java对象锁和类锁全面解析（多线程synchronize
11-22
Java对象锁和类锁全面解析（多线程synchronized关键字）编程开发技术共14页.pdf.zip
Java类锁、对象锁、私有锁冲突测试
09-04
主要介绍了Java类锁、对象锁、私有锁冲突测试,得出结论是加锁方法够成了竞争关系,同一时刻只能有一个方法能执行,需要的朋友可以参考下
详解Java同步—线程锁和条件对象
08-27
在这篇文章中给大家详细讲述了Java同步—线程锁和条件对象的相关知识点，有需要的读者们可以参考下。
Java对象锁
12-22
在并发环境下，解决共享资源冲突问题时，可以考虑使用锁机制。 　1.对象的锁 　所有对象都自动含有单一的锁。 　JVM负责跟踪对象被加锁的次数。... 　2.1同步到单一对象锁 　当使用同步块时，如果方法下的同步块
输入一个文件名和一个字符串, 统计这个字符串在这个文件中出现的次数？
ArvinYL
09-24 2348
  本来对文件读取掌握的就特别不好，还记得在一次省赛的蓝桥杯比赛中有一道文件读取，还好那次文件数据不大，因为参赛用的语言是C语言，所以直接全部数据scanf了，还好全部可以读取，当时看到我们带队老师不可置信的眼神，当时我是想找个地缝钻进去的。以后还是要多补一下自己的薄弱环节。 public class FileUtils{ /** * 写入一个方法，输入一个文件名和一个...
CountDownLatch和 CyclicBarrier的内部原理和用法
ArvinYL
09-27 849
  这个东西第一次看到是在一场校招笔试上看到的，笔试其他题目做的还好，看的这个的时候一脸懵逼。一看就知道这两个词是关于多线程的，因为也就多线程会起这么sao的名字了，但是我比他更sao，因为这道题我空着没做。虽然这个没做出来，但是其他做的挺好的，至今还没收到面试邀约，伤心。 1.CountDownLatch减计数，CyclicBarrier加计数。 2.CountDownLatch是一次性的，...
java中static在类中的调用过程
ArvinYL
03-14 756
static经常在面试通过继承等知识一起进行考察,接下来就针对static的继承进行了解。 1.下面这段代码的输出 public class Test extends Base{ static{ System.out.println("test static"); } public Test(){ System.out.println("test const...
Java 类的实例化顺序和初始化顺序
ArvinYL
10-20 666
class B extends A ,然后A类也就是父类里面有静态代码块，静态方法，静态成员变量，构造代码块，普通成员变量，普通方法。 经测试，得到如下结论： 1.父类【静态成员】和【静态代码块】，按照代码中出现的顺序依次执行。 2.子类【静态成员】和【静态代码块】，按照代码中出现的顺序依次执行。 3.父类的【构造代码块】和【普通成员变量被普通成员方法赋值】，按在代码中出现的顺序依次执行。 4.执...
java类锁和对象锁的区别
06-09
Java中的锁分为类锁和对象锁，它们的主要区别在于锁定的范围不同。 对象锁是针对对象实例的锁，当某个线程获取了该对象的锁之后，其他试图获取该对象锁的线程将会被阻塞，直到该线程释放该对象锁。 类锁是针对类的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值