方法锁、对象锁、类锁

最新推荐文章于 2023-02-22 22:08:17 发布
最新推荐文章于 2023-02-22 22:08:17 发布
阅读量956 收藏 2
点赞数
分类专栏： java 锁同步
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013795543/article/details/83716108
版权

一、java内存模型

java内存模型规定了所有变量都存储在主内存（Main Memory）中，每个线程还有自己的工作线程（Working Memory），线程的工作内存保存了该线程使用到的变量的主内存副本拷贝，线程对变量的所有读写操作都必须在工作线程中进行，而不能直接读写主内存中的变量（这里的变量指的是实例字段、静态字段和构成数组对象的元素以及堆上的数据）。不同线程之间也无法直接访问其它线程工作内存中的变量，线程间变量值的传递都通过主内存来完成，线程、主内存、工作内存三者的交互关系如下所示：

先看一个两个线程同时操作的例子

public class SynMethodTest {
    private int a;

    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }
    public  void increaseI() {
        for (int i = 0; i < 5; i++) {
            ++a;
            System.out.print("thread1 run: a="+ a +",,thread id="+Thread.currentThread().getId()+"\n");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public static void main(String[] args) {
    SynMethodTest synMethodTest=new SynMethodTest();
    Thread thread1=new Thread(new Runnable() {
        @Override
        public void run() {
            synMethodTest.increaseI();
            System.out.print("thread1 run: end======================="+"\n");
        }
    });
    Thread thread2=new Thread(new Runnable() {
        @Override
        public void run() {
            synMethodTest.increaseI();
            System.out.print("thread2 run: end======================="+"\n");
        }
    });
    thread1.start();
    thread2.start();
}

log打印如下：

thread1 run: a=2,,thread id=11
thread1 run: a=1,,thread id=12
thread1 run: a=3,,thread id=12
thread1 run: a=3,,thread id=11
thread1 run: a=4,,thread id=12
thread1 run: a=5,,thread id=11
thread1 run: a=7,,thread id=12
thread1 run: a=6,,thread id=11
thread1 run: a=8,,thread id=11
thread1 run: a=9,,thread id=12
thread1 run: end=======================
thread2 run: end=======================

两个线程都在执行同一个对象的同一个方法导致数据变化无法预测，由于多个线程同时操作某个对象就可能导致数据不一致以及死锁等并发问题，而解决这些并发问题可以通过volatile、synchrozied等锁机制来解决。

二、方法锁、对象锁、类锁

在java中，最基本的互斥同步手段就是synchronized关键字，synchronized关键字经过编译之后，会在同步块的前后形成monitorenter和monitorexit两个字节码指令，这两个字节码指令都需要一个reference类型的参数来明确要锁定和解锁的对象。

如果java程序中的synchronized明确指定了对象参数，那就是这个对象reference；如果没有明确指定，那么就要根据synchronized修饰的是实例方法还是类方法，去取对象的对象实例或者class对象来作为reference。

1、方法锁

方法锁是在一个方法名的前面加上synchronized关键字，如

public synchronized void method(){//todo}; 

这里要分两种情况，一种情况是此方法是静态方法，另外一种情况是此方法是非静态方法。

1）如果synchronized 修饰一个非静态方法，那么调用这个非静态方法的对象实例就会被锁定，其他线程再去调用该非静态方法就会堵塞，直到对象实例被解锁，其他线程才可以访问该非静态方法。

在SynMethodTest.java的increaseI方法前加上synchronized

public synchronized void increaseI() {
    for (int i = 0; i < 5; i++) {
        ++a;
        System.out.print("thread1 run: a="+ a +",,thread id="+Thread.currentThread().getId()+"\n");
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

log打印如下

thread1 run: a=1,,thread id=11
thread1 run: a=2,,thread id=11
thread1 run: a=3,,thread id=11
thread1 run: a=4,,thread id=11
thread1 run: a=5,,thread id=11
thread1 run: end=======================
thread1 run: a=6,,thread id=12
thread1 run: a=7,,thread id=12
thread1 run: a=8,,thread id=12
thread1 run: a=9,,thread id=12
thread1 run: a=10,,thread id=12
thread2 run: end=======================

可以看出thread1 执行完后释放锁，thread2才开始执行。

此时如果在SynMethodTest.java增加一个printM方法

public  void printM() {
    System.out.print("just do a print test ,,thread id="+Thread.currentThread().getId()+"\n");
}

log打印如下：

thread1 run: a=1,,thread id=11
just do a print test ,,thread id=12
thread1 run: a=2,,thread id=11
thread1 run: a=3,,thread id=11
thread1 run: a=4,,thread id=11
thread1 run: a=5,,thread id=11
thread1 run: end=======================
thread1 run: a=6,,thread id=12
thread1 run: a=7,,thread id=12
thread1 run: a=8,,thread id=12
thread1 run: a=9,,thread id=12
thread1 run: a=10,,thread id=12
thread2 run: end=======================

如果在printM方法加上synchronized，log打印如下：

thread1 run: a=1,,thread id=11
thread1 run: a=2,,thread id=11
thread1 run: a=3,,thread id=11
thread1 run: a=4,,thread id=11
thread1 run: a=5,,thread id=11
thread1 run: end=======================
just do a print test ,,thread id=12
thread1 run: a=6,,thread id=12
thread1 run: a=7,,thread id=12
thread1 run: a=8,,thread id=12
thread1 run: a=9,,thread id=12
thread1 run: a=10,,thread id=12
thread2 run: end=======================

synchronized修饰方法时会将实例对象锁定，该对象实例不能同时执行其他被synchronized修饰的方法。

刚才说到的synchronized修饰方法时会将实例对象锁定，如果是同一个类的两个不同实例，那就相互不影响

public static void main(String[] args) {
    SynMethodTest synMethodTest=new SynMethodTest(); //实例1
    SynMethodTest synMethodTest2=new SynMethodTest(); //实例2
    Thread thread1=new Thread(new Runnable() {
        @Override
        public void run() {
            synMethodTest.increaseI();
            System.out.print("thread1 run: end======================="+"\n");
        }
    });
    Thread thread2=new Thread(new Runnable() {
        @Override
        public void run() {
            synMethodTest2.printM();
            synMethodTest2.increaseI();
            System.out.print("thread2 run: end======================="+"\n");
        }
    });
    thread1.start();
    thread2.start();
}

log打印：

thread1 run: a=1,,thread id=11
just do a print test ,,thread id=12
thread1 run: a=1,,thread id=12
thread1 run: a=2,,thread id=11
thread1 run: a=2,,thread id=12
thread1 run: a=3,,thread id=11
thread1 run: a=3,,thread id=12
thread1 run: a=4,,thread id=11
thread1 run: a=4,,thread id=12
thread1 run: a=5,,thread id=11
thread1 run: a=5,,thread id=12
thread1 run: end=======================
thread2 run: end=======================

2）如果synchronized 修饰一个静态方法，那么这个类会被锁定。

上例中可以同时执行同一个类的两个不同对象实例的同一个synchronized非静态方法，如果执行的是同一个synchronized静态方法，则就必须一次只有一个线程可以执行，另一个线程则需要等前一个线程执行完释放锁才可以开始执行。SynMethodTest 修改如下：

public class SynMethodTest {
    private static int a;

    public  int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }
    public static synchronized void increaseI() {
        for (int i = 0; i < 5; i++) {
            ++a;
            System.out.print("thread1 run: a="+ a +",,thread id="+Thread.currentThread().getId()+"\n");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
 public synchronized void printM() {
        System.out.print("just do a print test ,,thread id="+Thread.currentThread().getId()+"\n");
    }
}

log打印如下：

thread1 run: a=1,,thread id=11
just do a print test ,,thread id=12
thread1 run: a=2,,thread id=11
thread1 run: a=3,,thread id=11
thread1 run: a=4,,thread id=11
thread1 run: a=5,,thread id=11
thread1 run: end=======================
thread1 run: a=6,,thread id=12
thread1 run: a=7,,thread id=12
thread1 run: a=8,,thread id=12
thread1 run: a=9,,thread id=12
thread1 run: a=10,,thread id=12
thread2 run: end=======================

可以看出同一个synchronized 静态方法不能同时被两个线程执行，但是synchronized 非静态printM方法却可以执行，如果此时将printM方法也改为静态的呢

public static synchronized void printM() {
    System.out.print("just do a print test ,,thread id="+Thread.currentThread().getId()+"\n");
}

log打印如下：

thread1 run: a=1,,thread id=11
thread1 run: a=2,,thread id=11
thread1 run: a=3,,thread id=11
thread1 run: a=4,,thread id=11
thread1 run: a=5,,thread id=11
thread1 run: end=======================
just do a print test ,,thread id=12
thread1 run: a=6,,thread id=12
thread1 run: a=7,,thread id=12
thread1 run: a=8,,thread id=12
thread1 run: a=9,,thread id=12
thread1 run: a=10,,thread id=12
thread2 run: end=======================

可以看出一个类中一次只能执行一个synchronized 静态方法。

3）与方法锁类似的情况是用另外一个对象实例去锁住一个方法中的代码块，他与方法锁的区别是方法锁锁住的是方法所在对象实例，而代码块中的对象实例可以是任意一个不想关的对象实例。

 

2、对象锁

对象锁修饰的是一个对象实例，下面三个锁是等价的

public synchronized void method()  //锁定的是对象实例
{
   // todo
}
public void method()
{
   synchronized(this) {   //锁定的是对象实例
      // todo
   }
}
synchronized (synMethodTest){  //锁定的是对象实例
    synMethodTest.increaseI();
    System.out.print("thread1 run: end======================="+"\n");
}

如果将SynMethodTest.java中的方法去掉synchronized 关键字，将synchronized 移到调用实例方法的地方

public class SynMethodTest {
    private  int a;

    public  int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }
    public  void increaseI() {
        for (int i = 0; i < 5; i++) {
            ++a;
            System.out.print("thread1 run: a="+ a +",,thread id="+Thread.currentThread().getId()+"\n");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public  synchronized void printM() {
        System.out.print("just do a print test ,,thread id="+Thread.currentThread().getId()+"\n");
    }

}
public static void main(String[] args) {
    SynMethodTest synMethodTest=new SynMethodTest();
    SynMethodTest synMethodTest2=new SynMethodTest();
    Thread thread1=new Thread(new Runnable() {
        @Override
        public void run() {
            synchronized (synMethodTest){
                synMethodTest.increaseI();
                System.out.print("thread1 run: end======================="+"\n");
            }
        }
    });
    Thread thread2=new Thread(new Runnable() {
        @Override
        public void run() {
            synchronized (synMethodTest) {
                synMethodTest2.printM();
                synMethodTest2.increaseI();
                System.out.print("thread2 run: end=======================" + "\n");
            }
        }
    });
    thread1.start();
    thread2.start();
}

log打印如下：

thread1 run: a=1,,thread id=11
thread1 run: a=2,,thread id=11
thread1 run: a=3,,thread id=11
thread1 run: a=4,,thread id=11
thread1 run: a=5,,thread id=11
thread1 run: end=======================
just do a print test ,,thread id=12
thread1 run: a=1,,thread id=12
thread1 run: a=2,,thread id=12
thread1 run: a=3,,thread id=12
thread1 run: a=4,,thread id=12
thread1 run: a=5,,thread id=12
thread2 run: end=======================

3、类锁

类锁锁定的是一个类或者一个静态方法，如静态方法锁中所述类锁定后类的不同对象实例也不能执行同一个被synchronized 修饰的方法。

参考文献：https://blog.csdn.net/luoweifu/article/details/46613015

https://www.cnblogs.com/edwardru/articles/6030686.html

爱炒饭
关注
专栏目录
Synchronized方法锁、对象锁、类锁区别
weixin_30642305的博客
06-09 815
synchronized关键字，我们一般称之为”同步锁“，用它来修饰需要同步的方法和需要同步代码块，默认是当前对象作为锁的对象。在修饰类时（或者修饰静态方法），默认是当前类的Class对象作为所的对象故存在着方法锁、对象锁、类锁 这样的概念 一.Synchronized方法锁（也叫对象锁） 1.修饰在方法上，多个线程调用同一个对象的同步方法会阻塞，调用不同对象的同步方法不会阻塞。（j...
synchronized 方法锁 对象锁 类锁
dycy的博客
09-27 1564
synchronized 方法锁 对象锁 类锁方法锁对象锁类锁 方法锁 synchronized修饰方法时 每个类的实例类的实例对应一把锁（方法锁也是对象锁） 执行synchronized修饰的方法必须拥有实例对象的锁 方法一旦执行，就会独占该锁，方法执行完毕，会释放该锁 其他没获得锁的线程处于阻塞状态 不加synchronized： 对象锁 synchronized修饰对象或代码块 java的每个对象都有一个互斥锁，线程运行synchronized修饰的方法或代码块时都要获得这个对象的锁 没
方法锁、对象锁和类锁区别
qq_35181209的博客
05-22 5974
引言：结合synchronized进行分析。 synchronized用来处理多个线程同时访问同一个类的一个代码块、方法，甚至这个类。 （1）修饰代码块时，需要一个reference对象作为锁的对象。 （2）修饰方法时，默认是当前对线作为锁的对象。 （3）修饰类时，默认是当前类的Class对象作为锁的对象。 1、对象锁 当一个对象中有同步方法或者同步块，线程调用此对象进入该同步区域
多线程学习之类锁、对象锁、方法锁
最新发布
weixin_50348837的博客
02-22 687
在Java中，对于synchronized关键字，大家看到的第一反应就是这个关键字是进行同步操作的，即得名“同步锁”。当用它来修饰方法和代码块时，默认当前的对象为锁的对象，即对象锁。当用来修饰类和静态方法时，默认当前的类为锁的对象所以，方法锁既可以是类锁，又可以是对象锁。主要就是看他修饰的静态方法还是非静态方法。对象锁修饰在方法上时，多个线程调用同一对象的同步方法时会阻塞，调用不同对象的同步方法时不会阻塞。可以看出，两个线程在调用不同对象的同步方法时，并未发生阻塞。
java synchronized关键字的用法以及锁的等级：方法锁、对象锁、类锁
forLove
09-21 2936
转载自：http://blog.csdn.net/le_le_name/article/details/52348314 java的内置锁：每个java对象都可以用做一个实现同步的锁，这些锁成为内置锁。线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法。   java内置锁是一个互斥锁，
详解java 对象锁与类锁
09-07
Java中的对象锁与类锁是多线程编程中非常重要的概念，它们用于控制并发访问，确保数据的一致性和完整性。本文将深入探讨这两种锁的原理、形式及应用场景。 一、对象锁（方法锁） 对象锁，又称为实例锁，是针对特定...
Java对象锁和类锁全面解析（多线程synchronize
11-22
Java对象锁和类锁是Java多线程编程中至关重要的概念，它们是通过`synchronized`关键字来实现的，用于确保代码在并发环境下的线程安全。在这个全面解析中，我们将深入探讨这两个锁机制，理解它们的工作原理以及如何在...
透彻理解Java中Synchronized（对象锁）和Static Synchronized（类锁）的区别
08-27
Java 中 Synchronized（对象锁）和 Static Synchronized（类锁）的区别 Synchronized 和 Static Synchronized 是 Java 中两种同步机制，它们都用于解决多线程并发访问的安全问题。然而，它们之间存在着本质的区别。...
java 方法锁 对象锁_Java的类锁、对象锁和方法锁
weixin_42525551的博客
02-12 281
在Java中，对于synchronized关键字，大家看到的第一反应就是这个关键字是进行同步操作的，即得名“同步锁”。当用它来修饰方法和代码块时，默认当前的对象为锁的对象，即对象锁。当用来修饰类和静态方法时，默认当前的类为锁的对象对象锁修饰在方法上时，多个线程调用同一对象的同步方法时会阻塞，调用不同对象的同步方法时不会阻塞。在多线程环境下，调用不同对象的同步方法：public class Sync...
方法锁、对象锁、类锁区别
qq_37260235的博客
10-16 556
方法锁： 方法锁是对象锁的一种： 代码：四个窗口售票。每个窗口卖4张，一个窗口卖完下一个在卖 /** * 对象锁，方发锁，类锁 * * @author my * */ public class ObjectLock { public synchronized void sellTickets() { //方发锁，对象锁的一种 int n = 4; while(n&gt...
方法锁 对象锁 类锁
七月听雪的博客
02-15 137
对象锁，方法锁，类锁区别总结
qq_45680802的博客
02-17 1445
文章目录对象锁，方法锁，类锁区别总结内置锁对象锁(synchronized修饰方法或代码块)类锁(synchronized 修饰静态的方法或代码块)对象锁与类锁的对比对象锁（与类锁前两点对应）类锁 对象锁，方法锁，类锁区别总结 此小结主要是针对本人对单利设计模式的补充总结，所以有不全面的地方请谅解 内置锁 每个对象都可作为一个实现同步的锁，这些锁就是内置锁 内置锁是一个互斥锁，当A线程（第一个...
对象锁和方法锁
yiqzq的博客
02-20 440
对象锁和方法锁 文章目录对象锁和方法锁 主要内容可以归纳为以下的表格 修饰形式 修饰分类 锁住的对象 代码实例 同步方法 非静态方法 类的实例对象 public synchronized void method(){} 同步方法 静态方法 类对象 public static synchronized void method(){} 同步代码块 实例对象 类的实例对象 syn...
方法锁，对象锁，类锁的区别和用法
热门推荐
qq_38872310的博客
04-13 2万+
在java编程中，经常需要用到同步，而用得最多的也许是synchronized关键字了，下面看看这个关键字的用法。 因为synchronized关键字涉及到锁的概念，所以先来了解一些相关的锁知识。   java的内置锁：每个java对象都可以用做一个实现同步的锁，这些锁成为内置锁。线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途
Java类锁、对象锁、私有锁冲突分析与测试
"Java类锁、对象锁、私有锁冲突测试主要探讨了这三种锁在并发编程中的竞争关系，确保同一时刻只有一个方法能够执行。本文通过实例代码展示了类锁、对象锁和私有锁的概念，并进行了冲突测试，旨在帮助开发者理解和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值