synchronized

最新推荐文章于 2022-07-13 17:47:05 发布
最新推荐文章于 2022-07-13 17:47:05 发布
阅读量128 收藏
点赞数
分类专栏： JVM 多线程 java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yinianxx/article/details/106216457
版权
多线程 同时被 3 个专栏收录
8 篇文章 0 订阅
订阅专栏
java基础
8 篇文章 0 订阅
订阅专栏
JVM
2 篇文章 0 订阅
订阅专栏

简单总结

  • synchronized(this|object)以及synchronized修饰非静态方法是对象锁
  • synchronized(类.class)以及修饰静态方法是类锁。
  • 同一个类的不同对象的对象锁不是一把锁
  • 同一个类的同一对象的对象锁，同一个类的同一对象的类锁以及同一个类的不同对象的类锁，分别是同一把锁。
  • 类锁和对象锁是独立的，互不干扰。
  • 判断方法间是否是同步的，关键是判断获取的是否是同一把锁！

概念

synchronized是java的关键字，是利用锁的机制来实现同步的

对象锁和类锁

  • 对象锁
    在java中，每个对象都有一个monitor对象，这个对象是java对象的锁。
    类的对象有多个，每个对象都有其独立的对象锁，互不干扰。
  • 类锁
    在java中，每个类也有一个锁，成为”类锁“，类锁实际上是通过对象锁实现的，即类的Class对象锁。
    每个类只有一个class对象，也就只有一个类锁。

用法

  • 修饰代码块
    synchronized(object){} //对象锁
    synchronized(xxx.class){} //类锁
  • 修饰方法
    非静态方法 //对象锁
    静态方法 //类锁

具体例子

对象锁
比较不加锁，锁住同步代码块，锁住非静态方法的区别。
对于同一个对象
具体代码

import java.util.Date;

public class Main {
    public static void main(String[] args) {
        //同一个对象
        Test test = new Test();
        Thread threada1 = new Thread(test,"A1");
        Thread threada2 = new Thread(test,"A2");
        Thread threadb1 = new Thread(test,"B1");
        Thread threadb2 = new Thread(test,"B2");
        Thread threadc1 = new Thread(test,"C1");
        Thread threadc2 = new Thread(test,"C2");
        threada1.start();
        threada2.start();
        threadb1.start();
        threadb2.start();
        threadc1.start();
        threadc2.start();
    }

}
class Test implements Runnable{

    @Override
    public void run() {
        String threadName = Thread.currentThread().getName();
        if(threadName.startsWith("A")){
            async();
        }else if(threadName.startsWith("B")){
            sync1();
        }else if(threadName.startsWith("C")){
            sync2();
        }
    }

    private synchronized void sync2() {
        //修饰非静态方法
        System.out.println(Thread.currentThread().getName()+ "sync2："+new Date());

            try {
                System.out.println(Thread.currentThread().getName()+" sync2_start: "+ new Date());
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName()+" sync2_end: "+ new Date());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

    }

