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

最新推荐文章于 2023-06-21 16:41:40 发布
最新推荐文章于 2023-06-21 16:41:40 发布
阅读量495 收藏 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
关注
专栏目录
详解java 对象锁与类锁
09-07
Java中的对象锁与类锁是多线程编程中非常重要的概念，它们用于控制并发访问，确保数据的一致性和完整性。本文将深入探讨这两种锁的原理、形式及应用场景。 一、对象锁（方法锁） 对象锁，又称为实例锁，是针对特定...
方法锁、对象锁、类锁
qq_35124535的博客
03-29 554
java synchronized同步方法调用另一个同步方法，锁机制问题 public synchronized void methodA(int a, int b); public synchronized void methodB(int a）{ methodA(a, 0); } 要明白两个问题，1.锁的对象是谁，2.谁持有了锁。 假设方法A和B
方法锁、对象锁、类锁的意义和区别
XiaoArea的博客
02-22 323
方法锁、对象锁、类锁的意义和区别
方法锁、对象锁和类锁区别
qq_35181209的博客
05-22 5992
引言：结合synchronized进行分析。 synchronized用来处理多个线程同时访问同一个类的一个代码块、方法，甚至这个类。 （1）修饰代码块时，需要一个reference对象作为锁的对象。 （2）修饰方法时，默认是当前对线作为锁的对象。 （3）修饰类时，默认是当前类的Class对象作为锁的对象。 1、对象锁 当一个对象中有同步方法或者同步块，线程调用此对象进入该同步区域
Synchronized方法锁、对象锁、类锁区别
ratel的博客
03-03 2494
Synchronized方法锁、对象锁、类锁区别
一文搞懂java中方法锁、对象锁、类锁、静态锁
智者之家
08-23 6178
synchronized关键字，我们一般称之为“同步锁”，用它来修饰需要同步的方法和需要同步代码块，默认是当前对象作为锁的对象。在用类修饰synchronized时（或者修饰静态方法），默认是当前类的Class对象作为锁的对象，故存在着方法锁、对象锁、类锁这样的概念。 先给出以下代码感受下代码执行的时候为什么需要同步？代码可能比较枯燥，配上业务理解起来就会舒服很多，学生军训，有三列，每列5人，...
Java对象锁和类锁全面解析（多线程synchronize
11-22
Java对象锁和类锁是Java多线程编程中至关重要的概念，它们是通过`synchronized`关键字来实现的，用于确保代码在并发环境下的线程安全。在这个全面解析中，我们将深入探讨这两个锁机制，理解它们的工作原理以及如何在...
详解Java同步—线程锁和条件对象
08-27
总结来说，Java中的线程锁和条件对象是实现线程同步的重要工具。`synchronized`关键字提供了一种简单的方式来保护共享资源，而`ReentrantLock`和条件对象则提供了更高级的控制，比如可重入性、非阻塞锁获取以及基于...
Java锁之阻塞锁介绍和代码实例
09-04
`ReentrantLock`是Java并发包`java.util.concurrent.locks`中的可重入互斥锁，相比`synchronized`，它提供了更多的灵活性，如可中断的锁等待、公平锁和非公平锁的选择等。当线程尝试获取`ReentrantLock`而锁已被其他...
java 方法锁 对象锁_Java的类锁、对象锁和方法锁
weixin_42525551的博客
02-12 295
在Java中，对于synchronized关键字，大家看到的第一反应就是这个关键字是进行同步操作的，即得名“同步锁”。当用它来修饰方法和代码块时，默认当前的对象为锁的对象，即对象锁。当用来修饰类和静态方法时，默认当前的类为锁的对象对象锁修饰在方法上时，多个线程调用同一对象的同步方法时会阻塞，调用不同对象的同步方法时不会阻塞。在多线程环境下，调用不同对象的同步方法：public class Sync...
java对一个对象加锁，锁的是什么东西？
分享Java技术知识，共同成长进步！
09-19 1315
线程同步相关知识详解。 一、同步代码块 作用：把出现线程安全问题的核心代码给上锁 原理：每次只能一个线程进入，执行完毕后自动解决，其他线程才可以进来执行。 synchronized(同步锁对象) { 操作共享资源的代码(核心代码) } 锁对象要求 理论上：锁对象只要对于当前同时执行的现成来说是同一个对象即可。 锁对象用任意唯一的对象好不好呢？ 不好，会影响其他无关线程的执行。 锁对象的规范要求 规范上：建议使用共享资源作为锁对象。 对于实例方法建议使用this作为锁对象。
多线程学习之类锁、对象锁、方法锁
weixin_50348837的博客
02-22 709
在Java中，对于synchronized关键字，大家看到的第一反应就是这个关键字是进行同步操作的，即得名“同步锁”。当用它来修饰方法和代码块时，默认当前的对象为锁的对象，即对象锁。当用来修饰类和静态方法时，默认当前的类为锁的对象所以，方法锁既可以是类锁，又可以是对象锁。主要就是看他修饰的静态方法还是非静态方法。对象锁修饰在方法上时，多个线程调用同一对象的同步方法时会阻塞，调用不同对象的同步方法时不会阻塞。可以看出，两个线程在调用不同对象的同步方法时，并未发生阻塞。
Java 的锁 -- 具体的锁对象及其实现原理
十七的博客
11-28 2852
锁机制：用来保证在多线程并发情况下数据的一致性。 锁的作用点：操作一个对象或者调用一个方法前加锁，这样当其他线程也对该对象和方法进行访问时就需要获得锁，如果该锁被其他线程持有，那么该线程则进入阻塞队列等待获得锁。 Java 中，用作锁的对象有：synchronized、ReentrantLock、ReadWriteLock、volatile。 synchronized：同步锁。 ReentrantLock：可重入锁。 ReadWriteLock：读写锁。
详解Java锁对象
最新发布
Krive~Irving
06-21 3305
synchronized特性,锁对象,volatile,
对象锁和类锁的区别
Apollo的博客
04-15 1777
对实例对象和类加锁的区别 class Account { private int money; public Account(int money) { this.money = money; } public sell(){} } Account a = new Account(2000); Account b = new Account(2000); 实例锁即sycronized(this),加载实例对象上,不同的实例对象之间的锁不冲突.当sell加了
Java类锁、对象锁、私有锁冲突分析与测试
"Java类锁、对象锁、私有锁冲突测试主要探讨了这三种锁在并发编程中的竞争关系，确保同一时刻只有一个方法能够执行。本文通过实例代码展示了类锁、对象锁和私有锁的概念，并进行了冲突测试，旨在帮助开发者理解和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值