Java高并发之魂-synchronized深度解析 学习笔记（1）- 对象锁和类锁

2021-01-08 15:07:59 54 收藏
分类专栏： # Java线程学习笔记 文章标签： 多线程 java 对象锁 类锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012292754/article/details/111025839
版权

1 Synchronized

1.1 作用

在这里插入图片描述
在这里插入图片描述

一句话概括：

  • 能够保证 同一时刻 最多只有 一个 线程执行该段代码，以达到保证并发安全的效果。

1.1 不使用并发手段的后果

public class DisappearRequest1 implements Runnable {

    static DisappearRequest1 instance = new DisappearRequest1();

    static int i = 0;

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

        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println(i);
    }

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

在这里插入图片描述
在这里插入图片描述

2 Synchronized 的两个用法

2.1 对象锁

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

代码块形式：手动指定锁对象
方法锁形式： synchronized 修饰普通方法，锁对象默认是 this

在这里插入图片描述

/**
 * @Description 对象锁案例1，代码块形式
 * @Author tzb
 * @Date 2020/12/16 22:56
 * @Version 1.0
 **/
public class SycchronizedObjecfCodeBlock2 implements Runnable {

    static SycchronizedObjecfCodeBlock2 instance = new SycchronizedObjecfCodeBlock2();

    @Override
    public void run() {

        synchronized (this) {
            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 t1 = new Thread(instance);
        Thread t2 = new Thread(instance);

        t1.start();
        t2.start();

        while (t1.isAlive() || t2.isAlive()) {

        }

        System.out.println("finished");

    }

}

在这里插入图片描述

public class SycchronizedObjecfCodeBlock2 implements Runnable {

    static SycchronizedObjecfCodeBlock2 instance = new SycchronizedObjecfCodeBlock2();

    Object lock1 = new Object();
    Object lock2 = new Object();

    @Override
    public void run() {

        synchronized (lock1) {
            System.out.println("我是lock1，我叫" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " lock1运行结束");
        }

        synchronized (lock2) {
            System.out.println("我是lock2，我叫" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " lock2运行结束");
        }


    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);

        t1.start();
        t2.start();

        while (t1.isAlive() || t2.isAlive()) {

        }

        System.out.println("finished");

    }

}

在这里插入图片描述

2.1.1 调试技巧 - 看线程的生命周期

public class SycchronizedObjecfCodeBlock2 implements Runnable {

    static SycchronizedObjecfCodeBlock2 instance = new SycchronizedObjecfCodeBlock2();

    @Override
    public void run() {

        synchronized (this) {
            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 t1 = new Thread(instance);
        Thread t2 = new Thread(instance);

        t1.start();
        t2.start();

        while (t1.isAlive() || t2.isAlive()) {

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

    }

}

在这里插入图片描述

  • 断点处右击

  • All : 会把整个 jvm停止，包括其他的线程

  • thread : 只会停止当前的线程
    在这里插入图片描述

  • 线程0： Runnable
    在这里插入图片描述

  • 线程1
    在这里插入图片描述
    在这里插入图片描述

2.1.2 对象锁的形式2-普通方法锁

/**
 * @Description 对象锁实例2-方法锁
 * @Author tzb
 * @Date 2021/1/4 22:55
 * @Version 1.0
 **/
public class SynchronizedObjectMethod3 implements Runnable {

    static SynchronizedObjectMethod3 instance = new SynchronizedObjectMethod3();

    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);

        t1.start();
        t2.start();

        while (t1.isAlive() || t2.isAlive()) {

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

    }

    @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() + " 运行结束");
    }

}

在这里插入图片描述

2.2 类锁

指 synchronized 修饰静态的方法或指定为 Class对象
在这里插入图片描述
在这里插入图片描述

2.2.1 类锁的形式1- 静态方法锁

  • 不加 static
public class SynchronizedClassStatic4 implements Runnable {

    static SynchronizedClassStatic4 instance1 = new SynchronizedClassStatic4();
    static SynchronizedClassStatic4 instance2 = new SynchronizedClassStatic4();

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

    public  synchronized void method() {
        System.out.println("我是类锁的第一种形式：static形式，我叫 " + 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 t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);

        t1.start();
        t2.start();

        while (t1.isAlive() || t2.isAlive()) {

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

    }
}

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

2.2.2 类锁的形式2- .class

  • 反例 this
public class SynchronizedClassClass5 implements Runnable{

    static SynchronizedClassClass5 instance1 = new SynchronizedClassClass5();
    static SynchronizedClassClass5 instance2 = new SynchronizedClassClass5();

    @Override
    public void run() {

    }

