七、Synchronized锁

已于 2024-03-18 22:03:58 修改
阅读量108 收藏
点赞数 1
分类专栏： # 多线程 文章标签： java jvm 开发语言
于 2022-12-02 00:08:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45905724/article/details/128140562
版权

目录

Synchronized锁

synchronized有三种写法：

一、synchronized类锁

二、synchronized对象锁

Synchronized锁

synchronized锁是jvm内置的锁，不同于ReentrantLock锁。

  • synchronized关键字可以修饰方法，
    • synchronized关键字修饰方法时可以修饰静态方法
    • 也可以修饰非静态方法
  • synchronized关键字可以修饰代码块。
    • synchronized关键字修饰代码块时可以修饰对象
    • synchronized关键字修饰代码块时可以修饰类

synchronized有三种写法：

  • 同步代码块，灵活     synchronized (ClassLock2.class)类上锁

        synchronized(线程共享对象){
                    同步代码块;
                }

  • 在实例方法上使用synchronized表示共享对象一定是this，并且同步代码块是整个方法体。  
  • 在静态方法上使用synchronized表示找类锁。类锁永远只有1把。

synchronized修饰静态方法/类和非静态方法/对象时的作用范围是不同的

一、synchronized类锁

这里所说的synchronized类锁的作用范围是类级别的，不会因为同一个类的不同对象执行而失效。

1. synchronized修饰同一个类的两个静态方法时类锁生效

package com.tde.demo.synchroized;

import java.util.Date;
import java.util.concurrent.TimeUnit;

public class SynchronizeAndClassLock {
    public static void main(String[] args) throws Exception {
        new Thread(() -> {
            // new了一个ClassLock对象
            new ClassLock().test1();
        }).start();

        new Thread(() -> {
            // new了另一个ClassLock对象
            new ClassLock().test2();
        }).start();
    }

}
class ClassLock {
    public synchronized static void test1(){
        System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {}
        System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
    }
    // 【注意】public static void test2(){ 不会互斥，因为此时test2没有使用类锁。
    public synchronized static void test2(){
        System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {}
        System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
    }
}

【运行结果】： 

【结论】两个线程分别同时执行同一个类产生的不同对象的两个不同 synchronized static方法，类锁生效，虽然是不同对象，因为两个线程使用的是同一个类锁。反过来，假如test2方法没有synchronized修饰的话，只有test1方法有被synchronized修饰，此时两个方法也不会互斥，一个有锁，一个没有锁，自然不会互斥。

2. synchronized分别修饰同一个类的静态方法和当前类时类锁生效

package com.tde.demo.synchroized;

import java.util.Date;
import java.util.concurrent.TimeUnit;

public class SynchronizeAndClassLock2 {
    public static void main(String[] args) throws Exception {
        new Thread(() -> {
            // new了一个ClassLock2对象
            new ClassLock2().test1();
            // ClassLock2.test1();
        }).start();

        new Thread(() -> {
            // new了另一个ClassLock2对象
            new ClassLock2().test2();
            // ClassLock2.test2();
        }).start();
    }

}
class ClassLock2 {
    public synchronized static void test1(){
        System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {}
        System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
    }

    public static void test2(){
        // 【注意】synchronized (SynchronizeAndClassLock2.class)不会互斥锁其他类不会互斥
        synchronized (ClassLock2.class) {
            System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {}
            System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
        }
    }
}

【运行结果】：

 【结论】两个线程同时分别执行一个被synchronized修饰static方法，一个有synchnized(该类)代码块的static方法，锁生效，虽然是不同对象，因为两个线程使用的同一个类锁。反过来，如果是修饰的不同类，因为类锁不同，肯定不会被锁住，比如将test2方法的synchronized (ClassLock2.class)这句代码改成synchronized (SynchronizeAndClassLock2.class),此时不会被锁住。

3. synchronized分别修饰同一个静态对象时类锁生效

package com.tde.demo.synchroized;

import java.util.Date;
import java.util.concurrent.TimeUnit;

public class SynchronizeAndClassLock3 {

    public static void main(String[] args) throws Exception {
        new Thread(() -> {
            new RunObject1().test1();
        }).start();

        new Thread(() -> {
            new RunObject2().test2();
        }).start();
    }
}

class RunObject1 {
    public static void test1(){
        // 【1】synchronized (StaticLock2.staticLock1) {
        synchronized (StaticLock2.staticLock) {
            System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {}
            System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
        }
    }
}


