synchronized锁的是什么？

最新推荐文章于 2024-04-27 09:13:51 发布
最新推荐文章于 2024-04-27 09:13:51 发布
阅读量4.4k 收藏 45
点赞数 19
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57434877/article/details/123790279
版权

文章目录

1.synchronized是什么

synchronized是java里的一个关键字，可以用来给对象和方法或者代码块加锁，当它锁定一个方法或者代码块的时候，同一时刻最多只有一条线程执行这段代码

synchronized修饰的对象：

  • 修饰方法，被修饰的方法被称为同步方法
  • 修饰代码块，被修饰的代码块被称为同步代码块

2.synchronized锁的是什么

未加锁状态下线程执行：

// 未加锁的普通方法测试
public class TestMethod {
    public static void main(String[] args) {
        Date date = new Date();
        
        // 开启一个A线程执行 fun1() 方法
        new Thread(()->{
            try {
                date.fun1();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();

		// 主线程休眠1秒
        Thread.sleep(1000);

        // 开启一个B线程执行 fun2() 方法
        new Thread(()->{
            try {
                date.fun2();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"B").start();
    }
}
class Date{
    // 未加synchronized修饰
    public void fun1() throws InterruptedException {
        // 延迟3秒后继续运行
        Thread.sleep(3000);
        System.out.println("fun1......");
    }
    // 未加synchronized修饰
    public void fun2() throws InterruptedException {
        // 直接运行
        System.out.println("fun2......");
    }
}

执行结果：
在这里插入图片描述
显而易见，fun2()由于没有延迟3秒，于是fun2()先打印

1、修饰普通方法

1.1、两个普通方法都加锁

当锁的是普通方法（非静态方法）时，锁的是方法的调用者，也就是下面代码中date这个对象

// 两个普通方法都加锁的测试
public class TestMethod2 {
    public static void main(String[] args) {
        Date2 date = new Date2();

        // 开启一个A线程执行 fun1() 方法
        new Thread(()->{
            try {
                date.fun1();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();

		// 主线程休眠1秒
        Thread.sleep(1000);

        // 开启一个B线程执行 fun2() 方法
        new Thread(()->{
            try {
                date.fun2();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"B").start();
    }
}
class Date2{
    // 加synchronized修饰
    public synchronized void fun1() throws InterruptedException {
        // 延迟3秒后继续运行
        Thread.sleep(3000);
        System.out.println("fun1......");
    }
    // 加synchronized修饰
    public synchronized void fun2() throws InterruptedException {
        // 直接运行
        System.out.println("fun2......");
    }
}

执行结果：
在这里插入图片描述
从结果可以看出，由于锁的是方法的调用者，也就是date这个对象，所以A线程先来执行fun1()方法的时候锁定date，导致属于date里面的fun2()方法也被锁定，B线程必须等A线程执行完fun1()方法之后，A线程释放锁，B线程才能重新锁定date，并执行date里的fun2()方法

1.2、一个普通方法加锁，一个普通方法未加锁

普通方法加锁，锁的是调用者，而不加锁的普通方法执行是不需要锁的

// 一个普通方法加锁，一个普通方法未加锁的测试
public class TestMethod2 {
    public static void main(String[] args) throws InterruptedException {
        Date2 date = new Date2();

        // 开启一个A线程执行 fun1() 方法
        new Thread(()->{
            try {
                date.fun1();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();
        
        // 主线程休眠1秒
        Thread.sleep(1000);

        // 开启一个B线程执行 fun2() 方法
        new Thread(()->{
            try {
                date.fun2();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"B").start();
    }
}
class Date2{
    // 加synchronized修饰
    public synchronized void fun1() throws InterruptedException {
        // 延迟3秒后继续运行
        Thread.sleep(3000);
        System.out.println("fun1......");
    }
    // 普通方法
    public  void fun2() throws InterruptedException {
        // 直接运行
        System.out.println("fun2......");
    }
}

执行结果：
在这里插入图片描述
从结果来看是fun2()先输出，这是因为fun1()有线程同步，所以fun1()的执行需要锁定date这个对象，而fun2()不是线程同步的，所以fun2()的执行不需要锁定对象就能执行，所以fun2()的执行不需要等fun1()释放锁住的对象，所以fun2()先输出

1.3、两个对象分别执行两个都加锁的普通方法

两个不同的对象，锁的是方法的调用者，所以两个对象分别执行两个普通方法的话，互不干扰

// 两个对象分别执行两个都加锁的普通方法的测试
public class TestMethod2 {
    public static void main(String[] args) throws InterruptedException {
        Date2 date1 = new Date2();
        Date2 date2 = new Date2();

        // 开启一个A线程执行 fun1() 方法
        new Thread(()->{
            try {
                date1.fun1();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();
        
        // 主线程休眠1秒
        Thread.sleep(1000);

        // 开启一个B线程执行 fun2() 方法
        new Thread(()->{
            try {
                date2.fun2();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"B").start();
    }
}
class Date2{
    // 加synchronized修饰
    public synchronized void fun1() throws InterruptedException {
        // 延迟3秒后继续运行
        Thread.sleep(3000);
        System.out.println("fun1......");
    }
    // 加synchronized修饰
    public  synchronized void fun2() throws InterruptedException {
        // 直接运行
        System.out.println("fun2......");
    }
}

执行结果：
在这里插入图片描述
从结果看出，fun2()先输出，因为当date1执行fun1()方法的时候，锁的是date1，date2执行fun2()的时候，锁的是date2，锁的是两个不同的对象，不存在竞争，所以fun2()先输出

2、修饰静态方法

2.1、两个对象分别执行两个都加锁的静态方法

静态方法锁定的是类，不是对象，所以不管多少个对象锁的都是一个类

// 两个对象分别执行两个都加锁的静态方法的测试
public class TestMethod2 {
    public static void main(String[] args) throws InterruptedException {
        Date2 date1 = new Date2();
        Date2 date2 = new Date2();

        // 开启一个A线程执行 fun1() 方法
        new Thread(()->{
            try {
                date1.fun1();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();
        
        // 主线程休眠1秒
        Thread.sleep(1000);

        // 开启一个B线程执行 fun2() 方法
        new Thread(()->{
            try {
                date2.fun2();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"B").start();
    }
}
class Date2{
    // 加synchronized修饰的静态方法
    public synchronized static void fun1() throws InterruptedException {
        // 延迟3秒后继续运行
        Thread.sleep(3000);
        System.out.println("fun1......");
    }
    // 加synchronized修饰的静态方法
    public  synchronized static void fun2() throws InterruptedException {
        // 直接运行
        System.out.println("fun2......");
    }
}

执行结果：
在这里插入图片描述
从结果来看，fun1()先输出，因为静态方法锁的是类，而类只有一个，所以fun2()需要等待fun1()执行完后释放锁，fun2()才能执行

2.2、两个对象分别执行一个加锁、一个未加锁的静态方法

静态方法加锁锁定的是类，而fun2()未加锁，不需要锁定类就能直接执行

// 两个对象分别执行一个加锁、一个未加锁的静态方法的测试
public class TestMethod2 {
    public static void main(String[] args) throws InterruptedException {
        Date2 date1 = new Date2();
        Date2 date2 = new Date2();

        // 开启一个A线程执行 fun1() 方法
        new Thread(()->{
            try {
                date1.fun1();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();
        
        // 主线程休眠1秒
        Thread.sleep(1000);

        // 开启一个B线程执行 fun2() 方法
        new Thread(()->{
            try {
                date2.fun2();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"B").start();
    }
}
class Date2{
    // 加synchronized修饰
    public synchronized static void fun1() throws InterruptedException {
        // 延迟3秒后继续运行
        Thread.sleep(3000);
        System.out.println("fun1......");
    }
    // 未加synchronized修饰的静态方法
    public  static void fun2() throws InterruptedException {
        // 直接运行
        System.out.println("fun2......");
    }
}

执行结果：
在这里插入图片描述
从结果来看，fun2先输出，这是因为fun1执行的时候锁的是类，而fun2没有加锁，所以fun2无需锁定就可以进行直接执行，也就是说fun2()无需等待fun1()释放锁资源，所以fun2()先输出

3、修饰代码块

未加锁的状态下的测试：

// 未加锁的状态测试
public class TestCode {
    public static void main(String[] args) {
        Date3 date3 = new Date3();
        // 启动五条线程
        for (int i = 0; i < 5; i++) {
            new Thread(()->{
                try {
                    date3.fun();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}
class Date3 {
	// 未加锁的状态
    public void fun() throws InterruptedException {
        System.out.println("start......");
        // 休眠1秒
        Thread.sleep(1000);
        System.out.println("end......");
    }
}

执行结果：
在这里插入图片描述
从结果看出，正常情况下，在五条线程执行完start…的时候都会停下等待1秒，然后全部执行完
修饰代码块，锁定的是传入的对象

3.1、代码块加锁，传入this

当加锁的代码块传入的是this的时候，锁的也是方法的调用者，也就是date3这个对象

// 代码块加锁，传入this的测试
public class TestCode {
    public static void main(String[] args) {
        Date3 date3 = new Date3();
        // 启动五条线程
        for (int i = 0; i < 5; i++) {
            new Thread(()->{
                try {
                    date3.fun();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}
class Date3 {
    public void fun() throws InterruptedException {
        // 代码块加锁，传入this
        synchronized (this) {
            System.out.println("start......");
            // 休眠1秒
            Thread.sleep(1000);
            System.out.println("end......");
        }

    }
}

执行结果：
在这里插入图片描述
从结果来看，是排队输出的，因为传入的是this，所以锁的是date3这个对象，所以每个线程在执行的时候都在等待上一个线程释放对象（锁），这个线程才能继续执行

3.2、代码块加锁，传入this，五个不同对象

代码块加锁，传入this，锁的方法的调用者，由于是五个不同的对象，所以互不干扰

// 代码块加锁，传入this，五个不同对象的测试
public class TestCode {
    public static void main(String[] args) {
        // 启动五条线程
        for (int i = 0; i < 5; i++) {
        	// 每次循环创建一个新的对象
            Date3 date3 = new Date3();
            new Thread(()->{
                try {
                    date3.fun();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}
class Date3 {
    public void fun() throws InterruptedException {
        // 代码块加锁，传入this
        synchronized (this) {
            System.out.println("start......");
            // 休眠1秒
            Thread.sleep(1000);
            System.out.println("end......");
        }

    }
}

执行结果：
在这里插入图片描述
从结果来看，五个线程基本是一起输出的，因为，代码块加锁，传入this，锁的是方法的调用者，所以五个线程之间互不干扰，一起输出

3.3、代码块加锁，传入类（.class），五个不同对象

代码块加锁，当传入的是类（.class） 的时候，锁定的自然就是类了

// 代码块加锁，传入类（.class），五个不同对象的测试
public class TestCode {
    public static void main(String[] args) {
        // 启动五条线程
        for (int i = 0; i < 5; i++) {
            Date3 date3 = new Date3();
            new Thread(()->{
                try {
                    date3.fun();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}
class Date3 {
    public void fun() throws InterruptedException {
        // 代码块加锁，传入类（.class）
        synchronized (Date3.class) {
            System.out.println("start......");
            // 休眠1秒
            Thread.sleep(1000);
            System.out.println("end......");
        }

    }
}

执行结果：
在这里插入图片描述
从结果来看，线程是一条一条排队输出的，因为当代码块锁中传入的是类的时候，锁定的就是类，而类只有一个，所以即使是不同的对象，也必须等待锁的释放

3.4、代码块加锁，传入Integer的对象，五个不同对象

Integer有一个特殊之处，当直接定义Integer而不用构造器，Integer的值是在-128~127之间的情况下，Integer其实都是存在常量池的，所以即使看起来是五个不同的对象那个，但其实是同一个对象

// 代码块加锁，传入Integer的对象，五个不同对象的测试
public class TestCode {
    public static void main(String[] args) {
        // 启动五条线程
        for (int i = 0; i < 5; i++) {
            Date3 date3 = new Date3();
            new Thread(()->{
                try {
                    date3.fun();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}
class Date3 {
    public void fun() throws InterruptedException {
        // 代码块加锁，传入普通Integer的对象
        Integer num = 1;
        synchronized (num) {
            System.out.println("start......");
            // 休眠1秒
            Thread.sleep(1000);
            System.out.println("end......");
        }

    }
}

执行结果：
在这里插入图片描述
从结果来看，线程依然是排队输出的，这是因为即使看起来是五条线程中每次都回生成一个新的Integer对象，但是Integer有一个特殊之处，当直接定义Integer而不用构造器，Integer的值是在-128~127之间的情况下，Integer其实都是存在常量池的，所以即使看起来是五个不同的对象那个，但其实是同一个对象。测试的方法也很简单，只需把Integer num = 1;换成Integer num = new Integer(1);或者Integer num = 128就可以看出区别

注意：即使在同步代码块里加一句num++;锁的依然是同一个对象，需要排队

好好玩_tyrant
关注
  • 19
    点赞
  • 踩
  • 45
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第5 章 Consul服务注册与发现
a13763926743的博客
04-22 767
consul官网地址。
第16讲 synchronized底层如何实现？什么是锁的升级、降级？1
08-03
所谓锁的升级、降级，就是 JVM 优化 synchronized 运行的机制，当 JVM 检测到不同的竞争状况时，会自动切换到适合的锁实现，这种切换就是锁的升级
第16讲synchronized底层如何实现？什么是锁...1
08-03
极客时间 | Java核心技术36讲所谓锁的升级、降级，就是 JVM 优化 synchronized 运行的机制，当 JVM 检测到不同的竞争状况时，会自动切换
JAVA Synchronized对象锁和类锁区别（牛逼）
pengweid专栏
03-22 9527
一个类就像一个四合院，四合院的大门叫做构造方法，盖房子必须经过大门，每new一个对象，就表示在四合院里再盖一间新房子，大门上面的锁，叫做构造锁，里面每一间房子就是一个实例，每间房子里边都有一个锁叫做实例锁。 四合院里有厕所，水龙头，洗衣机等等都是公共设施，都叫做static资源）你想获得洗衣机，就需要调用static的洗衣机方法，也就是行为） 假如一天来了3个人租房子，第一个人租了一间小房子，那...
synchronized到底锁住的是谁？
jushisi的博客
11-25 1402
本文代码仓库：https://github.com/yu-linfeng/BlogRepositories/tree/master/repositories/sync synchronized从语法的维度一共有3个用法： 1、静态方法加上关键字 2、实例方法（也就是普通方法）加上关键字 3、方法中使用同步代码块 前两种方式最为偷懒，第三种方式比前两种性能要好。 synchronized从锁的...
Java并发——Synchronized关键字和锁升级，详细分析偏向锁和轻量级锁的升级
qq_36777191的博客
02-02 228
目录 一、Synchronized使用场景 二、Synchronized实现原理 三、锁的优化 1、锁升级 2、锁粗化 3、锁消除 一、Synchronized使用场景 Synchronized是一个同步关键字，在某些多线程场景下，如果不进行同步会导致数据不安全，而Synchronized关键字就是用于代码同步。什么情况下会数据不安全呢，要满足两个条件：一是数据共享（临界资源），二是多线程同时访问并改变该数据。 例如： public class AccountingSync imple
synchronized详解
zhilianxian2212的博客
10-26 563
synchronized原理详解以及锁的升级过程
【线程】synchronized锁的是什么
Elephant_King的博客
02-07 2611
1.synchronized作用于成员变量和非静态方法时，锁住的是对象的实力，即this对象 2.synchronized作用于静态方法时，锁住的是Class实例 3.synchronized作用于一个代码块时，锁住的是所有代码块中配置的对象 ...
Java的synchronized锁的到底是什么？
笨鸟贤妃的博客
05-22 647
synchronized被大大小小的程序员广泛使用，有的程序员偷懒，在要求保证线程安全时，不加思索的就在方法前加入了synchronized关键字（例如我刚才那道校招级大题）。偷懒归偷懒，CodeReview总是要进行的，面对同事的“指责”，要求优化这个方法，将synchronized使用同步代码块的方式提高效率。 synchronized要按照同步代码块来保证线程安全，这可就加在方法“复杂”多了。有：synchronized(this){}这么写的，也有synchronized(Count.class)
Synchronized同步锁
qq_49194786的博客
09-08 1696
有关synchronized同步锁的介绍！
synchronized锁
qq_61353850的博客
03-19 5514
1、synchronize锁的修饰的是方法和块 2、synchronize锁修饰静态方法就是类锁；修饰非静态方法就是对象锁。 3、类锁：是如果有N个静态的方法被synchronize修饰，有一个线程执行其中一个加锁的静态方法，那么其他的线程就无法继续调用这个类中的其他的加锁的静态方法，直到这个静态方法被执行完，其他加锁静态方法才可以被执行。不加锁的方法是不受影响的。 4、对象锁：在java中，类中定义一个非静态的方法，如果需要在其他类中使用这个方法，我们就要在其他类中，new一个新的对象。对象锁的意义
Java并发 synchronized锁住的内容解析
08-25
主要介绍了Java并发 synchronized锁住的内容解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
synchronized枷锁实例
07-05
基于Synchronized加锁的四个demo，主要反映类锁、对象锁、方法锁的使用方法。 并测试不同类型锁之间的有效关系。
Java Synchronized锁失败案例及解决方案
08-19
主要介绍了Java Synchronized锁失败案例及解决方案,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 368
都是符合我们的预期的。
java方法重写（重点讲），方法重载
最新发布
weixin_46281068的博客
04-27 434
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
string模拟实现
m0_73969414的博客
04-23 1462
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 625
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
Synchronized用过吗？其原理是什么？
03-30
Synchronized的原理是通过Java中的内置锁（也称为监视器锁）来实现线程同步。当一个线程进入Synchronized块时，它会尝试获取内置锁。如果内置锁已经被其他线程占用，该线程将被阻塞，直到内置锁被释放。只有获取到...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值