synchronized锁的是什么

最新推荐文章于 2024-04-17 03:55:13 发布
最新推荐文章于 2024-04-17 03:55:13 发布
阅读量1.5k 收藏 2
点赞数
文章标签： class 安卓 proxy 面向对象编程 asp.net
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_38032942/article/details/111158544
版权

最近发现synchronized锁的是什么？甚至有人认为synchronized锁的是代码？？！这个我觉得还是很有必要通过实际的示例来说明synchronized锁的到底是什么。

根据获取的锁的分类：获取对象锁和获取类锁！

获取对象锁的两种用法

1、同步代码块(synchronized(this), synchronized(类实例对象))，锁是小括号()中的实例对象。
2、同步非静态方法(synchronized method)，锁是当前对象的实例对象。

获取类锁的两种用法

1、同步代码块(synchronized(类.class))，锁是小括号()中的类对象，即Class对象。
2、同步静态方法(synchronized static method)，锁是当前对象的类对象(Class对象)。

对象锁示例

看看这样一段代码：

SynchronizedDemo.java

package thread_study.synchronize;

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

public class SynchronizedDemo implements Runnable{

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

    private void async() {
        try {
            System.out.println(Thread.currentThread().getName()
            + "_Async_Start:" 
            + new SimpleDateFormat("mm:ss").format(new Date()));
            
            TimeUnit.SECONDS.sleep(1);
            
            System.out.println(Thread.currentThread().getName() 
            + "_Async_End:" 
            + new SimpleDateFormat("mm:ss").format(new Date()));
            
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    private synchronized void syncObjectMethod() {
        System.out.println(Thread.currentThread().getName() 
        + "_SyncObjectMethod:" 
        + new SimpleDateFormat("mm:ss").format(new Date()));
        
        try {
            System.out.println(Thread.currentThread().getName() 
            + "_SyncObjectMethod_Start:" 
            + new SimpleDateFormat("mm:ss").format(new Date()));
            
            TimeUnit.SECONDS.sleep(1);
            
            System.out.println(Thread.currentThread().getName() 
            + "_SyncObjectMethod_End:" 
            + new SimpleDateFormat("mm:ss").format(new Date()));
            
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void syncObjectBlock() {
        System.out.println(Thread.currentThread().getName() 
        + "_SyncObjectBlock:" 
        + new SimpleDateFormat("mm:ss").format(new Date()));
        synchronized (this){
            try {
                System.out.println(Thread.currentThread().getName() 
                + "_SyncObjectBlock_Start:" 
                + new SimpleDateFormat("mm:ss").format(new Date()));
                
                TimeUnit.SECONDS.sleep(1);
                
                System.out.println(Thread.currentThread().getName() 
                + "_SyncObjectBlock_End:" 
                + new SimpleDateFormat("mm:ss").format(new Date()));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

SynchronizedMain.java

package thread_study.synchronize;

public class SynchronizedMain {
    public static void main(String[] args) {
        SynchronizedDemo demo = new SynchronizedDemo();
        Thread A_thread1 = new Thread(demo, "A_thread1");
        Thread A_thread2 = new Thread(demo, "A_thread2");
        Thread B_thread1 = new Thread(demo, "B_thread1");
        Thread B_thread2 = new Thread(demo, "B_thread2");
        Thread C_thread1 = new Thread(demo, "C_thread1");
        Thread C_thread2 = new Thread(demo, "C_thread2");
        A_thread1.start();
        A_thread2.start();

        B_thread1.start();
        B_thread2.start();

        C_thread1.start();
        C_thread2.start();
    }
}

mark

但是如果我们传入不同的对象呢？

package thread_study.synchronize;

public class SynchronizedMain {
    public static void main(String[] args) {
        //SynchronizedDemo demo = new SynchronizedDemo();
        Thread A_thread1 = new Thread(new SynchronizedDemo(), "A_thread1");
        Thread A_thread2 = new Thread(new SynchronizedDemo(), "A_thread2");
        Thread B_thread1 = new Thread(new SynchronizedDemo(), "B_thread1");
        Thread B_thread2 = new Thread(new SynchronizedDemo(), "B_thread2");
        Thread C_thread1 = new Thread(new SynchronizedDemo(), "C_thread1");
        Thread C_thread2 = new Thread(new SynchronizedDemo(), "C_thread2");
        A_thread1.start();
        A_thread2.start();

        B_thread1.start();
        B_thread2.start();

        C_thread1.start();
        C_thread2.start();
    }
}

mark

从上面的代码和结果中我们可以得出一个结论，那就是

获取对象锁的两种用法：
1、同步代码块(synchronized(this), synchronized(类实例对象))，锁是小括号()中的实例对象。
2、同步非静态方法(synchronized method)，锁是当前对象的实例对象。

同步非静态方法锁住整个方法，而同步代码块只是锁住的只是方法中的一部分代码

获取类锁的两种用法
1、同步代码块(synchronized(类.class))，锁是小括号()中的类对象，即Class对象。
2、同步静态方法(synchronized static method)，锁是当前对象的类对象(Class对象)。

同步静态方法锁住整个方法，而同步代码块只是锁住的只是方法中的一部分代码，与上面一样的

类锁示例

下面来看看同步静态方法和同步代码块(synchronized(类.class))的效果吧：

package thread_study.synchronize;

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

public class SynchronizedDemo implements Runnable{

    @Override
    public void run() {
        String threadName = Thread.currentThread().getName();
        if(threadName.startsWith("A")){
            async();
        }else if(threadName.startsWith("B")){
            syncObjectBlock();
        }else if(threadName.startsWith("C")){
            syncObjectMethod();
        }else if(threadName.startsWith("D")){
            syncClassBlock();
        }else if(threadName.startsWith("E")){
            syncClassMethod();
        }
    }

    private synchronized static void syncClassMethod() {
        System.out.println(Thread.currentThread().getName()
                           + "_SyncClassMethod:"
                           + new SimpleDateFormat("mm:ss").format(new Date()));
        try {
            System.out.println(Thread.currentThread().getName()
                               + "_SyncClassMethod_Start:"
                               + new SimpleDateFormat("mm:ss").format(new Date()));
            TimeUnit.SECONDS.sleep(1);
            System.out.println(Thread.currentThread().getName()
                               + "_SyncClassMethod_End:"
                               + new SimpleDateFormat("mm:ss").format(new Date()));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void syncClassBlock() {
        System.out.println(Thread.currentThread().getName()
                           + "_SyncClassBlock:" 
                           + new SimpleDateFormat("mm:ss").format(new Date()));
        synchronized (SynchronizedDemo.class){
            try {
                System.out.println(Thread.currentThread().getName()
                                   + "_SyncClassBlock_Start:"
                                   + new SimpleDateFormat("mm:ss").format(new Date()));
                TimeUnit.SECONDS.sleep(1);
                System.out.println(Thread.currentThread().getName()
                                   + "_SyncClassBlock_End:" 
                                   + new SimpleDateFormat("mm:ss").format(new Date()));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private void async() {
        try {
            System.out.println(Thread.currentThread().getName() 
                               + "_Async_Start:" 
                               + new SimpleDateFormat("mm:ss").format(new Date()));
            TimeUnit.SECONDS.sleep(1);
            System.out.println(Thread.currentThread().getName() 
                               + "_Async_End:" 
                               + new SimpleDateFormat("mm:ss").format(new Date()));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //...和上面一样的
}

SynchronizedMain.java

package thread_study.synchronize;

public class SynchronizedMain {
    public static void main(String[] args) {
        Thread A_thread1 = new Thread(new SynchronizedDemo(), "A_thread1");
        Thread A_thread2 = new Thread(new SynchronizedDemo(), "A_thread2");
        Thread D_thread1 = new Thread(new SynchronizedDemo(), "D_thread1");
        Thread D_thread2 = new Thread(new SynchronizedDemo(), "D_thread2");
        Thread E_thread1 = new Thread(new SynchronizedDemo(), "E_thread1");
        Thread E_thread2 = new Thread(new SynchronizedDemo(), "E_thread2");

        A_thread1.start();
        A_thread2.start();

        D_thread1.start();
        D_thread2.start();
        E_thread1.start();
        E_thread2.start();
    }
}

mark

对象锁和类锁不会干扰

最后看看类锁和对象锁是否会相互影响呢？

修改一下代码：

package thread_study.synchronize;

public class SynchronizedMain {
    public static void main(String[] args) {
        //SynchronizedDemo demo = new SynchronizedDemo();
        Thread A_thread1 = new Thread(new SynchronizedDemo(), "A_thread1");
        Thread A_thread2 = new Thread(new SynchronizedDemo(), "A_thread2");
        Thread B_thread1 = new Thread(new SynchronizedDemo(), "B_thread1");
        Thread B_thread2 = new Thread(new SynchronizedDemo(), "B_thread2");
        Thread C_thread1 = new Thread(new SynchronizedDemo(), "C_thread1");
        Thread C_thread2 = new Thread(new SynchronizedDemo(), "C_thread2");
        Thread D_thread1 = new Thread(new SynchronizedDemo(), "D_thread1");
        Thread D_thread2 = new Thread(new SynchronizedDemo(), "D_thread2");
        Thread E_thread1 = new Thread(new SynchronizedDemo(), "E_thread1");
        Thread E_thread2 = new Thread(new SynchronizedDemo(), "E_thread2");

        A_thread1.start();
        A_thread2.start();

        B_thread1.start();
        B_thread2.start();
        C_thread1.start();
        C_thread2.start();

        D_thread1.start();
        D_thread2.start();
        E_thread1.start();
        E_thread2.start();
    }
}

mark

可以看出来，类锁和对象锁是不会相互干扰的！

赏

谢谢你请我喝咖啡

支付宝
微信
「已注销」
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
synchronized锁住的是代码还是对象
菩提小猿的博客
02-26 1435
1.synchronized作用 在Java中，synchronized关键字是用来控制线程同步的。在多线程的环境下，控制synchronized代码段不被多个线程同时执行。 2.synchronized用法 synchronized既可以加在一段代码上，也可以加在方法上。 3.对象锁和全局锁区别 对象锁：synchronized(this)以及非static的synchronized方法。锁的...
Java synchronized-锁的概念
记录成长的过程
02-15 185
synchronized的用法 1.修饰实例方法，作用于当前实例加锁，进入同步代码前要获得当前实例的锁 2.修饰静态方法，作用于当前类对象的锁，进入同步代码前要获得当前类对象的锁 3.修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码块之前要获得给定对象的锁 关于锁 .锁是什么？ 锁是处理并发的一种同步手段。Java提供的加锁方法就是synchronized关键字。 .为什么任何...
Synchronized锁详解(全网最细)
Anakki的博客
04-17 2092
正常来说a获取到锁后b不能获取锁，但是当一个实例内的a方法和b方法都是用一把锁上锁时，同一个线程访问a和b就需要重入的能力，比如在a方法中访问b方法，那么a的锁x已经被抢占了，如果不支持重入，那么访问b的时候会发现x锁已经被自己抢占而无法访问，支持重入的原理也就是在这里判断一下当前方法的锁是否是本线程拥有的锁。所以锁消除可以节省毫无意义的请求锁的时间。JVM在JDK1.6后会有几种状态，线程获取对象时，分别会判断对象锁的状态，以此来决定线程是否进入阻塞，或者获取到锁对象执行代码块，或者自旋等接下来的动作。
Synchronized锁详解
lixiangchibang的博客
07-31 4713
Synchronized锁详解
Java内部锁（synchronized）中类锁和对象锁
冷血之心的博客
08-29 5688
关于对象锁、类锁以及锁争用情况的简单介绍
synchronized对象锁，锁的是什么？
Canon
08-27 8447
昨天看博客看到这样一段代码，说是看似线程安全，但实际上并不是，参考大佬一个看似线程安全的示例： class ListHelper <E> { public List<E> list = Collections.synchronizedList(new ArrayList<E>()); public synchronized bo...
Java并发 synchronized锁住的内容解析
08-25
Java并发synchronized锁住的内容解析 Java并发synchronized锁住的内容解析是Java并发编程中的一种重要机制，用于解决多线程并发访问同一个资源时可能出现的线程安全问题。通过使用synchronized关键字，可以锁住当前...
synchronized枷锁实例
07-05
本文将深入探讨`synchronized`关键字的用法，包括类锁、对象锁、方法锁以及它们之间的关系。 **类锁（Class Lock）** 类锁是通过类的Class对象实现的，当一个线程访问类的静态 synchronized 方法或同步代码块时，就...
Java Synchronized锁失败案例及解决方案
08-19
Java Synchronized锁失败案例及解决方案 Java Synchronized锁是一种同步机制，用于解决多线程并发访问共享资源的问题。它通过锁机制来实现线程之间的同步，防止多个线程同时访问同一个资源，从而避免了线程安全问题...
Java synchronized锁升级jol过程详解
08-19
Java synchronized锁升级jol过程详解 Java synchronized锁升级jol过程详解是Java并发编程中一个重要的概念，了解锁升级过程对Java开发者来说非常重要。本文将通过示例代码详细介绍Java synchronized锁升级jol过程...
Java使用synchronized实现互斥锁功能示例
08-19
Java使用synchronized实现互斥锁功能示例 在Java编程语言中，synchronized关键字是实现互斥锁功能的主要手段。互斥锁是一种机制，用于控制多个线程访问共享资源的顺序，从而避免因为资源竞争而导致的程序错误。在...
synchronized修饰方法到底锁住的是什么
venus321的博客
01-31 1万+
本文参看http://blog.csdn.net/shenshibaoma/article/details/53009505 我们先给出本文的结论，synchronized修饰方法锁住的是对象的本身，也是this。 下面我们通过代码来验证。 public class Test164 { public static void main(String[] args) { MyThr
JUC多线程：synchronized锁机制原理 与 Lock锁机制
张维鹏的博客
08-26 1万+
synchronized 通过当前线程持有对象锁，从而拥有访问权限，而其他没有持有当前对象锁的线程无法拥有访问权限，保证在同一时刻，只有一个线程可以执行某个方法或者某个代码块，从而保证线程安全。synchronized 锁机制在 Java 虚拟机中的同步是基于进入和退出监视器锁对象 monitor 实现的
Synchronized（对象锁）和Static Synchronized（类锁）的区别
热门推荐
cs408的博客
10-06 3万+
Synchronized和Static Synchronized区别 通过分析这两个用法的分析，我们可以理解java中锁的概念。一个是实例锁（锁在某一个实例对象上，如果该类是单例，那么该锁也具有全局锁的概念），一个是全局锁（该锁针对的是类，无论实例多少个对象，那么线程都共享该锁）。实例锁对应的就是synchronized关键字，而类锁（全局锁）对应的就是static synchroniz
Synchronized详解（可重入、Monitor原理等）
mulinsen77的博客
03-18 2万+
其他相关文章见：《Lock与synchronized 的区别》 《可重入锁 介绍以及原理》 介绍Synchronized之前，我们先来看一下线程安全的相关概念。 造成线程安全问题的主要诱因有两点，一是存在共享数据(也称临界资源)，二是存在多条线程共同操作共享数据。 因此，引入了互斥锁的概念，即一个共享数据只能被一个线程访问，其他线程需要等待（阻塞），直至当前线程处理完毕释放该锁。 so，synch...
关于synchronized，对象锁的理解
dac55300424的专栏
07-19 2419
要想很好的理解synchronized 必须理解好什么是对象锁。 关于对象锁的理解：    刚开始真的有点难理解这个对象锁的概念，在网上搜了一大堆，感觉还是不怎么清晰。今天在次理解了下对象锁，突然发现这个对象锁并不难理解，关键是你要明白这个对象指的是什么？ [size=medium]其实这个对象指的是拥有synchronized修饰的函数，或者是代码块的一个类的实例。 当某个线程访问该
java synchronized是什么_java synchronized究竟锁住的是什么
weixin_39751769的博客
02-19 85
刚学java的时候，仅仅知道synchronized一个线程锁。能够锁住代码，可是它真的能像我想的那样，能够锁住代码吗？在讨论之前先看一下项目中常见关于synchronized的使用方法：public synchronized void syncCurrentObject() {System.out.println(Thread.currentThread().getName()+"..star...
synchronized对于加锁代码块、方法以及全局(static)锁的详细对比
linlvting1314的博客
02-22 1万+
在网上看了许多关于synchronized的介绍及用法区别，大多大同小异，点到为止，个人推荐一篇博友写的，网址如下：http://blog.csdn.net/cs408/article/details/48930803这篇博客是介绍对象锁和类锁的区别，通俗易懂，而我的这篇博客是基于此基础上引申出，用实际的代码分析对象和类在方法、代码段加锁及静态时的对比。开始先普及一下java里synchroniz...
synchronized到底锁的是什么？？
TT_130616的博客
06-30 195
先说结论，锁无非是锁两种： 非静态方法锁的当前实例对象this 静态方法锁的是当前类的class对象 代码块锁的是指定的对象 1、synchronzed修饰普通方法 package juctest; import java.util.concurrent.TimeUnit; public class LockTest1 { /** * 两个线程访问同一个synchronzied修饰的方法，资源类 * 其中谁先抢占着锁谁先执行。 * synchronzie
synchronized是什么锁
最新发布
04-24
synchronized锁的是对象或类，具体取决于它是修饰实例方法还是静态方法。当修饰实例方法时，锁是当前对象实例；当修饰静态方法时，锁是当前类的Class对象。 使用synchronized锁可以解决多线程并发访问共享资源时...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值