多线程之对象锁、类锁，引用锁

最新推荐文章于 2024-07-01 03:14:20 发布
最新推荐文章于 2024-07-01 03:14:20 发布
阅读量1.9k 收藏 9
点赞数 3
分类专栏： 多线程 文章标签： java 锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GDFHGFHGFH/article/details/118770201
版权
本文详细介绍了Java中的锁机制，包括类锁、对象锁和引用锁。类锁通过静态方法或同步代码块锁定类本身，对象锁则是针对实例方法或同步代码块，确保同一时刻只有一个线程访问。引用锁则可以通过类的静态引用或实例引用实现类似的效果，控制对特定资源的访问。文章通过示例代码展示了各种锁的使用和竞争关系。
摘要由CSDN通过智能技术生成

我们知道在多线程环境下，我们常常需要给一些共享的东西加锁来保证安全性，在访问某个共享资源的时候，就需要获取到它锁，而这个这个锁就分为很多种，类锁、对象锁、引用锁。

结论

1.对于synchronized关键字，作用在方法上，如public （static） synchronized 返回值类型 方法名,如果是静态方法，那么此处的锁就是类锁，如果是普通方法，锁就是对象锁。
2.synchronized（this）{…}就代表此处的锁就是对象锁，synchronized（类.class）{…}就代表此处锁就是类锁。
3.对于引用锁，synchronized（非静态引用）{…}，实际上就代表此处的锁就是发挥着和对象锁一样的作用，synchronized（静态引用）{…}，实际上就代表此处的锁发挥着和类锁一样的作用。
4.一个实例只能有一个对象锁，那么在同一时刻，外部的线程最多只能访问一个被synchronized修饰的方法。

对象锁

所谓对象锁，从名字上看就是锁住对象的锁，对象就是实例，一个类可以有多个实例，每个实例都可以有自己的锁，或者这样说每个实例都都可以锁住属于自己的东西，那么一个类中什么是属于实例的的那，非静态的方法、变量、代码块、，那么作用在这些东西上的锁都可以是对象锁，需要注意的是在java中synchronized不能修饰变量，并且一个实例只能有一个锁对象，只能修饰方法和代码块。所以属于对象的，并且可以加锁的就是非静态方法和非静态代码块。对于方法的加锁方式 ：public synchronized void say(){…}，对于代码块的加锁方式synchronized(this){ …}，代码如下：

/**
 * @author 理想
 * @version 1.0
 * @date 2021/7/16 1:06
 */
public class Test01 {
    public int a=5;
    public static int count=0;
    
    {
        synchronized(this)
        {
            System.out.println( "这是第"+ ++count+"个实例");
        }

    }

    public synchronized void say()
    {
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("你好啊"+ ++count);
    }

    public synchronized void eat()
    {
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("好好吃");
    }

    public void two()
    {
        synchronized (this)
        {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("我是对象锁的另一种表现方式");
        }
    }
}

在主方法中进行测试

/**
 * @author 理想
 * @version 1.0
 * @date 2021/7/16 1:17
 */
public class demo01 {
    public static void main(String[] args) {
        Test01 test01 = new Test01();
        Test01 test02 = new Test01();
        /**
         * 当两个线程同时访问一个对象的时候，线程A获取到了锁，那么线程B就得等待，存在竞争关系
         */
//        new Thread(new Runnable() {
//            @Override
//            public void run() {
//                test01.say();
//            }
//        }).start();
//        new Thread(new Runnable() {
//            @Override
//            public void run() {
//                test01.say();
//            }
//        }).start();

        /**
         * 当两个线程去访问不同的对象的时候，获取的是不同的锁，不存在竞争关系
         */

//        new Thread(new Runnable() {
//            @Override
//            public void run() {
//                test01.say();
//            }
//        }).start();
//        new Thread(new Runnable() {
//            @Override
//            public void run() {
//                test02.say();
//            }
//        }).start();

        /**
         * 当两个线程同时访问同一个对象里面的不同加锁方法，由于当前的锁是以对象为锁，那么就存在竞争关系
         * 比如说这里 非静态的的say和eat方法都加了synchronized，都是同一个对象的锁，要么say先执行，eat等待，要么执行eat的线程先抢到锁，执行say的
         * 线程等待
         */
//        new Thread(new Runnable() {
//            @Override
//            public void run() {
//                test01.say();
//            }
//        }).start();
//        new Thread(new Runnable() {
//            @Override
//            public void run() {
//                test01.eat();
//            }
//        }).start();

        /**
         * 对象锁实际上也可以用synchronized (this)来，这样的效果实际上是一样的，只是写法不一样,同样也需要竞争
         */
        new Thread(new Runnable() {
            @Override
            public void run() {
                test01.two();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                test01.two();
            }
        }).start();


    }
}

