并发系列--Synchronized使用与原理

最新推荐文章于 2024-02-20 11:54:21 发布
最新推荐文章于 2024-02-20 11:54:21 发布
阅读量221 收藏
点赞数
分类专栏： # 高并发 # Android面试复习 javase
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_18242391/article/details/107889414
版权

前言

Synchronized在多线程中使用得比较多的，这两天看了下慕课网相关课程，在此总结下其使用和原理

作用：

Synchronized据有可重入，不可中断性，能够保证在同一时刻最多只有一个线程执行该段代码，以达到保证并发安全的效果，内部是通过monitor来加锁和解锁的。

地位：

1.Synchronized是java的关键字，被java语言原生支持。
2.是最基本的互斥同步手段。
3.是并发编程中的元老级角色，是并发编程的必学内容。

不使用并发的后果

两个线程同时a++，如果不加锁，最后结果会比预计的少

public class DisappearRequest {

    int i = 0;

    private Runnable runnable = new Runnable() {
        @Override
        public void run() {
            for (int j = 0; j < 100000; j++) {
                i++;
            }
        }
    };

    @Test
    public void test01() throws InterruptedException {

        Thread thread = new Thread(runnable);
        Thread thread2 = new Thread(runnable);
        thread.start();
        thread2.start();
        thread.join();
        thread2.join();

        System.out.println(i);

    }
}

运行上面代码，期望结果是200000，但是每次运行结果都是小于这个数的。

原因：
i++不是一个原子操作，实际上包含三个动作
1.读取i;
2.将i加1；
3.将i的值写入到内存中。

在多线程环境下这样是不安全的。在解决问题之前，还是先来学习下Synchronized的用法。

Synchronized的两个用法

对象锁

包括方法锁（默认锁对象为this当前实例对象）和同步代码块锁（自己指定的锁对象）

类锁

指synchronized修饰静态的方法或指定锁对象为class对象

一、对象锁

1、代码块形式
public Object lock = new Object();

//代码块锁
public Runnable runnable = new Runnable() {
    @Override
    public void run() {
        synchronized (lock) { //this或者自建对象
            System.out.println("我是对象锁的代码块形式，我叫：" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ":运行结束");
        }
    }
};

@Test
public void test01() {

    Thread t1 = new Thread(runnable);
    Thread t2 = new Thread(runnable);
    t1.start();
    t2.start();
    while (t1.isAlive() || t2.isAlive()) {

    }
    System.out.println("finished");
}

对象锁只对同一个对象的方法起到作用，如果是不同对象同一个方法，锁会失效

2、方法锁形式
//方法锁
public Runnable runnable2 = new Runnable() {
    @Override
    public synchronized void run() {
        System.out.println("我是对象锁的方法修饰符形式，我叫：" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ":运行结束");
    }
};
@Test
public void test01() {

    Thread t1 = new Thread(runnable2);
    Thread t2 = new Thread(runnable2);
    t1.start();
    t2.start();
    while (t1.isAlive() || t2.isAlive()) {

    }
    System.out.println("finished");
}

方法锁形式，锁对象默认为this

二、类锁

概念：java类可能有很多个对象，但只有一个class对象
本质：所以所谓的类锁，不过是Class对象而已。

1、静态方法锁
class RunnableTest implements Runnable{

    @Override
    public void run() {
        method();
    }

    public static synchronized void method(){
        System.out.println("我是对象锁的静态方法修饰符形式，我叫：" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ":运行结束");
    }

}

@Test
public void test01() {

    Thread t1 = new Thread(new RunnableTest());
    Thread t2 = new Thread(new RunnableTest());
    t1.start();
    t2.start();
    while (t1.isAlive() || t2.isAlive()) {

    }
    System.out.println("finished");
}

如果不加static，RunnableTest里面的method方法可以同时运行

2、class对象代码块
//class对象锁
public Runnable runnable5 = new Runnable() {
    @Override
    public void run() {
        synchronized (SynchronizedTest.class){
            System.out.println("我是对象锁的class对象修饰符形式，我叫：" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ":运行结束");
        }
    }
};
@Test
public void test01() {

    Thread t1 = new Thread(runnable5);
    Thread t2 = new Thread(runnable5);
    t1.start();
    t2.start();
    while (t1.isAlive() || t2.isAlive()) {

    }
    System.out.println("finished");
}

