Synchronize锁详解

最新推荐文章于 2023-02-28 21:05:26 发布
置顶 最新推荐文章于 2023-02-28 21:05:26 发布
阅读量533 收藏
点赞数
分类专栏： synchronize锁 Java基础多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wxssbsb/article/details/114803624
版权

1、多线程中出现的问题

我们在使用多线程中，发现代码有时候会和我们的预期结果不一致：

我们发现，在多线程中，我们开启两个线程对我们的i值进行增加，但是最后的结果不等于200000，他最后输出的结果是小于200000的，这是为啥呢？

原因很简单，因为我们的i++这个操作，并不是一个原子操作。

i++分解后其实是三个操作：

  1. 读取i的值
  2. 将i的值进行+1
  3. 将i的值写回内存

两个线程同时进程，可能A线程刚读取完i的值。B线程就进来，将i的值进行读取并对i+1写回内存。B线程结束后A线程并不知道i的值被修改，所以他再对i进行+1操作其实并不准确。

2、Synchronize锁的介绍

synchronize锁的作用：

就是保证同一时刻最多只有一个线程执行该段代码，以保证并发安全的问题。

3、Synchronize锁的用法

  • 对象锁：包括方法锁（默认锁对象为this当前实例对象）和同步代码块锁（自己指定锁对象）
  • 类锁：Synchronize修饰静态方法或者锁对象为class对象

3.1、对象锁

用代码来演示我们的对象锁：

public class MethodSynchronize implements Runnable {

    private static MethodSynchronize methodSynchronize = new MethodSynchronize();

    @Override
    public void run() {
        synchronized (this) {
            System.out.println("我是对象锁代码块，" + Thread.currentThread().getName() + "开始执行");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("我是对象锁代码块，" + Thread.currentThread().getName() + "执行结束");
        }
    }

    public static void main(String[] args) {
        Thread thread1 = new Thread(methodSynchronize);
        Thread thread2 = new Thread(methodSynchronize);
        thread1.start();
        thread2.start();
        while (thread1.isAlive() || thread2.isAlive()){

        }
        System.out.println("game over");
    }
}
//执行结果
我是对象锁代码块，Thread-0开始执行
我是对象锁代码块，Thread-0执行结束
我是对象锁代码块，Thread-1开始执行
我是对象锁代码块，Thread-1执行结束
game over

我们发现，对方法加了锁后，就是顺序执行的。执行完了thread1之后才回去执行thread2。

如果我们不加对象锁，我们的执行效果是这样的：

public class MethodSynchronize implements Runnable {

    private static MethodSynchronize methodSynchronize = new MethodSynchronize();

    @Override
    public void run() {
        // synchronized (this) {
            System.out.println("我是对象锁代码块，" + Thread.currentThread().getName() + "开始执行");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("我是对象锁代码块，" + Thread.currentThread().getName() + "执行结束");
        // }
    }

    public static void main(String[] args) {
        Thread thread1 = new Thread(methodSynchronize);
        Thread thread2 = new Thread(methodSynchronize);
        thread1.start();
        thread2.start();
        while (thread1.isAlive() || thread2.isAlive()){

        }
        System.out.println("game over");
    }
}
//执行效果
我是对象锁代码块，Thread-0开始执行
我是对象锁代码块，Thread-1开始执行
我是对象锁代码块，Thread-0执行结束
我是对象锁代码块，Thread-1执行结束
game over

使用同步代码块，自己指定锁：

public class MethodSynchronize implements Runnable {

    private static MethodSynchronize methodSynchronize = new MethodSynchronize();
    Object lock1 = new Object();
    Object lock2 = new Object();

    @Override
    public void run() {
        synchronized (lock1) {
            System.out.println("我是lock1对象锁代码块，" + Thread.currentThread().getName() + "开始执行");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("我是lock1对象锁代码块，" + Thread.currentThread().getName() + "执行结束");
        }

        synchronized (lock2) {
            System.out.println("我是lock2对象锁代码块，" + Thread.currentThread().getName() + "开始执行");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("我是lock2对象锁代码块，" + Thread.currentThread().getName() + "执行结束");
        }
    }