class RunObject2 {
    public static void test2() {
        // 【2】synchronized (StaticLock2.staticLock2) {
        synchronized (StaticLock2.staticLock) {
            System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {}
            System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
        }
    }
}

class StaticLock2 {
    public static Object staticLock = new Object();
}

【运行结果】

【结论】synchronized分别修饰同一个类的静态对象时类锁生效,反过来，如果是修饰不同的静态对象，肯定不会生效，比如将上面代码中标【1】和【2】的synchronized代码结合使用。

二、synchronized对象锁

synchronized对象锁的作用范围是对象级别的即仅仅作用于同一个对象，如果是同一个类的两个不同的对象是不会生效的，即没有效果的。

1. synchronized修饰同一个类对象的两个非静态方法时锁生效

package com.tde.demo.synchroized;

import java.util.Date;
import java.util.concurrent.TimeUnit;

public class SynchronizeAndObjectLock {
    public static void main(String[] args) throws Exception {
        // 【注意】当且仅当是同一个SynchronizeAndObjectLock对象
        SynchronizeAndObjectLock synchronizeAndObjectLock = new SynchronizeAndObjectLock();
        new Thread(() -> {
            synchronizeAndObjectLock.test1();
        }).start();

        new Thread(() -> {
            synchronizeAndObjectLock.test2();
        }).start();
    }
    public synchronized void test1(){
        System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {}
        System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
    }

    public synchronized void test2(){
        System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {}
        System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
    }
}

【运行结果:】

 【结论:】两个线程同时执行被synchronized修饰的相同对象的不同（相同）方法，锁生效，因为两个线程使用的是相同的对象锁

2. synchronized分别修饰同一个类对象的非静态方法和当前对象时互斥

package com.tde.demo.synchroized;

import java.util.Date;
import java.util.concurrent.TimeUnit;

public class SynchronizeAndObjectLock2 {
    public static void main(String[] args) throws Exception {
        // 【注意】当且仅当是同一个SynchronizeAndObjectLock2对象
        SynchronizeAndObjectLock2 synchronizeAndObjectLock2 = new SynchronizeAndObjectLock2();
        new Thread(() -> {
            synchronizeAndObjectLock2.test1();
        }).start();

        new Thread(() -> {
            synchronizeAndObjectLock2.test2();
        }).start();
    }
    public void test1(){
        synchronized(this) {  //对象
            System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {}
            System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
        }

    }

    public synchronized void test2(){   //方法
        System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {}
        System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
    }
}

【运行结果：】 

【结论：】synchronized修饰非静态方法与synchronized(this)互斥，可见，snchronized修饰非静态方法实质锁的是当前对象。

 3. synchronized代码块修饰同一个对象时互斥

package com.tde.demo.synchroized;

import java.util.Date;
import java.util.concurrent.TimeUnit;

public class SynchronizeAndObjectLock3 {
    private Object objectLock = new Object();

    public static void main(String[] args) throws Exception {

        SynchronizeAndObjectLock3 synchronizeAndObjectLock3 = new SynchronizeAndObjectLock3();
        new Thread(() -> {
            synchronizeAndObjectLock3.test1();
        }).start();

        new Thread(() -> {
            synchronizeAndObjectLock3.test2();
        }).start();
    }
    public void test1(){
        synchronized(objectLock) {
            System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {}
            System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
        }

    }

    public void test2(){
        synchronized(objectLock) {
            System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {}
            System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
        }
    }
}

【运行结果：】 

【结论：】 synchronized代码块修饰同一个对象时互斥（锁生效），若synchronized代码块修饰的是不同对象，那么不会互斥

小问题 ： 如果在synchronized对象上锁的，在多线程并发的进行中，有new了一个对象这种情况就会导致线程不安全问题，需要使用final修饰不让对象发生改变

package com.tde.demo;

import java.util.concurrent.TimeUnit;

public class demo {
    public static void main(String[] args) {
        new demo().m1();
    }