对象锁和类锁学完了，前面的例子就可以很容易的解决了，这里就不多说了。

多线程访问同步方法的7种情况

一、两个线程同时访问一个对象的同步方法

前面的对象锁已经学习过

二、两个线程访问的是两个对象的同步方法

前面的类锁的静态方法同步锁已经学过，如果不加静态的，那么两个线程运行毫无影响，不受干扰

三、两个线程访问的是synchronized的静态方法

加了静态方法就变成类锁，会一个一个执行

四、同时访问同步方法与非同步方法

public class SynchronizedYesAndNoTest {

    private Runnable runnable = new Runnable(){
        @Override
        public void run() {
            if(Thread.currentThread().getName().equals("Thread-0")){
                method();
            }else {
                method2();
            }
        }
    };

    public synchronized void method(){
        System.out.println("我是加锁的方法，我叫：" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ":运行结束");
    }

    public void method2(){
        System.out.println("我是没加锁的方法，我叫：" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ":运行结束");
    }

    @Test
    public void test01() {

        Thread t1 = new Thread(runnable);
        Thread t2 = new Thread(runnable);
        t1.start();
        t2.start();
        while (t1.isAlive() || t2.isAlive()) {

        }
        System.out.println("finished");
    }

}

非同步方法不受影响

五、访问同一个对象的不同的普通同步方法

public class SynchronizedDifferentMethod {

    private Runnable runnable = new Runnable(){
        @Override
        public void run() {
            if(Thread.currentThread().getName().equals("Thread-0")){
                method();
            }else {
                method2();
            }
        }
    };

    public synchronized void method(){
        System.out.println("我是加锁的方法method，我叫：" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ":运行结束");
    }

    public synchronized void method2(){
        System.out.println("我是加锁的方法method2，我叫：" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ":运行结束");
    }

    @Test
    public void test01() {

        Thread t1 = new Thread(runnable);
        Thread t2 = new Thread(runnable);
        t1.start();
        t2.start();
        while (t1.isAlive() || t2.isAlive()) {

        }
        System.out.println("finished");
    }

}

一个一个执行

六、同时访问静态synchronized和非静态synchronized方法

public class SynchronizedStaticAndNormal {

    private Runnable runnable = new Runnable(){
        @Override
        public void run() {
            if(Thread.currentThread().getName().equals("Thread-0")){
                method();
            }else {
                method2();
            }
        }
    };

    public static synchronized void method(){
        System.out.println("我是静态加锁的方法method，我叫：" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ":运行结束");
    }

    public synchronized void method2(){
        System.out.println("我是非静态加锁的方法method2，我叫：" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ":运行结束");
    }

    @Test
    public void test01() {

        Thread t1 = new Thread(runnable);
        Thread t2 = new Thread(runnable);
        t1.start();
        t2.start();
        while (t1.isAlive() || t2.isAlive()) {

        }
        System.out.println("finished");
    }

}

不受影响，同时进行

七、方法抛出异常后，会释放锁

public class SynchronizedException {

    private Runnable runnable = new Runnable(){
        @Override
        public void run() {
            if(Thread.currentThread().getName().equals("Thread-0")){
                method();
            }else {
                method2();
            }
        }
    };

    public synchronized void method(){
        System.out.println("我是方法method，我叫：" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        throw new RuntimeException();

//        System.out.println(Thread.currentThread().getName() + ":运行结束");
    }

    public synchronized void method2(){
        System.out.println("我是方法method2，我叫：" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ":运行结束");
    }

    @Test
    public void test01() {

        Thread t1 = new Thread(runnable);
        Thread t2 = new Thread(runnable);
        t1.start();
        t2.start();
        while (t1.isAlive() || t2.isAlive()) {

        }
        System.out.println("finished");
    }
}

抛出异常后，jvm会自动释放锁

八、七种情况总结

1.一把锁只能同时被一个线程获取，没有拿到锁的线程必须等待（对应第1，5种情况）
2.每个实例都对应有自己的一把锁，不同实例之前互不影响；例外：锁对象是*.class以及synchronized修饰的是static方法的时候，所有对象共用同一把类锁（对应第2，3，4，6种情况）
3.无论是正常执行完毕或者抛出异常，都会释放锁。

Synchronized的性质

一、可重入性

定义：指的是同一个线程的外层函数获得锁之后，内层函数可以直接再次获取到锁。（Synchronized,Lock）

好处：避免死锁、提升封装性

粒度：线程而非调用（用3种情况来说明和pthread的区别）

1、情况1：证明同一个方法是可重入的
public class SynchronizedRecursion {