    public static void main(String[] args) {
        Thread thread1 = new Thread(methodSynchronize);
        Thread thread2 = new Thread(methodSynchronize);
        thread1.start();
        thread2.start();
        while (thread1.isAlive() || thread2.isAlive()){

        }
        System.out.println("game over");
    }
}
//执行结果
我是lock1对象锁代码块，Thread-0开始执行
我是lock1对象锁代码块，Thread-0执行结束
我是lock2对象锁代码块，Thread-0开始执行
我是lock1对象锁代码块，Thread-1开始执行
我是lock1对象锁代码块，Thread-1执行结束
我是lock2对象锁代码块，Thread-0执行结束
我是lock2对象锁代码块，Thread-1开始执行
我是lock2对象锁代码块，Thread-1执行结束
game over

Process finished with exit code 0

这里我们可以看到，因为是不同的锁，所以thread-0的lock2锁的代码执行时间和thread-1的lock1锁执行的时间是同步。因为锁对象不是同一个，所以是并行执行的。

如果将lock2的锁对象也替换成lock1，那么他们就还是顺序执行：

public void run() {
        synchronized (lock1) {
            System.out.println("我是lock1对象锁代码块，" + Thread.currentThread().getName() + "开始执行");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("我是lock1对象锁代码块，" + Thread.currentThread().getName() + "执行结束");
        }

        synchronized (lock1) {
            System.out.println("我是lock2对象锁代码块，" + Thread.currentThread().getName() + "开始执行");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("我是lock2对象锁代码块，" + Thread.currentThread().getName() + "执行结束");
        }
    }
//执行效果
我是lock1对象锁代码块，Thread-0开始执行
我是lock1对象锁代码块，Thread-0执行结束
我是lock2对象锁代码块，Thread-0开始执行
我是lock2对象锁代码块，Thread-0执行结束
我是lock1对象锁代码块，Thread-1开始执行
我是lock1对象锁代码块，Thread-1执行结束
我是lock2对象锁代码块，Thread-1开始执行
我是lock2对象锁代码块，Thread-1执行结束
game over

 

方法锁代码示例：

public class MethodSychroize2 implements Runnable {
    private static MethodSychroize2 methodSychroize2= new MethodSychroize2();
    @Override
    public void run() {
        method();
    }

    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 static void main(String[] args) {
        Thread thread1 = new Thread(methodSychroize2);
        Thread thread2 = new Thread(methodSychroize2);
        thread1.start();
        thread2.start();
        while (thread1.isAlive() || thread2.isAlive()){

        }
        System.out.println("game over!");
    }
}
//执行效果
我是对象锁的方法修饰符，我叫Thread-0开始
我是对象锁的方法修饰符，我叫Thread-0结束
我是对象锁的方法修饰符，我叫Thread-1开始
我是对象锁的方法修饰符，我叫Thread-1结束
game over!

synchronize修饰普通方法，默认锁对象就是当前实例对象

同步代码块，锁对象需要自己指定

3.2、类锁

概念：一个类，可以有多个实例对象，但是只有一个class对象

类锁有两种方式：

  1. static静态方法上synchronize关键字
  2. 代码块中用.class作为锁对象

不适用类锁，而是使用对象锁出现的问题：

public class StaticMethodSynchronize implements Runnable {
    private static StaticMethodSynchronize instance1 = new StaticMethodSynchronize();
    private static StaticMethodSynchronize instance2 = new StaticMethodSynchronize();

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

    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 static void main(String[] args) {
        Thread thread1 = new Thread(instance1);
        Thread thread2 = new Thread(instance2);
        thread1.start();
        thread2.start();
        while (thread1.isAlive() || thread2.isAlive()) {

        }
        System.out.println("game over");

    }
}
//执行结果
我是类锁，我叫Thread-1开始执行
我是类锁，我叫Thread-0开始执行
Thread-0执行结束
Thread-1执行结束
game over

我们发现这种情况下，使用同步代码块锁，线程为啥还是并行执行的呢？

原因是我们的同步代码块中，锁对象默认是当前实例，但是我们可以看到，thread1和thread2的传递进去的实例对象并不是同一个，所以无法锁住。

想要解决这个问题，我们就需要使用我们的类锁，使用静态方法上加synchronize：

    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() + "执行结束");
    }
//执行结果
我是类锁静态方法，我叫Thread-0开始执行
Thread-0执行结束
我是类锁静态方法，我叫Thread-1开始执行
Thread-1执行结束
game over

