JUC：synchronized详解与线程八锁问题解析

于 2024-03-28 09:38:18 发布
阅读量1k 收藏 20
点赞数 31
分类专栏： JUC 文章标签： java 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cosmoshhhyyy/article/details/137076540
版权
本文分析了`synchronized`在Java中的应用，介绍了对象锁与类锁的区别，以及八种典型线程同步场景：实例方法、静态方法和对象/类锁的交互作用。
摘要由CSDN通过智能技术生成

文章目录

synchronized

synchronized俗称对象锁，只有获取了锁的线程才能执行被锁住的代码。

有且只有一个线程能获取对象锁。既可以让线程之间互斥访问被锁住的对象。

即使线程切换，没有锁也运行不了临界区中的代码，这样就可以保证读写的原子性，那么就一定正确。

代码示例

@Slf4j(topic = "c.Test3")
public class st3 {
    static int count = 0;
    static Object lock = new Object();
    
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                synchronized (lock) {
                    count++;
                }
            }
        }, "t1");

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                synchronized (lock){
                    count--;
                }
            }
        }, "t2");

        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("{}",count);
    }
}

在这里插入图片描述

面向对象改进：

@Slf4j(topic = "c.Test3")
public class st3 {
    public static void main(String[] args) throws InterruptedException {
        Lock lock = new Lock();
        Thread t1 = new Thread(() -> {
            for (int j = 0; j < 5000; j++) {
                lock.incr();
            }
        }, "t1");

        Thread t2 = new Thread(() -> {
            for (int j = 0; j < 5000; j++) {
                lock.decr();
            }
        }, "t2");

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

        log.debug("count: {}" , lock.getCount());
    }

}

class Lock{
    private int count = 0;

    public void incr() {
        synchronized(this) {
            count++;
        }
    }

    public void decr() {
        synchronized (this) {
            count--;
        }
    }

    public int getCount() {
        return count;
    }
}

在这里插入图片描述

一样的只不过，在类方法里调用，锁的是当前对象this。

方法上加synchronized

加在普通方法上是对象锁，加载静态方法上是类锁。
而不加锁的方法不受任何影响。

class Test{
    public synchronized void test() {

    }
}
等价于
class Test{
    public void test() {
        synchronized(this) {

        }
    }
}

class Test{
    public synchronized static void test() {
        
    }
}
等价于
class Test{
    public static void test() {
        synchronized(Test.class) {

        }
    }
}

注意：不要有误区，不要认为类锁被锁后其类对应的所有对象锁也不能再执行，类锁锁住的是类对象，也是一个对象而已，也就是Class c = xx.getClass()这个对象。

所以我认为没必要区分什么锁类锁对象啥的，都是锁一个对象。只不过一个锁的该类的对象，一个锁的该类的Class对象。不过我们通常将锁一个类叫做类锁而已。

线程八锁

"线程八锁"通常是指Java中关于多线程同步的八种情况，这些情况是基于对象锁的不同组合而产生的。这些情况包括对实例方法和静态方法的访问，以及对普通对象和Class对象的访问。
对于非静态同步方法，锁的是当前实例对象。
对于静态同步方法，锁的是当前类的Class对象。
对于同步方法块，锁的是括号里配置的对象。

下面我们就来全面解析吧。

No.1

class Number{
    public synchronized void a() {
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}

public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n1.b(); }).start();
}

a、b锁对象，互斥，执行顺序随机。
答案：
1、2 或
2、1

No.2

class Number{
    public synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}

public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n1.b(); }).start();
}

a、b锁对象、互斥，执行顺序随机。
答案：1s、1、2 或
2、1s、1

No.3

class Number{
    public synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
    public void c() {
        log.debug("3");
    }
}

public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n1.b(); }).start();
    new Thread(()->{ n1.c(); }).start();
}

a、b锁对象，c普通方法，同一对象的a、b互斥、普通方法不受影响，随时可以执行。
答案：3、2、1s、1 或
3、1s、1、2 或
2、3、1s、1

No.4

class Number{
    public synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}

public static void main(String[] args) {
    Number n1 = new Number();
    Number n2 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n2.b(); }).start();
}