    private int a = 0;

    private synchronized void method(){
        System.out.println("这是method1,a = " + a);
        if(a==0){
            a ++;
            method();
        }
    }

    @Test
    public void test01(){
        method();
    }

}

递归调用自己可以成功

2、情况2：证明可重入不要求是同一个方法
public class SynchronizedOtherMethod {

    private synchronized void method(){
        System.out.println("这是method1");
        method2();
    }

    private synchronized void method2(){
        System.out.println("这是method2");
    }

    @Test
    public void test01(){
        method();
    }
}
3、情况3：证明可重入不要是同一个类种的
public class SynchronizedSuperClass {

    @Test
    public void test01(){
        TestClass testClass = new TestClass();
        testClass.method();
    }

}

class SuperClass{

    public synchronized void method(){
        System.out.println("我是父类的方法");
    }

}

class TestClass extends SuperClass{

    @Override
    public synchronized void method() {
        super.method();
        System.out.println("我是子类的方法");
    }
}

二、不可中断性

一旦这个锁已经被别人获取到了，如果我还想获得，我只能选择等待或者阻塞，直到别的线程释放这个锁。如果别人永远不释放锁，那么我就只能永远等待下去。

相比之下，Lock可以拥有中断的能力，第一点，如果我觉得我等的时间太长，有权中断现在已经获取到锁的线程的执行；第二点，如果我等待的时间太长了不想再等了，也可以退出。

原理

一、加锁和释放锁的原理

获取和释放的时机：内置锁，每个java对象可以用做实现同步的锁，这个锁就是内置锁，或者称做监视锁。

表达成lock的形式

public class SynchronizedToLock {

    Lock lock = new ReentrantLock();

    public synchronized void method1(){
        System.out.println("我是Synchronized形式的锁");
    }

    public void method2(){
        lock.lock();

        try{
            System.out.println("我是lock形式的锁");
        }finally {
            lock.unlock();
        }
    }

    @Test
    public void test01(){
        method1();
        method2();
    }

}

深入JVM看字节码
javac 编译成class文件
javap [-verbose] 反编译

//java文件
public class Decompilation {

    private Object object = new Object();