类锁

类锁的意思就是以当前类对象为锁，以类本身为锁，类锁就很有意思了，锁住自己的东西，静态方法，静态代码快，public static synchronized 返回值类型 方法名,这本身就可以是个类锁，就不用过多解释了，但是你也可以作用非静态代码块上，代码可以像下面这么写，但是我也不知道这么写的意义是什么。
public void sleep02()
{
synchronized (Test02.class)
{
…
}
}
这个方法还是属于每个对象的，但是当一个对象在使用的时候，其他对象却无法使用这个方法，不知道这种模式的应用在哪。

/**
 * @author 理想
 * @version 1.0
 * @date 2021/7/16 1:41
 */
public class Test02 {

    /**
     * 第一种表现方式
     */
    public  static synchronized void sleep()
    {
        System.out.println("我是类的锁");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 作用在静态代码块
     */

    static {
        synchronized (Test02.class)
        {

        }
    }

    /**
     * 第二种类锁的表现方式
     */
    public void  sleep02()
    {
        /**
         * 作用在非静态代码快
         */
        synchronized (Test02.class)
        {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"来了");
        }
    }
}

在主方法中测试

/**
 * @author 理想
 * @version 1.0
 * @date 2021/7/16 1:42
 */
public class demo02 {
    public static void main(String[] args) {
        Test02 test01 = new Test02();
        Test02 test02 = new Test02();

        /**
         * 对于类锁而言，锁的是属于类的东西，如静态代码块，静态方法
         */
//        new Thread(new Runnable() {
//            @Override
//            public void run() {
//                Test02.sleep();
//            }
//        }).start();
//        new Thread(new Runnable() {
//            @Override
//            public void run() {
//                Test02.sleep();
//            }
//        }).start();

        /**
         * 使用类锁，锁住某个非静态方法中的代码块，这样的话，不同的线程去访问不同对象的同一方法也会竞争锁对象
         */
        new Thread(new Runnable() {
            @Override
            public void run() {
                test01.sleep02();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                test02.sleep02();
            }
        }).start();


    }
}

引用锁

引用锁就是说在类中创建一个任意类型的引用，假如说你创建一个静态的，那么这个引用属于类本身，使用这个引用加锁，就相当于使用类加锁的效果，假如你创建一个非静态的引用，那么这个引用属于实例，每个实例都有，那么使用这个引用加锁，就相当于使用对象锁加锁的效果。测试代码如下


/**
 * @author 理想
 * @version 1.0
 * @date 2021/7/16 2:05
 */
public class Test03 {

        /**
         * 引用锁
         */
        //一个普通的
        Object object=new Object();
        //一个静态的
        static Object object_static=new Object();

        public void happy()
        {
            /**
             * 这是一个普通的成员变量，与锁对象中的this起的作用差不多
             */
            synchronized (object)
            {

                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"非静态变量");
            }
        }

        public void mad()
        {
            /***
             * 静态变量，属于类，与 类.class差不多
             */
            synchronized (object_static)
            {

                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"静态变量");
            }

        }
}

测试类如下

/**
 * @author 理想
 * @version 1.0
 * @date 2021/7/16 2:05
 */
public class demo03 {
    public static void main(String[] args) {
        Test03 test01 = new Test03();
        Test03 test02 = new Test03();

        /**
         * 两个线程去访问两个对象的被非静态引用锁加锁的happy方法，不存在竞争关系
         */
//        new Thread(new Runnable() {
//            @Override
//            public void run() {
//                test01.happy();
//            }
//        }).start();
//        new Thread(new Runnable() {
//            @Override
//            public void run() {
//                test02.happy();
//            }
//        }).start();
/**
 * 两个线程都去访问被静态引用锁加锁的mad，竞争一个锁，存在竞争关系
 */

        new Thread(new Runnable() {
            @Override
            public void run() {
                test01.mad();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                test02.mad();
            }
        }).start();
    }

}

在本中的代码都是根据代码的输出先后，间隔时间来判断是否产生了竞争