Synchronize(.class)这种形式的代码示例：

    public void method(){
        synchronized (StaticMethodSynchronize.class) {
            System.out.println("我是类锁静态方法，我叫" + Thread.currentThread().getName() + "开始执行");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "执行结束");
        }
    }
//执行结果
我是类锁静态方法，我叫Thread-0开始执行
Thread-0执行结束
我是类锁静态方法，我叫Thread-1开始执行
Thread-1执行结束
game over

4、核心思想

  1. 一把锁同时只能被一个线程持有，没有持有锁的线程必须等待
  2. 每个实例之间都有一把锁，不同实例之间互不影响；例外，只有锁对象是.class的时候和synchronize修饰static方法的时候，所有对象共用一把类锁
  3. synchronize无论是正常执行完毕还是抛出异常，都会释放锁对象

synchronize修饰的方法调用了其他的方法，不能保证其他方法是线程安全的。没有被synchronize修饰的方法，是可以同时被多个线程访问的

5、synchronize性质

  • 可重入：同一线程的外层函数获取了锁之后，内层函数不需要再去竞争锁，可以直接使用
  • 不可中断：一旦这个锁被人获得了，我还想获得锁对象，我只能选择等待或者阻塞，直到没得线程释放了这把锁

5.1可重入性

  • 证明同一个方法是可重入的：
public class SynchronizeRecusion  {
    int a = 0;
    public static void main(String[] args) {
        SynchronizeRecusion recusion = new SynchronizeRecusion();
        recusion.method();
    }

    private synchronized void method() {
        System.out.println("我是method，a="+a);
        if (a == 0){
            a++;
            method();
        }
    }
}
//执行结果
我是method，a=0
我是method，a=1
  • 证明可重入不要求是同一个方法：
public class MethodOtherSynchorize {

    public synchronized void method(){
        System.out.println("我是method");
        method1();
    }

    public synchronized void method1(){
        System.out.println("我是method1");
    }

    public static void main(String[] args) {
        MethodOtherSynchorize otherSynchorize = new MethodOtherSynchorize();
        otherSynchorize.method();
    }
}
//执行结果
我是method
我是method1
  • 证明可重入不要求是同一个类中
public class SuperClassSynchroize {

    public synchronized void doSomething(){
        System.out.println("我是父类方法"+this);
    }
}

class TestClass extends SuperClassSynchroize{
    public synchronized void doSomething(){
        System.out.println("我是子类方法"+this);
        super.doSomething();
    }

    public static void main(String[] args) {
        TestClass testClass = new TestClass();
        testClass.doSomething();
    }
}
//执行结果
我是子类方法com.wx.mythread.thread.TestClass@7adf9f5f
我是父类方法com.wx.mythread.thread.TestClass@7adf9f5f

粒度：是线程中，只要是同一个线程中，需要的是同一把锁，就可以直接使用

5.2不可中断

一旦这个锁被人获得了，我还想获得锁对象，我只能选择等待或者阻塞，直到没得线程释放了这把锁。如果别人永远不释放，我将会永远等待下去。

相比之下，之后会介绍Lock锁，他有中断的能力。我等待的时间太久了，可以选择中断正在执行的锁对象；等待太久了，也可以选择不等待了，直接退出

6、原理

加锁和释放锁的等价代码：

public class LockSynchroize {
    Lock lock = new ReentrantLock();

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

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

    public static void main(String[] args) {
        LockSynchroize lockSynchroize = new LockSynchroize();
        lockSynchroize.method();
        lockSynchroize.method1();
    }
}

我们的synchronize关键字在方法内部也是做的这么下面这个操作。

将我们的同步代码块进行反编译：

monitorenter为0，说明可以获取到锁，获取到锁会+1。monitorexit操作会-1，减到0就会释放锁，否则就说明是重入进来的。 

6.1可重入原理

利用加锁计数器实现的。

  • JVM会负责跟踪对象呗加锁的次数
  • 线程第一次给对象加锁的时候，计数变为1，每当相同的线程在对象上再次获得锁时，计数会递增
  • 每当任务离开时，计数递减，当计数为0的时候，锁会被完全释放

6.2可见性原理

Java内存模型

加锁后

加锁后，线程也是无法直接操作主内存的，只能通过本地内存去同步主内存中的数据。