     void m1(){
        System.out.println("m1开始");
        try {
            TimeUnit.SECONDS.sleep(1);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        m2();
        System.out.println("m1结束");
    }


     void m2(){
        System.out.println("m2开始");
        try {
            TimeUnit.SECONDS.sleep(2);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

synchronized 必须是可重入锁（一个锁里面在包含另外一个锁） ，如果不是很容易引起死锁 ，如上 其实锁的还是同一个对象

  1. synchronized锁住的是括号里的对象,而不是代码。
  2. 对于非static的synchronized方法,锁的就是对象本身也就是this。
  3. 对于static的方法、对象是锁的是类本身

小节

  1. synchronized 存在类锁与对象锁 
  2. 给修饰静态方法、对象等等静态数据上锁相当于给类上锁
  3. synchronized（this）相当于给对象上锁
  4. 类锁和对象锁是相互独立的，互不相斥
  5. synchronized锁不能被中断
  6. 唤醒/等待需要synchronized锁 （否则抛出IllegalMonitorStateException）

使用synchronized锁时，为了尽可能提高性能，我们应该尽量缩小锁的范围。能不锁方法就不锁方法，推荐尽量使用synchronized代码块来降低锁的范围


public <T> ServerBootstrap childOption(ChannelOption<T> childOption, T value) {
    if (childOption == null) {
        throw new NullPointerException("childOption");
    }
    if (value == null) {
        synchronized (childOptions) {
            childOptions.remove(childOption);
        }
    } else {
        synchronized (childOptions) {
            childOptions.put(childOption, value);
        }
    }
    return this;
}

小涂学编程
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
14.线程的同步机制-synchronized同步方法-局部变量为线程安全.mp4
04-06
在学习Java过程中，自己收集了很多的Java的学习资料，分享给大家，有需要的欢迎下载，希望对大家有用，一起学习，一起进步。
Java中synchronized正确使用方法解析
08-25
例如，在使用 synchronized void addOne() 方法时，锁可以保证在多线程环境下，共享资源的访问安全性。 六、happen before 原则 happen before 原则是指在多线程环境下，一个线程对共享资源的修改对其他线程的可见...
Synchronized锁详解(全网最细)
最新发布
Anakki的博客
04-17 2233
正常来说a获取到锁后b不能获取锁，但是当一个实例内的a方法和b方法都是用一把锁上锁时，同一个线程访问a和b就需要重入的能力，比如在a方法中访问b方法，那么a的锁x已经被抢占了，如果不支持重入，那么访问b的时候会发现x锁已经被自己抢占而无法访问，支持重入的原理也就是在这里判断一下当前方法的锁是否是本线程拥有的锁。所以锁消除可以节省毫无意义的请求锁的时间。JVM在JDK1.6后会有几种状态，线程获取对象时，分别会判断对象锁的状态，以此来决定线程是否进入阻塞，或者获取到锁对象执行代码块，或者自旋等接下来的动作。
并发编程（二）synchronized锁
CodingAnHour
07-15 241
前言 多线程编程中，有可能会出现多个线程同时访问同一个共享、可变资源的情况， 这个资源称之其为临界资源；这种资源可能是：对象、变量、文件等。 共享：资源可以由多个线程同时访问 可变：资源可以在其生命周期内被修改 由于线程执行的过程是不可控的，所以需要采用同步机制来协同对对象可变状态的访问 所有的并发模式在解决线程安全问题时，采用的方案都是序列化（有序）访问临界资源。即在同一时刻，只能有一个线程访问临界资源，也称作同步互斥访问。 当多个线程执行一个方法时，该方法内部的局部变量并不是临界资源，因为这些局部变
锁与同步
Franklins_Fan的博客
07-07 242
前几种保证线程安全的方式： 思想 缺陷 避免共享 不能用全局rep共享数据 只共享只读类型 只能“读”共享数据，不能写 使用线程安全类型 可以共享 “读写”，但只有单一方法是安全的，多个方法调用就不安全了 可以看出，这些方式都有很大的局限性，很多时候，无法满足上述三个条件。 常见的情况是要读写共享数据，且线程中的 读写操作复杂。 这时候，我们就要使用 同步和锁的方式，通过“同步” 策略，负责多线程之间对mutable数据的共享操作，同时避免多线程同时访问数据。 使用锁机制，获得对
一文搞懂Synchronized同步锁的作用范围
热门推荐
想着百万年薪努力的小赵
07-18 1万+
我们对一个方法，这种执行方式很明显会影响程序的性能，那么如何做好安全性及性能的平衡呢？实际上，Synchronized关键字只需保护可能存在线程安全问题的代码，因此，我们可以通过控制同步锁的作用范围来实现这个平衡机制。在Synchronized中，提供两种锁，一是类锁，二是对象锁。...
Java实习生面试复习(七)：synchronized和ReentrantLock的学习
12-21
在性能方面，`synchronized`在JDK 1.6及以后的版本中通过优化（如锁膨胀、锁粗化等）已经与`ReentrantLock`相差不大，但在某些特定场景下，如需要更精细的控制或者更高的性能，`ReentrantLock`可能更有优势。...
七周七并发英文版
08-02
读者会学习到原子操作、内存模型以及Java中的synchronized关键字或C++的std::mutex等工具的使用。 第三周可能涉及线程池和任务调度。线程池是一种优化资源管理和性能的有效手段，它减少了创建和销毁线程的开销。...
Java课件第七章.ppt
09-28
- `java.util.concurrent`包中的工具类，如`Semaphore`（信号量），`CyclicBarrier`（回环栅栏），`CountDownLatch`（倒计时锁）等，提供了更高级的同步和协调机制。 在实际编程中，理解和熟练运用这些线程相关知识...
七周七并发高清版附送惊喜书籍
12-14
Java作为企业级应用的首选语言，其并发特性强大且全面，包括线程、锁、同步机制、并发集合等。 《七周七并发》的每一部分都会针对一个特定的并发主题进行深入讲解，比如： 1. **线程基础**：介绍线程的创建、管理...
（十三）synchronized用法、底层原理，附四种锁范围详细例子
HaC 的博客
07-26 3066
《深入理解Java虚拟机》一句话： 当多个线程访问同一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替运行，也不需要进行额外的同步，或者在调用方进行任何其他的协调操作，调用这个对象的行为都可以获取正确的结果，那这个对象是线程安全的。 1. 开篇 内存分为主内存和工作内存，每个线程都有自己的工作内存，如何和主内存的数据同步，产生的数据不一致性，就是我们常说的线程安全，这就需要我们去了解Java内存模型了。 借用一张图： 如图为JMM抽象示意图，线程A和线程B之间要完成通信的话，要经历如下两步：
synchronized关键字
weixin_41992498的博客
06-17 187
多线程问题应该是多个线程对方法里面用到的变量（全局变量和局部变量）的访问出现的问题 使用synchronized关键字，可以修饰方法和代码块
synchronized修饰函数和封装变量的对象两处需要注意的地方
lsh3958411的专栏
05-29 1589
今天学习synchronizedgu
多线程synchronized关键字与局部变量，全局变量，静态变量
yugege5201314的博客
12-18 1646
问题描述： 观察局部变量，全局变量，静态变量在单线程和多线程环境下的不同表现，为多线程编程提供思路。 我们看一个简单例子，它的业务可以理解成售票功能。有一个静态变量记录总票数。 public class MultiThread { //我的电脑，这个值为4 private static final int core = Runtime.getRuntime().availableProcessors(); //线程池 ExecutorService es = Executors.n
java进阶之synchronized锁
weixin_44517209的博客
06-12 849
java多线程基础学习
Java进阶：多线程、synchronized锁
璃白的博客
04-21 1051
多线程、锁多线程下数据安全问题线程安全问题解决方案死锁守护线程定时器 多线程下数据安全问题 多线程并发环境下，数据的安全问题（重点） 存在安全问题的三个条件： 1.多线程并发 2.有共享数据 3.共享数据有修改的行为 满足以上3个条件之后，就会存在线程安全问题。 解决方法：线程同步机制，让线程排队执行。 线程同步机制的语法是： synchronized (){ // 线程同步代码块 } synchronized () 括号中传的数据必须是多线程共享的数据。 synchronized出现在实例方法上
Java多线程初学者指南（12）：使用Synchronized块同步变量
小菜的粉丝——专栏
09-08 723
我们可以通过synchronized块来同步特定的静态或非静态方法。要想实现这种需求必须为这些特性的方法定义一个类变量，然后将这些方法的代码用synchronized块括起来，并将这个类变量作为参数传入synchronized块。下面的代码演示了如何同步特定的类方法：  001  package mythread;  002    003  public class SyncT
使用synchronized块同步变量
Friedy星期五的博客
05-29 5058
我们可以通过synchronized块来同步特定的静态或非静态方法。要想实现这种需求必须为这些特性的方法定义一个类变量，然后将这些方法的代码用synchronized块括起来，并将这个类变量作为参数传入synchronized块。如下代码演示如何同步特定的类方法： package mythread; public class SyncThread extends Thread{ p...
Synchronized底层实现：从青铜到王者的同步之旅
7. 不可中断特性：讨论了synchronized锁在中断线程时的处理机制，确保线程安全的同时避免不必要的阻塞。 四、尊贵铂金 8. Monitor监视器锁：深入剖析了Java虚拟机中监视器锁的工作原理，包括monitor竞争、等待和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值