    private void sync1() {
        //使用同步代码块 synchronized(this)
        System.out.println(Thread.currentThread().getName()+ "sync1："+new Date());
        synchronized (this){
            try {
                System.out.println(Thread.currentThread().getName()+" sync1_start: "+ new Date());
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName()+" sync1_end: "+ new Date());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private void async() {
        //异步方法
        try {
            System.out.println(Thread.currentThread().getName()+" async_start: "+ new Date());
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName()+" async_end: "+ new Date());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果
在这里插入图片描述
结果分析：

  • 没有同步代码块，则该代码块是异步的，有线程在访问对象的同步代码块时，其他线程可以访问该对象的非同步代码块。所以在C线程的结果之间插入了A线程的执行结果。
  • 锁住同步代码块时（synchronized(this)）,同步代码块内的内容时同步的，代码块外的内容是异步的，所以B类线程代码块外代码的执行结果和代码块内的执行结果之间插入了其他线程的执行结果。
  • 锁住非静态方法时，方法内的所有代码都是同步的。
  • Bstart和Bend之间没有插入c类线程的执行结果，同样的C类线程的所有执行结果之间都没有插入Bstart和Bend的结果，因为获取的是同一个锁（对象锁）。

不同对象
测试方法修改为

 public static void main(String[] args) {
        //不同对象
//        Test test = new Test();
        Thread threada1 = new Thread(new Test(),"A1");
        Thread threada2 = new Thread(new Test(),"A2");
        Thread threadb1 = new Thread(new Test(),"B1");
        Thread threadb2 = new Thread(new Test(),"B2");
        Thread threadc1 = new Thread(new Test(),"C1");
        Thread threadc2 = new Thread(new Test(),"C2");
        threada1.start();
        threada2.start();
        threadb1.start();
        threadb2.start();
        threadc1.start();
        threadc2.start();
    }

运行结果
在这里插入图片描述
结果分析：
两个线程访问不同对象的synchronized(this){}代码块和synchronized修饰的非静态方法是异步的，因为获取的不是同一把锁，不同对象的对象锁互不干扰。

类锁

import java.util.Date;

public class Main {
    public static void main(String[] args) {
        //不同对象
        Test test = new Test();
//        Thread threada1 = new Thread(new Test(),"A1");
//        Thread threada2 = new Thread(new Test(),"A2");
//        Thread threadb1 = new Thread(new Test(),"B1");
//        Thread threadb2 = new Thread(new Test(),"B2");
//        Thread threadc1 = new Thread(new Test(),"C1");
//        Thread threadc2 = new Thread(new Test(),"C2");
        Thread threada1 = new Thread(test,"A1");
        Thread threada2 = new Thread(test,"A2");
        Thread threadb1 = new Thread(test,"B1");
        Thread threadb2 = new Thread(test,"B2");
        Thread threadc1 = new Thread(test,"C1");
        Thread threadc2 = new Thread(test,"C2");
        threada1.start();
        threada2.start();
        threadb1.start();
        threadb2.start();
        threadc1.start();
        threadc2.start();
    }

}
class Test implements Runnable{

    @Override
    public void run() {
        String threadName = Thread.currentThread().getName();
        if(threadName.startsWith("A")){
            async();
        }else if(threadName.startsWith("B")){
            sync1();
        }else if(threadName.startsWith("C")){
            sync2();
        }
    }

    private synchronized static void sync2() {
        //修饰非静态方法
        System.out.println(Thread.currentThread().getName()+ "sync2："+new Date());

            try {
                System.out.println(Thread.currentThread().getName()+" sync2_start: "+ new Date());
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName()+" sync2_end: "+ new Date());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

    }

    private void sync1() {
        //使用同步代码块 synchronized(this)
        System.out.println(Thread.currentThread().getName()+ "sync1："+new Date());
        synchronized (Test.class){
            try {
                System.out.println(Thread.currentThread().getName()+" sync1_start: "+ new Date());
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName()+" sync1_end: "+ new Date());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private void async() {
        //异步方法
        try {
            System.out.println(Thread.currentThread().getName()+" async_start: "+ new Date());
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName()+" async_end: "+ new Date());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果
在这里插入图片描述
结果分析：
同一个对象情况下，类锁和对象锁是一致的。

不同对象
修改测试方法

 public static void main(String[] args) {
        //不同对象
//        Test test = new Test();
        Thread threada1 = new Thread(new Test(),"A1");
        Thread threada2 = new Thread(new Test(),"A2");
        Thread threadb1 = new Thread(new Test(),"B1");
        Thread threadb2 = new Thread(new Test(),"B2");
        Thread threadc1 = new Thread(new Test(),"C1");
        Thread threadc2 = new Thread(new Test(),"C2");
        threada1.start();
        threada2.start();
        threadb1.start();
        threadb2.start();
        threadc1.start();
        threadc2.start();
    }

运行结果
在这里插入图片描述
结果分析：
两个线程访问同一个类的不同对象的synchronized(类.class){}代码块或synchronized修饰的静态方法还是同步的，和同一个对象的类锁以及同一个对象的对象锁是一致的，因为同一个类的不同对象的类锁还是同一个锁。

类中同时有对象锁和类锁
具体代码

import java.util.Date;

public class Main {
    public static void main(String[] args) {
        //不同对象
        Test test = new Test();
        Thread threadb1 = new Thread(test,"B1");
        Thread threadc1 = new Thread(test,"C1");
        threadb1.start();
        threadc1.start();
    }

}
class Test implements Runnable{

    @Override
    public void run() {
        String threadName = Thread.currentThread().getName();
        if(threadName.startsWith("B")){
            sync1();
        }else if(threadName.startsWith("C")){
            sync2();
        }
    }

    private synchronized void sync2() {
        //修饰非静态方法
        System.out.println(Thread.currentThread().getName()+ "sync2："+new Date());

            try {
                System.out.println(Thread.currentThread().getName()+" sync2_start: "+ new Date());
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName()+" sync2_end: "+ new Date());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

    }

    private synchronized static void sync1() {
        //修饰静态方法
        System.out.println(Thread.currentThread().getName()+ "sync1："+new Date());

        try {
            System.out.println(Thread.currentThread().getName()+" sync1_start: "+ new Date());
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName()+" sync1_end: "+ new Date());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }


}

运行结果
在这里插入图片描述
线程B和线程C是异步的，sychronized修饰静态方法和非静态方法是异步的，也就是说对象锁和类锁是独立的，互不干扰。

其他

  • synchronized关键字不能继承
    对于父类中synchronized修饰的方法，子类在覆盖该方法时必须显式使用synchronized关键字修饰才是同步的。
  • 定义接口方法时不能使用synchronized关键字。
  • 构造方法不能使用synchronized关键字修饰，但可以使用synchronized锁住同步代码块。

参考资料
https://juejin.im/post/594a24defe88c2006aa01f1c#heading-5

wmtmw
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
synchronized.md
02-24
关于synchronized的自学笔记
synchronized并发讲解源码.zip
03-16
在Java编程语言中，`synchronized`关键字是一个非常重要的并发控制机制，用于保证多线程环境下的数据一致性。本文将深入解析`synchronized`的工作原理、使用方式以及它在并发编程中的重要性。通过分析提供的源码，...
synchronized(xxx.class)
weixin_44412864的博客
04-20 624
synchronized(xxx.class)只能锁住类的方法，类的属性、元数据等都是没有被锁住的，可以被其他线程访问。
synchronized的用法
make2019_y的博客
03-05 383
多个线程去共享资源、一段代码可能会出现一些不能预料的问题。就比如模拟三个窗口同时售票 package com.smallchili.demo; public class CreateThread { public static void main(String[] args) { ThreadDemo2 t = new ThreadDemo2(); Thread t1 = ...
synchronized的分类和原理
a_higher的博客
06-03 473
修饰对象分类 同步方法 非静态 public synchronized void methodName(){} 静态方法 public synchronized static void methodName(){} 同步代码块 synchronized(this | object){} 获取的锁来分类 对象锁 修饰非静态方法 每个对象有个monitor对象，这个对象其实就是 ...
【多线程锁】synchronized对象锁与类锁用法
Dust_heart的博客
07-13 3872
本文主要介绍synchronized对象锁与类锁用法，入门级别使用
Java的类对象锁 synchronized(xxx.class)
rikey111的专栏
07-19 5728
Java的类对象锁 synchronized(xxx.class) 从字面上讲，只锁住了类对象，就是在方法区中表示这个类的元数据信息的类对象。通过实验验证，也确实如此。用的是sun 的jdk 1.6.24。   测试类：Test.java   TestClassMethod.java  TestObjMethod.java 在测试类中有2个方法，一个类方法，一个实例方法。 TestClas
详解java中的synchronized关键字
09-03
在Java编程语言中，`synchronized`关键字是一个重要的并发控制机制，用于确保多线程环境下的数据一致性。本文将深入探讨`synchronized`关键字的使用和功能。 首先，`synchronized`关键字可以应用于方法和代码块，以...
Java中synchronized正确使用方法解析
08-25
Java 中 synchronized 正确使用方法解析 Java 中 synchronized 关键字是解决线程安全问题的重要手段，它可以确保在多线程环境下，共享资源的访问安全性。本文将详细介绍 Java 中 synchronized 的正确使用方法，通过...
简单了解synchronized和lock的区别
08-25
了解synchronized和lock的区别 synchronized是Java语言中的一个关键字，用于线程同步，主要用于解决多线程之间的竞争问题。它可以将某个方法或代码块锁定，使得只有一个线程可以执行该方法或代码块，其他线程只能...
Java使用synchronized修饰方法来同步线程的实例演示
09-02
在Java编程语言中，synchronized关键字用于实现线程同步，以确保多线程环境下的数据一致性。它主要用于控制对共享资源的并发访问，防止多个线程同时进入临界区，可能导致数据不一致或竞态条件的问题。本文将深入探讨...
透彻理解Java中Synchronized（对象锁）和Static Synchronized（类锁）的区别
08-27
Java 中 Synchronized（对象锁）和 Static Synchronized（类锁）的区别 Synchronized 和 Static Synchronized 是 Java 中两种同步机制，它们都用于解决多线程并发访问的安全问题。然而，它们之间存在着本质的区别。...
Java关键字volatile和synchronized作用和区别
08-30
Java关键字volatile和synchronized作用和区别 Java关键字volatile和synchronized是Java语言中两个常用的关键字，它们都是用来解决多线程编程中的同步问题的，但它们的作用和用法却有所不同。 volatile关键字是变量...
你还在用Synchronized?Atomic你了解不?
08-26
Synchronized关键字是我们常见的一个同步原语，它提供了一种锁机制，确保了对共享资源的互斥访问。然而，随着Java并发库的发展，Atomic类（如AtomicInteger、AtomicLong等）逐渐成为一种更加轻量级且高效的替代方案...
volatile和synchronized的区别
04-19
### volatile与synchronized的区别 #### 一、锁的特性：互斥与可见性 在并发编程中，锁作为实现线程安全的一种手段，其核心作用在于提供两种特性：互斥和可见性。 - **互斥**：互斥是指在任何时刻，只允许一个...
synchronized详解
三分恶的博客
02-10 6361
synchronized是Java多线程中元老级的锁，也是面试的高频考点，让我们来详细了解synchronized吧。
Synchronized（对象锁）和Static Synchronized（类锁）的区别
热门推荐
cs408的博客
10-06 3万+
Synchronized和Static Synchronized区别 通过分析这两个用法的分析，我们可以理解java中锁的概念。一个是实例锁（锁在某一个实例对象上，如果该类是单例，那么该锁也具有全局锁的概念），一个是全局锁（该锁针对的是类，无论实例多少个对象，那么线程都共享该锁）。实例锁对应的就是synchronized关键字，而类锁（全局锁）对应的就是static synchroniz
Java synchronized类锁，对象锁详解(转载整理)
student100000的博客
06-16 1013
原文链接：https://www.iteye.com/blog/zhh9106-2151791 先回顾一下synchronized的用法： 1.同步代码块（对象锁） public class SynchronizedObjectLock implements Runnable { static SynchronizedObjectLock instence = new SynchronizedObjectLock(); @Override public void run() {
synchronized 类 ，对象 ，以及方法的解析
向大牛前行
01-10 1368
java中的synchronized 关键字，想必大部分人还是了解的，就是同步。主要目的是什么呢？：避免多线程共享资源的不安全。什么意思呢？因为如果存在多线程共享资源的时候，很容易出现不安全性。比如下面一段代码就是不安全的：public class ThreadTest { private int ticket = 3; private void buyTicket() {
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值