    public void insert(Thread thread){
        synchronized (object){
            
        }
    }

}

//反编译之后的文件
  Last modified 2020-8-9; size 503 bytes
  MD5 checksum 1832d1176898be312930160e30a29bf2
  Compiled from "Decompilation.java"
public class com.example.threadlocaldemo.Decompilation
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #2.#20         // java/lang/Object."<init>":()V
   #2 = Class              #21            // java/lang/Object
   #3 = Fieldref           #4.#22         // com/example/threadlocaldemo/Decompilation.object:Ljava/lang/Object;
   #4 = Class              #23            // com/example/threadlocaldemo/Decompilation
   #5 = Utf8               object
   #6 = Utf8               Ljava/lang/Object;
   #7 = Utf8               <init>
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               insert
  #12 = Utf8               (Ljava/lang/Thread;)V
  #13 = Utf8               StackMapTable
  #14 = Class              #23            // com/example/threadlocaldemo/Decompilation
  #15 = Class              #24            // java/lang/Thread
  #16 = Class              #21            // java/lang/Object
  #17 = Class              #25            // java/lang/Throwable
  #18 = Utf8               SourceFile
  #19 = Utf8               Decompilation.java
  #20 = NameAndType        #7:#8          // "<init>":()V
  #21 = Utf8               java/lang/Object
  #22 = NameAndType        #5:#6          // object:Ljava/lang/Object;
  #23 = Utf8               com/example/threadlocaldemo/Decompilation
  #24 = Utf8               java/lang/Thread
  #25 = Utf8               java/lang/Throwable
{
  public com.example.threadlocaldemo.Decompilation();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=3, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: aload_0
         5: new           #2                  // class java/lang/Object
         8: dup
         9: invokespecial #1                  // Method java/lang/Object."<init>":()V
        12: putfield      #3                  // Field object:Ljava/lang/Object;
        15: return
      LineNumberTable:
        line 3: 0
        line 5: 4

  public void insert(java.lang.Thread);
    descriptor: (Ljava/lang/Thread;)V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=4, args_size=2
         0: aload_0
         1: getfield      #3                  // Field object:Ljava/lang/Object;
         4: dup
         5: astore_2
         6: monitorenter  //monitorenter和monitorexit两个指令实现加锁和释放锁
         7: aload_2
         8: monitorexit
         9: goto          17
        12: astore_3
        13: aload_2
        14: monitorexit
        15: aload_3
        16: athrow
        17: return
      Exception table:
         from    to  target type
             7     9    12   any
            12    15    12   any
      LineNumberTable:
        line 8: 0
        line 10: 7
        line 11: 17
      StackMapTable: number_of_entries = 2
        frame_type = 255 /* full_frame */
          offset_delta = 12
          locals = [ class com/example/threadlocaldemo/Decompilation, class java/lang/Thread, class java/lang/Object ]
          stack = [ class java/lang/Throwable ]
        frame_type = 250 /* chop */
          offset_delta = 4

monitorenter和monitorexit两个指令实现加锁和释放锁

二、可重入原理：加锁次数计数器

1.jvm负责跟踪对象被加锁的次数
2.线程第一次给对象加锁的时候，计数变为1。每当这个相同的线程在此对象上再次获得锁时，计数会递增（可重入）。
3.每当任务离开时，计数递减，当计数为0的时候，锁会被完全释放。

三、保存可见性的原理：内存模型

在这里插入图片描述
在这里插入图片描述
Synchonized对象释放锁前，任何对象的修改都会被写入到主内存，保证每次执行都是可靠的，保证可见性

缺陷

效率低：锁的释放情况少、试图获得锁时不能设定超时、不能中断一个正在试图获得锁的线程
不够灵活（读写锁更灵活）：加锁和释放的时机单一，每个锁仅有单一的条件（某个对象），可能是不够的
无法知道是否成功获取到锁

常见问题

1.使用注意点：锁对象不能为空（锁信息是保存在对象头中，锁为空，那么锁信息就没有了）、作用域不宜过大、避免死锁
2.如何选择Lock和Synchronized关键字

如果可以两个都不要用，而是选择java.util.courrent包中的类，优先Synchronized，避免出错的发生

3.多线程访问同步方法的各种情况

思考

1.多个线程等待同一个

参考

Java高并发之魂：synchronized深度解析

Java高并发编程实战4，synchronized与Lock底层原理
学Java，找哪吒
09-23 4878
Java高并发编程实战系列，打造精品专栏。
Java面试系列之并发编程专题-Synchronized灵魂拷问
青松之竹_Java博客
01-26 344
金三银四跳槽季即将来临，想必有些猿友已经蠢蠢欲动在做相关的准备了！在接下来的日子里，笔者将坚持写作、分享Java工程师在面试求职期间的方方面面，包括简历制作、面试场景复现、面试题解答、谈薪技巧 以及 项目的实战！今天我们先拿Java里面的并发编程之Synchronized来开刀！ 以下内容来自 程序员实战基地fightjava.com一位网友最近的面试场景，笔者尝试着将其复现，话不多说，咱们直接开撸！ 1.面试官：Synchronized有用过吗？谈谈你对它的理解 （1）画外音：面试官主要...
synchronized用法与原理详解
Anon
07-12 421
介绍 在日常开发的过程中，为了提升业务处理的性能，我们常用多线程对代码进行逻辑改造，合理地使用多线程可以更好的利用计算资源。 因为每个线程都有自己的栈空间，所以只使用自己的线程上下文时不会有什么问题。但是大多数情况下，多线程的场景都需要线程间进行协作，当多个线程同时使用共享变量时，就涉及到主内存与线程工作内存间的同步。如何处理共享数据的线程安全问题？只要让线程一个个依次访问共享变量即可。这时，synchronized关键字就出场了。 synchronized关键字是用来控制线程同步的，保证多线程环境下，方法
三、并发编程之synchronized详解
♾️
11-04 434
设计synchronized同步器的意义 在多线程编程中，可能会出现多个线程访问同一个共享，可变的资源，这个资源就是所谓的临界资源，这个资源可能是，变量，对象，文件等 共享：资源可同时被多个线程访问 可变：资源在生命周期内可以被改变 由此引发的问题： 由于线程的执行是不可控的，所以需要同步机制来协同对可变资源的访问。 那怎么去解决此类的问题： 实际上，我们所有的并发模式在解决线程安全问题时，采用的都是序列化的访问临界资源，就是在同一时刻，只有一个线程访问临界资源，也称作同步互斥访问 Java提供了两种同步互
synchronized使用及原理
qq_48965301的博客
02-08 440
在java中我们对于synchronized锁是不可避免的，在jdk1.5之前它是一个重量级锁，相对于juc 里的lock显得十分笨重。因此在jdk1.6之后Java官方对synchronized进行优化处理。synchronized 是 Java 中的一个关键字，翻译成中文是同步的意思，主要解决的是多个线程之间访问资源的同步性，可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。在 Java 早期版本中，synchronized 属于 重量级锁，效率低下。
Synchronized的使用及原理（这篇文章就够了）
A_sendy的博客
09-25 335
前言 平时的开发中，我们经常与多线程接触，有时候某个变量是可以多个线程共享的，那么很有可能就会引入同步问题，使用synchronized关键字，将存在同步问题的代码块或者方法修饰起来，便是我们经常用来解决多线程同步的问题，下面我们一起看看它的使用及原理。 正文 1.同步问题： private static void test() { Runnable task = new Runnable() { int count = 10; @Override p
Synchronized使用及其原理
两米以下皆凡人的博客
02-13 486
文章目录1、线程安全问题1.1、问题分析1.2、概念归纳1.2.1、临界区1.2.2、竞态条件2、synchronized1.4、线程八锁问题3、变量的线程安全分析3.1、常见线程安全类3.2、不可变线程安全类3.3、案例分析3.4、卖票问题4、Monitor4.1、Java对象头4.2、Monitor 原理4.3、synchronized原理4.4、轻量级锁4.5、锁膨胀4.6、自旋优化4.7、偏向锁4.7.1、撤销偏向锁4.7.2、批量重偏向4.7.3、批量撤销5、死锁5.1、现象5.2、检测死锁5.3
并发Synchronized原理
harryptter的专栏
01-04 403
最近在看一些java并发方面的知识，并发编程是Java程序员最重要的技能之一，也是最难掌握的一种技能。 以下这部分转载自：http://www.cnblogs.com/paddix/p/5367116.html 目录 一、Synchronized的基本使用 二、Synchronized 原理 三、运行结果解释 四 总结 Mark Word（对象头） Monitor Synchr...
并发——Synchronized原理
m0_58568357的博客
08-04 123
synchronized原理1. Monitor 介绍2. MarkWord2. Synchronized 原理 （重量级锁）2.1 synchronized 在字节码中 的体现3. Synchronized进阶原理3.1 轻量级锁3.2 锁膨胀3.3 偏向锁3.31 hashcode问题4. 自旋优化5. 锁消除 1. Monitor 介绍 Monitor 被成为锁或者是管程，是操作系统底层为了控制线程，进程同步时使用的一个对象。在Monitor中有三个管家的属性见下图： 分别是： waitSet
深入理解高并发编程-核心技术原理
03-14
【深入理解高并发编程-核心技术原理】是一本专注于讲解高并发编程核心概念和技术的书籍，由阿里P8级别的架构师及Mykit系列开源框架作者撰写。本书内容涵盖源码分析、基础案例、实战案例和面试相关知识，旨在帮助读者...
java并发源码-java-concurrent-test:和朱晔一起复习Java并发系列文章
05-24
本项目“java-concurrent-test”是一个针对Java并发源码的测试与学习平台，旨在帮助开发者深入理解Java并发库的工作原理。在这个项目中，源代码主要存放在“test”目录下，方便开发者进行实践和调试。 《和朱晔一起...
并发编程系列之Synchronized实现原理
Nicky's blog
04-10 1127
并发编程系列之Synchronized实现原理。偏向锁：当一个线程获取到锁后，这把锁就是偏向锁，偏向锁是在锁对象的对象头中记录一个线程id,然后该线程再次获取锁时，直接获取就可以 轻量级锁：如果有第二个线程来竞争锁，这时就会升级为轻量级锁，轻量级锁是不会阻塞线程的，其底层是通过自旋实现的。自旋是通过CAS获取一个预期的标识，如果没获取到，就会一直循环获取，获取到标识，也就标识获取到锁 重量级锁：如果轻量级锁一直自旋也获取不到锁，才会升级为重量级锁，重量锁是会阻塞线程的，也称之为重锁
synchronized的介绍，使用和原理
迷雾总会解
01-07 803
synchronized实际上利用对象保证了临界区代码的原子性，临界区内的代码在外界看来是不可分割的，不会被线程切换所打断。
Synchronized 用法和底层原理
击水三千里的专栏
08-11 2526
一、对象锁和类锁 1. 对象锁 在 Java 中，每个对象都会有一个 monitor 对象，这个对象其实就是 Java 对象的锁，通常会被称为“内置锁”或“对象锁”。类的对象可以有多个，所以每个对象有其独立的对象锁，互不干扰。 2. 类锁 在 Java 中，针对每个类也有一个锁，可以称为“类锁”，类锁实际上是通过对象锁实现的，即类的 Class 对象锁。每个类只有一个 Class 对象，所...
Synchronized 原理是什么？ 2019 java 后端面试
夏安的博客
11-20 225
Synchronized 是由 JVM 实现的一种实现互斥同步的一种方式，如果你查看被 Synchronized 修饰过的程序块编译后的字节码，会发现，被 Synchronized 修饰过的程序块，在编译前后被编译器生成了 monitorenter [ˈmɒnɪtə(r)] [ˈentə(r)] 和 monitorexit 两个字节码指令。 这两个指令是什么意思呢？ 在虚拟机执行到 moni...
mysql乐观锁和悲观锁面试_面试必备之乐观锁与悲观锁
weixin_39819661的博客
02-03 270
何谓悲观锁与乐观锁乐观锁对应于生活中乐观的人总是想着事情往好的方向发展，悲观锁对应于生活中悲观的人总是想着事情往坏的方向发展。这两种人各有优缺点，不能不以场景而定说一种人好于另外一种人。悲观锁总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁(共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程)。传...
面试官:Synchronized用过么？原理是什么？
绅士jiejie的博客
04-07 1756
相信经过这篇专栏前面几篇的铺垫，读者即使在项目中没用过Synchronized关键字，对它的了解也不亚于项目实战了，而且大多数人也都是浮于使用，只是知道用Synchronized关键字能实现同步，那就用呗，甚至连类锁和对象锁也没分开区别，当然了，会用总是好的，不过面试官可不会只问你用过Synchronized没，只要你用过就肯定会深究的，所以这时能说出其一二原理，自然是大大的好。 Synchro...
并发编程篇:synchronized的使用以及原理
热门推荐
程序员ZZ的源码
09-09 1万+
synchronized的三种应用方式 synchronized关键字最主要有以下几种应用方式 java对象头 在JVM中，对象在内存中的布局分为三块区域：对象头、实例数据和对齐填充。 实例变量：存放类的属性数据信息，包括父类的属性信息，如果是数组的实例部分还包括数组的长度，这部分内存按4字节对齐。 填充数据：由于虚拟机要求对象起始地址必须是8字节的整数倍。填充数据不是必须存在的，仅...
并发编程系列(四)Synchronized的使用与实现原理
fd135的博客
02-20 196
synchronized关键字使我们在多线程并发条件下经常使用的一个关键字，下面我们来详细介绍synchronized的应用场景及底层的实现原理。 synchronized的使用 分类 被锁的对象 伪代码 实例方法 类的实例对象 public synchronized void method (){......} 静态方法 类对象 public static synchroni...
多线程系列(三) -synchronized 关键字使用详解
最新发布
程序员志哥的博客
02-20 1018
在之前的线程系列文章中，我们介绍了线程创建的几种方式以及常用的方法介绍。我们接着聊聊多线程线程安全的问题，以及解决办法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值