    private void method() throws InterruptedException {
        synchronized (this){
            System.out.println("我是类锁的第二种形式：synchronized(*.class)，我叫" +Thread.currentThread().getName());
            Thread.sleep(3000);
            System.out.println(Thread.currentThread().getName()+" 执行完毕");
        }
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);

        t1.start();
        t2.start();

        while (t1.isAlive() || t2.isAlive()) {

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

    }
}

在这里插入图片描述

  • 修改为 .class
    在这里插入图片描述
    在这里插入图片描述
已标记关键词 清除标记
Java高并发之魂：synchronized深度解析 —— 学习笔记
湖边的小屋遗址
05-07 248
Java高并发之魂：synchronized深度解析 —— 学习笔记课程链接 https://www.imooc.com/learn/1086第2章 Synchronized简介代码演示原因分析第3章 Synchronized的两种用法（对象锁和类锁）同步代码块 synchronized (this)synchronized 的参数synchronized 修饰普通方法 （锁对象默认为 this）...
表情包
插入表情
还能输入1000个字符
相关推荐
拉勾网《32个Java面试必考点》学习笔记之四------JVM
格林奥斯汀的博客
03-02 4718
本文为拉勾网《32个Java面试必考点》学习笔记.只是对视频内容进行简单整理,详细内容还请自行观看视频《32个Java面试必考点》.若本文侵犯了相关所有者的权益,请联系:txzw@live.cn.将会删除相关内容 JVMJVM内存模型栈本地方法栈程序计数器堆方法区JMM与内存可见性类加载与卸载加载过程加载机制-双亲委派模式分代回收回收算法考察点加分项真题汇总 JVM是Java运行基础,面试时一定...
Java锁-Synchronized深层剖析
cureking的博客
11-15 128
Java锁-Synchronized深层剖析 前言 Java锁的问题，可以说是每个JavaCoder绕不开的一道坎。如果只是粗浅地了解Synchronized等锁的简单应用，那么就没什么谈的了，也不建议继续阅读下去。如果希望非常详细地了解非常底层的信息，如monitor源码剖析，SpinLock，TicketLock，CLHLock等自旋锁的实现，也不建议看下去，因为本文也没有说得那么深入。本文只...
Java高并发之魂：synchronized深度解析
chenyl
02-24 447
文章目录一、synchronized简介1 synchronized作用1.1 官方翻译1.2 一句话概括synchronized作用1.3 如何实现2 synchronized地位3 不用并发手段的后果3.1 代码实战：两个线程同时a++ ,最后结果会比预计的少 一、synchronized简介 1 synchronized作用 1.1 官方翻译 同步方法支持一种简单的策略来防止线程干扰和内存一...
类锁和对象锁的详解
菜到不行的程序员的博客
12-10 1万+
最近在面试中遇到很多关于多线程的问题，特别是锁的应用，现在我就来说说类锁和对象锁。 对象锁（synchronized method{}）和类锁（static sychronized method{}）的区别 对象锁也叫实例锁，对应synchronized关键字，当多个线程访问多个实例时，它们互不干扰，每个对象都拥有自己的锁，如果是单例模式下，那么就是变成和类锁一样的功能。 对象锁防止在同一个
【并发编程】类锁和对象锁的区别
小七的博客
02-14 72
类锁和对象锁的区别： 对象锁是当前对象实例的锁，只有是同一个对象才会涉及是否做同步 类锁故名思议就是这个class的锁，只要是同类，即使不同的对象也必须同步 例子： 先做一个Person的对象做为锁。代码如下： public class Person { String name; String age; public Person() { } ...
如果synchronized(new Object){} 和 Object obj ＝ new Object(); synchronized(obj){}的区别是什么？
01-28
如果synchronized(new Object){} 和 Object obj ＝ new Object(); synchronized(obj){}的区别是什么？ 主要是在synchronized()中放new Object 是四个线程一起，而放obj对象是一个一个的执行，这是什么原因呢？ 代码： class XianChengDemo { public static void main(String[] args) { Card c = new Card(); Thread t = new Thread(c); Thread t1 = new Thread(c); Thread t2 = new Thread(c); Thread t3 = new Thread(c); t.start(); t1.start(); t2.start(); t3.start(); }} class Card implements Runnable{ private static int cards = 100; Object obj = new Object(); public void run() { while(true) { synchronized(obj) { if(cards>0) { try{Thread.sleep(10);}catch(Exception e){} System.out.println(Thread.currentThread().getName()+"------"+cards--); } else{ break; } } } }}
方法锁，对象锁，类锁区别
Large_beaR的博客
08-13 2万+
原文链接 首先的明白Java中锁的机制synchronized 在修饰代码块的时候需要一个reference对象作为锁的对象. 在修饰方法的时候默认是当前对象作为锁的对象. 在修饰类时候默认是当前类的Class对象作为锁的对象. 线程同步的方法：sychronized、lock、reentrantLock分析 方法锁（synchronized修饰方法时）通过在方法声明中加入 sync
从头认识多线程-2.14 由同步的synchronized (newobject()) 引起的异步现象和脏读
raylee2007的专栏
05-07 4972
这一章节我们来讨论一下由同步的synchronized (newobject()) 引起的异步现象。1.代码清单package com.ray.deepintothread.ch02.topic_14; /** * * @author RayLee * */ public class AsynchOfSynchWithUnSameObject { public static void
Java知识体系最强总结(2020版)
ThinkWon的博客
12-18 45万+
更新于2019-12-15 10:38:00 本人从事Java开发已多年，平时有记录问题解决方案和总结知识点的习惯，整理了一些有关Java的知识体系，这不是最终版，会不定期的更新。也算是记录自己在从事编程工作的成长足迹，通过博客可以促进博主与阅读者的共同进步，结交更多志同道合的朋友。特此分享给大家，本人见识有限，写的博客难免有错误或者疏忽的地方，还望各位大佬指点，在此表示感激不尽。 文章目录...
Java高并发之魂-synchronized深度解析 学习笔记（6）- 面试和总结
一角残叶的博客
02-07 20
1 synchronized使用注意点 锁对象不能为空 作用域不宜太大 避免死锁 2 如何选择 Lock 和 synchronized 尽量都不使用，用 java.util包下的各种工具类 优先使用 synchronized 3 多线程访问同步方法的各种具体情况 2 思考 2.1 多个线程等待同一个 synchronized锁的时候，JVM如何选择下一个获取的是哪个线程？ 内部锁调动机制 2.2 synchronized 使得同时只有一个线程可以执行，性能较差，有什么方法可以提升性能
透彻理解 Java synchronized 对象锁和类锁的区别
zhujiangtaotaise的专栏
02-17 2万+
synchronized 加到 static 方法前面是给class 加锁，即类锁；而synchronized 加到非静态方法前面是给对象上锁。这两者的区别我用代码来演示下： 对象锁和类锁是不同的锁，所以多个线程同时执行这2个不同锁的方法时，是异步的。 在Task2 中定义三个方法 doLongTimeTaskA和doLongTimeTaskB是类锁，而doLongTimeTaskC是对象锁。pub
类锁和对象锁的简单区别
一缕清风伴你左右的博客
06-26 233
1.用static 修饰的方法再加上sychonized 相当于是一个类锁，类名加方法名就能访问这个方法    对象锁，是指只有那个对象加上方法名才能访问的2.同步通信和异步通信的区别  同步：我叫你吃饭，你若暂时有事情我就一直在那等，不干别的事情，直到你忙完。    异步：我叫你吃饭，你若暂时有事情，我就先撤，干点别的，你忙完了再通过某种方式，如电话，通知我。这两者没有什么好不好之分，适用场景决...
Java锁
Faith的博客
05-31 391
Java的锁分为对象锁和类锁。 　　1. 当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内针对该对象的操作只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。 　　2. 然而，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。 　　3. 尤其关键
Synchronized方法锁、对象锁、类锁区别
JerryWu145的专栏
04-04 2万+
引言synchronized，这个东西我们一般称之为”同步锁“，他在修饰代码块的时候需要传入一个引用对象作为“锁”的对象。 在修饰方法的时候，默认是当前对象作为锁的对象 在修饰类时，默认是当前类的Class对象作为所的对象 故存在着方法锁、对象锁、类锁 这样的概念 那么我们来大致看一下这三种锁方法锁（synchronized修饰方法时）通过在方法声明中加入synchronized关键字来...
对象锁和类锁
王利峰的专栏
02-08 139
<br />对象锁<br />当一个对象中有synchronized method或synchronized block的时候调用此对象的同步方法或进入其同步区域时，就必须先获得对象锁。如果此对象的对象锁已被其他调用者占用，则需要等待此锁被释放<br />同步静态方法/静态变量互斥体<br />由于一个class不论被实例化多少次，其中的静态方法和静态变量在内存中都只由一份。所以，一旦一个静态的方法被申明为synchronized。此类所有的实例化对象在调用此方法，共用同一把锁，我们称之为类锁。一旦一个
©️2020 CSDN 皮肤主题: 书香水墨 设计师:CSDN官方博客 返回首页