7、缺陷

  • 效率低：锁释放的情况少，不能设置超时时间，没有获取到锁只能一直等待
  • 不够灵活（读写锁更灵活）：加锁释放锁的时机单一
  • 无法知道是够成功获取到锁

8、面试

  1. 使用synchronize关键字注意点：锁对象不能为空，作用域不宜过大，避免死锁
  2. 如何选择synchronize和lock：尽量选择juc提供的工具类，其次选择synchronize，因为写的代码少，减少出错的概率
Wan9_Xion9
关注
专栏目录
java 线程 synchronize_Java 线程详解（二）synchronize
weixin_34410975的博客
02-24 2384
我是按照《Java多线程编程技术》来学习的，所以这一篇是讲线程安全问题和synchronize关键字，下一篇是volatile关键字。一、线程安全问题1.线程安全和非线程安全线程安全：指多线程操作同一个对象的某方法，修改该类的成员变量时，不会出现“脏读”现象，即实例变量的值是经过同步处理的。非线程安全：指多线程操作同一个对象的某方法，修改该类的成员变量时，可能会出现“脏读”现象，即取到的数据其实是...
Synchronize 锁的使用和原理
M_Blog
11-04 149
是的一个关键字,加锁方式有: 对象锁、类锁,其用法有:方法锁: 默认所对象为，当前实例对象 同步代码块锁: 手动指定锁定对象(或者自定义锁) 自定义对象 类锁 修饰静态方法或指定锁对象为Class对象 synchronized原理 枷锁和释放锁是基于和指令实现的和指令，会让对象在执行，使其锁计数器加1或者减1。每一个对象在同一时间只与一个monitor(锁)相关联，而一个monitor在同一时间只能被一个线程获得，一个对象在尝试获得与这个对象相关联的Monitor锁的所有权的时候，：释放对于moni
synchronized 锁的介绍
高新富的博客
06-15 228
线程的安全性问题<-并发编程带来的问题 问题演示 package com.gaoxinfu.demo.jdk.rt.java.lang.thread.synchronize; /** * @Description: 并发编程问题demo * @Author: gaoxinfu * @Date: 2020-06-13 16:02 */ public class SynchronizedQuestionDemo { public static Integer COUNT=0;
Synchronize类锁
天高任鸟飞
08-09 592
类锁 Synchronize与static 在静态方法上，加上synchronize关键字 表示锁定class类，该锁是类级别的锁，独占类锁 代码 package com.bjsxt.base.sync002; /** * 关键字synchronized取得的锁都是对象锁，而不是把一段代码（方法）当做锁， * 所以代码中哪个线程先执行synchronized关键字的方法，哪个线...
synchronized锁
qq_61353850的博客
03-19 5590
1、synchronize锁的修饰的是方法和块 2、synchronize锁修饰静态方法就是类锁；修饰非静态方法就是对象锁。 3、类锁：是如果有N个静态的方法被synchronize修饰，有一个线程执行其中一个加锁的静态方法，那么其他的线程就无法继续调用这个类中的其他的加锁的静态方法，直到这个静态方法被执行完，其他加锁静态方法才可以被执行。不加锁的方法是不受影响的。 4、对象锁：在java中，类中定义一个非静态的方法，如果需要在其他类中使用这个方法，我们就要在其他类中，new一个新的对象。对象锁的意义
synchronized 使用理解、锁类
鑫的专栏
06-30 331
接上篇，本篇演示锁加在类上面 public class T { private static Integer count = 0; public static void m() { //任何线程要执行下面的代码，必须先拿到当前对象的锁 //锁的是当前对象 synchronized (T.class) { for (int i = 0; i < 100000; i++) { c
synchronize 重入锁
wjavadog的博客
08-03 169
前言 重入锁 重入的一种实现方式： 为每一个锁关联一个获取计数值和一个所有者线程。当计数值为0时，这个锁被认为是没有被任何线程持有。当一个线程持有一个未持有的锁的时候，JVM 将记下锁的持有者，并且将获取计数值将其置1。如果这个线程再次获取这个锁，计数值+1，当线程退出同步代码块时，计数值-1。当计数值为0时，释放锁。 示例如下： public class A { public synchron...
Java 中synchronize函数的实例详解
08-29
由于 `funcA` 包含了一个5秒的睡眠，`t2` 线程在 `t1` 执行 `funcA` 的过程中无法获取到锁，因此它会被阻塞，直到 `t1` 完成 `funcA` 并释放锁。接着，`t2` 线程可以获取到锁并执行 `funcB`。同样，如果 `t2` 先启动...
Synchronized 同步锁详解
qq_56263094的博客
07-21 1500
Synchronized是JAVA的关键字，是基于JVM层面的独占式的悲观锁，同时也属于可重入锁经常来用于解决多个线程之间访问访问资源的同步性，保证在同一时刻只有一个线程访问这个资源。
Java锁详解：“独享锁/共享锁+公平锁/非公平锁+乐观锁/悲观锁+线程锁”
m0_73257876的博客
08-19 311
在资源竞争不是很激烈的情况下，偶尔会有同步的情形下，synchronized是很合适的。原因在于，编译程序通常会尽可能的进行优化synchronize，另外可读性非常好。在资源竞争不激烈的情形下，性能稍微比synchronized差点点。但是当同步非常激烈的时候，synchronized的性能一下子能下降好几十倍，而ReentrantLock确还能维持常态。高并发量情况下使用ReentrantLock。和上面的类似，不激烈情况下，性能比synchronized略逊，而激烈的时候，也能维持常态。
Java 同步锁(synchronized)详解及实例
08-30
主要介绍了Java 同步锁(synchronized)详解及实例的相关资料,需要的朋友可以参考下
synchronize 3 种锁
05-13 224
对象锁 synchronize修饰this synchronized修饰普通方法 类锁 synchronize修饰静态方法 synchronized指定锁对象为Class对象
Synchronized的锁升级过程
stormkai的专栏
02-28 868
在synchronized中引入了偏向锁、轻量级锁、重量级锁之后，当前具体使用的是synchronzed中的那种类型锁，是根据线程竞争激烈程度来决定的。偏向锁实现原理：就是使用CAS机制来替换对象头中的Thread Id, 如果成功，则获得偏向锁，否则，就会升级为轻量级锁。重量级锁：是在Object Monitor中完成的，所以锁膨胀的意义就是构建一个ObjectMonitor.轻量级锁：只是通过CAS来修改锁对象中指向Lock Record的指针。
synchronize同步锁的应用
Qyuewei的专栏
05-29 348
1、当存在父子类继承关系是，子类完全可以通过“可重入锁”调用父类的同步方法的。 2、同步不能继承，需要在子类的方法中添加synchronize关键字 synchronize同步方法、变量；锁定当前对象 // 异步调用service1()、service2()、service3()方法时， // 会等待当前调用的方法完成后才调用下一个方法。 public static class Ser...
synchronized 锁升级过程
qq_43842093的博客
10-28 3919
synchronized 锁升级过程就是其优化的核心：偏向锁 -> 轻量级锁 -> 重量级锁 class Test{ private static final Object object = new Object(); public void test(){ synchronized(object) { // do something } } } 每个对象创建时都有各自的
synchronized锁升级过程
luly0630的专栏
11-12 258
synchronized锁升级过程：无锁、偏向锁、轻量级锁、重量级锁
多线程【四】：synchronized锁
qq_45605223的博客
05-22 142
目录一、synchronized锁1.什么是synchronized锁二、lock锁三、死锁 一、synchronized锁 1.什么是synchronized锁 二、lock锁 三、死锁
synchronized锁升级全过程
weixin_51490695的博客
11-11 298
synchronized全过程
玩玩并发编程（四）--synchronized
你是真的皮
06-18 160
synchronized1. 什么是synchronized2. synchronized特点3. synchronized使用4. synchronized原理4.1 对象的内存布局4.1.1 对象头5. synchronized 优化5.1 锁的膨胀升级过程6. 小结 1. 什么是synchronized synchronized内置锁是一种对象锁(锁的是对象而非引用)，作用粒度是对象，可以用来实现对临界资源的同步互斥访问，是可重入的。 2. synchronized特点 synchronized
synchronize是可重入锁吗
最新发布
05-14
synchronize不是可重入锁。在Java中，synchronized是一种互斥锁，它确保同一时间只有一个线程可以进入被锁定的代码块。如果一个线程已经获得了一个对象上的锁，那么在没有释放锁之前，它将无法再次获得该锁。这就...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值