这就是我对几种加锁的理解，如有错误，欢迎指出，感激不尽 ！

你是理想
关注
  • 3
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Java多线程--锁对象
吴晓如
06-04 426
前面总结了多个线程访问同一个对象的同步方法以同步执行，多个线程访问多个对象的同步方法则以异步方式执行，那如果多个线程分别访问一个对象中同步方法和非同步方法会如何执行那？ Demo： MyObject类（包含了一个同步方法和一个非同步方法）： public class MyObject { synchronized public void methodA(){ ...
Java多线程----java 对象锁
热门推荐
ymeng_bupt的专栏
09-27 3万+
在并发环境下，解决共享资源冲突问题时，可以考虑使用锁机制。 1. 对象锁       所有对象都自动含有单一的锁。      JVM负责跟踪对象被加锁的次数。如果一个对象被解锁，其计数变为0。在任务（线程）第一次给对象加锁的时候，计数变为1。每当这个相同的任务（线程）在
java加类锁
最新发布
weixin_29802189的博客
07-01 34
Java中的类锁 在Java中，我们可以使用类锁（Class Lock）来保护对类的静态成员变量和静态方法的访问。类锁是由Java虚拟机（JVM）自动维护的，它会确保在同一时刻只有一个线程可以访问被锁定的类。 什么是类锁? 类锁是在类级别上加锁，它是在类的Class对象上实现的。当一个线程获取了一个类的锁时，其他线程必须等...
java多线程关于“对象锁”的理解
weixin_30300225的博客
11-13 147
本文参考转载自：http://jasshine.iteye.com/blog/1617813 关于对象锁，其实这个对象指的是拥有synchronized修饰的函数，或者是代码块的一个类的实例。 当某个线程访问该类的方法或synchronized修饰的代码快时，就获得该对象的锁，其他线程就无法获得该对象的锁，也就是说这个对象已经被前一个线程所占用，另外的线程无法得到该对象，所以该对象对应的方法也就...
JAVA--对象锁
weixin_34378969的博客
07-23 106
在并发环境下，解决共享资源冲突问题时，可以考虑使用锁机制。 1.对象的锁 所有对象都自动含有单一的锁。 JVM负责跟踪对象被加锁的次数。如果一个对象被解锁，其计数变为0。在任务（线程）第一次给对象加锁的时候，计数变为1。每当这个相同的任务（线程）在此对象上获得锁时，计数会递增。 只有首先获得锁的任务（线程）才能继续获取该对象上的多个锁。 每当任务离开一个synchronized方法，计数...
多线程（14）对象锁和类锁
qq_43012298的博客
03-27 1216
对象锁（Instance Lock）和类锁（Class Lock）是在Java中用于线程同步的两种机制，它们是用来解决多线程中的并发问题，确保线程安全的重要手段。本文将详细探讨这两种锁的概念、作用、实现方式以及它们在实际编程中的应用。
Android多线程之同步锁的使用
08-29
Android多线程之同步锁的使用 Android多线程之同步锁的使用是Android应用程序开发中非常重要的一部分。多线程编程可以提高应用程序的性能和响应速度，但是它也带来了线程安全的问题。同步锁是解决线程安全问题的...
多线程中互斥锁和临界区锁编码及特点
03-11
### 多线程中互斥锁与临界区锁的编码及特点 #### 一、引言 在并发编程中，为了避免多个线程同时访问共享资源导致的数据不一致问题，通常会采用同步机制来保障数据的安全性。其中，互斥锁（Mutex）和临界区...
Java线程使用同步锁交替执行打印奇数偶数的方法
08-26
在 Java 中，多线程编程是非常重要的一部分，特别是在需要并发执行多个任务时。然而，在多线程编程中，如何保证线程执行结果的一致性是非常重要的。本文主要介绍了 Java 线程使用同步锁交替执行打印奇数偶数的方法。...
委托+事件+多线程+排他锁的c#例子
12-13
在C#编程中，委托和事件是实现多线程通信的关键机制，而多线程则为应用程序提供了并行处理的能力，提升系统效率。排他锁（Mutex）则用于线程同步，确保对共享资源的互斥访问。王杨可能是这个示例代码的作者或讲解者...
浅谈对java中锁的理解
08-31
一个类可以有多个实例对象，因此一个类的对象锁可能会有多个，但是每个类只有一个Class对象，所以类锁只有一个。 三、synchronized块 synchronized块包含两个部分：锁对象的引用，以及这个锁保护的代码块。如果作用...
Java对象锁和类锁全面解析（多线程synchronized关键字）
weixin_30512043的博客
06-17 859
最近工作有用到一些多线程的东西，之前吧，有用到synchronized同步块，不过是别人怎么用就跟着用，并没有搞清楚锁的概念。最近也是遇到一些问题，不搞清楚锁的概念，很容易碰壁，甚至有些时候自己连用没用对都不知道。 今天把一些疑惑都解开了，写篇文章分享给大家，文章还算比较全面。当然可能有小宝鸽理解得不够深入透彻的地方，如果说得不正确还望指出。 看之前有必要跟某些猿友说一下，...
多线程中的锁
qq_66292058的博客
03-13 1338
在了解什么是锁之前，我们先来看一下这样一段代码//创建变量i//我们创建两个线程,分别让i自增10000次j < 10000;j++) {i++;});j < 10000;j++) {i++;});t1.start();t2.start();try {//等待两个线程执行完成t2.join();t1.join();//打印i的值按照正常的逻辑，两个线程都让i自增了10000次，i最终的结果应该是20000才对，但事实真是如此吗？我们来看一下代码的运行结果。
JAVA多线程之synchronized，对象锁，类锁
搬砖大力猿的博客
07-22 426
JAVA内置锁：java内置锁的两种体现就是对象锁和类锁，java内置锁是一个互斥锁，同时只能被一个线程拿到，线程进入同步方法时自动获取内置锁，退出方法时，释放内置锁。当一个线程A拿到内置锁，其他线程只能等待A执行完毕释放锁，才能有机会获取内置锁进入同步方法。         对象锁：对象锁是用于对象实例方法，或者一个对象实例上的，每个对象实例只有一把锁，且各个对象实例的锁互不干扰。     
java中的锁——对象锁、类锁
A_BCDEF_的博客
04-29 664
对象锁（方法锁） 针对一个对象实例，只锁住当前的对象。在该对象的某个内存位置声明一个标识，说明该对象是否拥有锁。 synchronized修饰普通方法,即为对象锁 synchronized修饰的代码块传入this也属于对象锁 //对象锁的两种形式 public synchronized void fun() {} synchronized (obj) { ... } ...
多线程： 锁对象和条件对象
lahhass的博客
02-28 397
锁对象 用ReentrantLock保护代码块基本结构： public class Bank { private Lock bankLock = new ReentrantLock(); ... public void transfer(int from, int to, int amount) { bankLock.lock(); try { ... } finally ...
关于多线程的对象锁 synchronized 面试题 对象锁总结
qq_45858803的博客
12-21 127
面试题为：线程t2调用doother方式是否需要线程t1释放对象myClass的对象锁之后才能执行； 答案：不需要，因为doother方法根本就没有使用关键字synchronized修饰，也就是说我们调用这个方法根本就不需要对象锁。 具体实现请看下面的代码。 package sybchro; public class O1 { public static void main(String[] args) { MyClass myClass = new MyClass();
C#只能lock 引用类型的值 （转载）
11-20 200
Lock: C#只能lock 引用类型的值，如果lock一个int, bool，编译器会报错。 当一个互斥锁已被占用时，在同一线程中执行的代码仍可以获取和释放该锁。但是，在其他线程中执行的代码在该锁被释放前是无法获得它的。 建议不要使用锁定对象类型之种方法来同步对静态数据的访问。您无权控制的其他代码可能也会锁定您的类类型。这可能导致死锁。因此，请使用锁定私有静态...
Java多线程 之 类锁与对象锁
稚枭天卓
04-06 584
对象锁 java的所有对象都含有1个互斥锁，这个锁由JVM自动获取和释放。线程进入synchronized方法的时候获取该对象的锁，当然如果已经有线程获取了这个对象的锁，那么当前线程会等待；synchronized方法正常返回或者抛异常而终止，JVM会自动释放对象锁。这里也体现了用synchronized来加锁的1个好处，方法抛异常的时候，锁仍然可以由JVM来自动释放。 类锁 对象锁是用来控制
Java面向对象编程：理解线程同步与锁机制
- 包含`package`声明，顶级要素通常包括类定义、包引用，以及可能的注释和导入语句。 7. **类与实例示例** - 如`Student`、`Teacher`、`Customer`和`Seller`类，分别代表学生、教师、客户和售货员，分布在`myapp....
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值