a、b锁对象，但是调用对象不同，互不影响。
答案：
2、1s、1

No.5

class Number{
    public static synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}

public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n1.b(); }).start();
}

a锁对象、b锁类（Class对象），互不影响。
答案：
2、1s、1

No.6

class Number{
    public static synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public static synchronized void b() {
        log.debug("2");
    }
}

public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n1.b(); }).start();
}

a、b锁类，互斥，执行顺序随机。
答案：
1s、1、2 或
2、1s、1

No.7

class Number{
    public static synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}

public static void main(String[] args) {
    Number n1 = new Number();
    Number n2 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n2.b(); }).start();
}

a锁类、b锁对象，但是调用对象和方法都不同，互不影响。
答案：
2、1s、1

No.8

class Number{
    public static synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public static synchronized void b() {
        log.debug("2");
    }
}

public static void main(String[] args) {
    Number n1 = new Number();
    Number n2 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n2.b(); }).start();
}

a、b都是锁类、虽然是不同对象调用，但是他俩锁的类，互斥，执行顺序随机。
答案：
1s、1、2
2、1s、1

Cosmoshhhyyy
关注
  • 31
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
synchronized8锁学习总结
ADB2
03-14 75
通过8种情况演示锁运行案例，看看我们到底锁的是什么。输出结果我会放在最底下。可以思考一下，然后对照，代码都是基于Java8运行。
八锁现象带你了解 synchronized 到底是锁什么？
qq_44613591的博客
11-09 365
什么是八锁现象？ 八锁现象就是加锁的地方不一样，像加在普通方法，静态方法等，可以帮我们搞懂锁锁住的东西是什么。 第一种：标准情况下，两个线程先打印 发短信还是 打电话？ //标准情况下，两个线程先打印 发短信还是 打电话？ public class Test1 { public static void main(String[] args) { Phone phone = new Phone(); //锁的存在 new Thread(()-
synchronized - 八锁问题及扩展
江南烟雨却痴缠丶
11-24 954
通过8锁问题，可以大致清楚synchronized是锁的什么东西。通过对8锁问题的扩展，可以进一步理解synchronized。 8锁问题 1、一个对象，两个synchronized方法，一个方法睡眠 public class LockTest { public static void main(String[] args) { Phone phone = new Phone(); // 一个Phone对象 new Thread(() -> {
synchronized：锁的对象到底是谁？快速理解八锁现象
saya21的博客
07-24 887
通过总结和例子帮助快速理解八锁现象。
synchronized 八锁现象，搞懂 synchronized 的使用问题
小熊
10-13 371
一.同一个对象，两个线程分别调用对象的两个加锁方法 package com.example.demo.module.synchronized8Test; import java.util.concurrent.TimeUnit; public class Test { public static void main(String[] args) { Phone phone = new Phone(); new Thread(phone::sendSms,"A"
juc详解juc详解juc详解juc详解juc详解juc详解juc详解
08-02
- `ReentrantLock`可重入锁，提供了与`synchronized`类似的功能，但更灵活，支持公平与非公平策略。 - `ReadWriteLock`读写锁，允许多个读取线程同时访问，写入时互斥。 理解并熟练运用JUC库是提升Java并发编程...
JUC代码演示 Java多线程并发
最新发布
05-03
在给定的代码示例中，通过以下方式设置了一个名为`ydy`的守护线程： ```java Thread thread = new Thread(() -> { System.out.println(Thread.currentThread().getName() + "::" + Thread.currentThread()....
Java 多线程与并发(11-26)-JUC锁- ReentrantLock详解.pdf
07-26
Java中的ReentrantLock是Java并发包（java.util.concurrent.locks）中的一个高级锁，它是可重入的，意味着一个线程可以多次获取同一锁。在深入ReentrantLock之前，我们首先需要了解Java并发编程的基础，特别是Java...
Java 多线程与并发(12-26)-JUC锁- ReentrantReadWriteLock详解.pdf
07-26
这个锁提供了比标准的synchronized关键字更细粒度的控制，允许多个线程同时读取共享资源，但只允许一个线程写入。ReentrantReadWriteLock包含两种类型的锁：读锁（ReadLock）和写锁（WriteLock），它们可以独立地被...
Java多线程Atomic包操作原子变量与原子类详解
08-28
总的来说，Java的`Atomic`包提供了一组强大的工具，可以帮助开发者在多线程环境下实现高效且线程安全的代码，避免了锁的复杂性和性能开销，是并发编程中不可或缺的一部分。正确理解和使用这些原子类，可以大大提高...
synchronized八锁现象理解
lczcxyit的博客
04-19 1837
八锁就是关于锁的八个问题 前提A方法 睡4秒 B方法直接执行 synchronized 无static 锁的是方法的调用者 谁先拿到锁谁谁先执行 两个Synchronized 谁先执行 谁输出(同一对象调用）A先 一个写Sy 一个无Sy 不影响 即便同一个对象调用 B先 *static 静态方法 锁类 即便两个类的对象调用也是 一个对象调用 A先 （同一对象）一个Static 一个无static 拿到的的不是同一个锁 一个类锁 一个对象锁 不影响 B先输出 （不同对象）.
JAVA中synchronized修饰方法的8锁问题
weixin_43907440的博客
04-22 430
JAVA中synchronized锁的总结 前提：phone类中有两个synchronized修饰的同步方法，让两个线程分别去执行这两个方法，判断谁先输出。 //基础代码，线程A\B分别执行send()和call() public class LockDemo { public static void main(String[] args) { Phone phone = ...
java的8锁问题
toBeMN的博客
04-13 2632
正经学徒，佛系记录，不搞事情 8锁即8个关于锁执行顺序的问题 解决问题前，首先需要明白的是 synchronized 只会锁两样东西，一样是调用的对象，一样是Class 问题一：两个普通的锁方法，new一个对象调用，调用过程中间睡1秒，执行结果是什么 public class Test { public static void main(String[] args) thro...
synchronized8锁问题
zds448588952的博客
06-09 126
synchronized8锁问题
多线程synchronized对象锁与静态锁之间的8锁问题理解
m0_52889702的博客
02-02 604
8锁问题 锁1：多个线程使用同一对象分别调用不同带有带synchronized关键字且非静态的方法 锁2：在锁1基础上，增加A线程执行的方法的执行时间，使得B有机会参与执行 锁3：多个线程使用同一对象，一个线程执行带有对象锁的方法，一个线程执行普通方法 锁4：多个线程使用不同对象分别调用不同带有对象锁的方法 锁5：多个线程同一个对象分别调用对各自静态锁的方法 锁6：多个线程同多个对象分别调用对各自静态锁的方法 锁7：多个线程同一个对象分别调用对象锁的方法和静态锁的方法 锁8：多个线程不同对象分别调用对象锁的
synchronize的8锁现象带你彻底了解
烟花易冷
09-12 368
关于锁的8个问题前言例子1例子2例子3例子4 前言 synchronize的8锁现象，其实就是利用锁的8种应用场景的代码，带你彻底搞懂： synchronized 锁的对象是方法的调用者 下面我们开始看例子 例子1 public class Test1 { public static void main(String[] args) { Phone phone = new Phone(); //这里注意不是先调用 phone.sendSms()，而是因为锁的存在
JAVA并发编程的8锁问题（synchronized，static synchronized和普通方法调用）
Dream_6666的博客
08-22 237
通过示例说明：（注意代码中的延时问题） 情况1、2 /* 8锁，就是锁的8个问题 1.标准情况下（只有上面的延迟），两个线程先打印发短信还是打电话? 1.发短信 2.打电话 （锁的是同一个对象即方法的调用者，所以是并发） 2.sendSms延迟4秒，两个线程先打印发短信还是打电话? 1.发短信 2.打电话 （锁的是同一个对象即方法的调用者，所以是并发），synchronized 锁的对象是方法的调用者！ */ public class Test1 {
八锁现象——synchronized关键字实战详解
欢迎。
05-24 1468
synchronized关键字到底锁的是谁？
synchronized的线程八锁问题
蒋大钊的博客
02-04 462
synchronized线程八锁问题可以很好地辨析学习synchronized锁的是哪个对象。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Cosmoshhhyyy

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值