并发编程 synchronized (二) 两种锁

最新推荐文章于 2023-04-16 10:46:34 发布
最新推荐文章于 2023-04-16 10:46:34 发布
阅读量272 收藏
点赞数
分类专栏： 并发 文章标签： Java 并发编程 synchronized
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45839708/article/details/119530924
版权

目录

对象锁

定义

对象锁例子

在普通方法上加锁(相同对象调用相同方法)

对当前对象加锁(相同对象调用相同方法)

不同对象调用相同方法 && 相同对象调用不同方法

类锁

定义

类锁例子

在静态方法上加锁(不同对象调用相同方法)

​

对当前类加锁(不同对象调用相同方法)

不同对象调用不同方法

线程八锁

 第一锁

第二锁

第三锁(难点)

第四锁

第五锁(难点)

第六锁

第七锁

第八锁

对象锁

定义

形如：

synchronized void method(){ // 在普通成员方法上加锁
    // 临界区
}

void method(){
    synchronized(this){ // 锁住当前对象
        // 临界区
    }
}

两种方式的临界区，对于同一个对象是等效的

对象锁例子

在普通方法上加锁(相同对象调用相同方法)

package com.juc.ppy.synchronize;

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.MethodSynchronized")
public class MethodSynchronized {
    public MethodSynchronized(){ // 每次创建新对象，都打印出该对象的 hash 码
        log.debug("创建了 MethodSynchronized 新对象 {}", this.hashCode());
    }

    public synchronized void getTime1(){ // 在普通成员方法上加锁
        try{
            log.debug("在普通方法加锁");
            Thread.sleep(2000); // sleep() 不会释放锁，用来证明锁起作用了
        }catch (Exception e){
            e.printStackTrace();
        }
        log.debug("结束");
    }
}

class Test3{
    public static void main(String[] args) throws InterruptedException {
        MethodSynchronized ms = new MethodSynchronized();

        Thread t1 = new Thread(() -> { // 线程 1 调用 getTime1()
            ms.getTime1();
        }, "t1");

        Thread t2 = new Thread(() -> { // 线程 2 调用 getTime1()
            ms.getTime1();
        }, "t2");

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

① 第 2 秒创建出对象 ms

② 紧接着线程 t1 获取到锁，开始执行；第 4 秒结束，释放锁

③  线程 t2 获取到锁，开始执行；第 6 秒结束

综上：t1、t2 共用 ms 这一把锁

对当前对象加锁(相同对象调用相同方法)

@Slf4j(topic = "c.MethodSynchronized")
public class MethodSynchronized {
    public MethodSynchronized(){ // 每次创建新对象，都打印出该对象的 hash 码
        log.debug("创建了 MethodSynchronized 新对象 {}", this.hashCode());
    }

    public void getTime2(){
        synchronized (this){ // 在当前对象上加锁
            try{
                log.debug("synchronized (this)");
                Thread.sleep(2000);
            }catch (Exception e){
                e.printStackTrace();
            }
            log.debug("结束");
        }
    }
}

class Test4{
    public static void main(String[] args) throws InterruptedException {
        MethodSynchronized ms = new MethodSynchronized();

        Thread t1 = new Thread(() -> {
            ms.getTime2();
        }, "t1");

        Thread t2 = new Thread(() -> {
            ms.getTime2();
        }, "t2");

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

情况与上面一样，说明这两种加锁方式是等效的 

不同对象调用相同方法 && 相同对象调用不同方法

@Slf4j(topic = "c.MethodSynchronized")
public class MethodSynchronized {
    public MethodSynchronized(){ // 每次创建新对象，都打印出该对象的 hash 码
        log.debug("创建了 MethodSynchronized 新对象 {}", this.hashCode());
    }

    public void method(){
        synchronized (this){ // 在当前对象上加锁
            try{
                log.debug("先芜湖~");
                Thread.sleep(2000);
            }catch (Exception e){
                e.printStackTrace();
            }
            log.debug("再起飞!");
        }
    }
}

class Test6{
    public static void main(String[] args) throws InterruptedException {
        MethodSynchronized ms1 = new MethodSynchronized();
        MethodSynchronized ms2 = new MethodSynchronized();

        Thread t1 = new Thread(() -> {
            ms1.method();
        }, "t1");

        Thread t2 = new Thread(() -> {
            ms2.method();
        }, "t2");

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

① 创建了 ms1、ms2 两个对象

② 第 59 秒 t1、t2 几乎同时执行

③ 第 1 秒 t1、t3 几乎同时结束

综上：锁没起作用

@Slf4j(topic = "c.MethodSynchronized")
public class MethodSynchronized {
    public MethodSynchronized(){ // 每次创建新对象，都打印出该对象的 hash 码
        log.debug("创建了 MethodSynchronized 新对象 {}", this.hashCode());
    }

    public synchronized void getTime1(){ // 在普通成员方法上加锁
        try{
            log.debug("在普通方法加锁");
            Thread.sleep(2000); // sleep() 不会释放锁，用来证明锁起作用了
        }catch (Exception e){
            e.printStackTrace();
        }
        log.debug("结束");
    }

    public void getTime2(){
        synchronized (this){ // 在当前对象上加锁
            try{
                log.debug("synchronized (this)");
                Thread.sleep(2000);
            }catch (Exception e){
                e.printStackTrace();
            }
            log.debug("结束");
        }
    }
}

class Test7{
    public static void main(String[] args) throws InterruptedException {
        MethodSynchronized ms = new MethodSynchronized();

        Thread t1 = new Thread(() -> { // t1 调用方法 1
            ms.getTime1();
        }, "t1");

        Thread t2 = new Thread(() -> { // t2 调用方法 2
            ms.getTime2();
        }, "t2");

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

总结：同一个对象属于同一把锁

① 不同对象调用相同方法，锁不起作用；是因为 ms1、ms2 相当于两把锁，分别被 t1、t2 获取；锁不同，临界区就不一样，它们相互之间是不影响的，各执行各的

② 相同对象调用不同方法，锁起作用；对象相同，锁就相同，临界区就相同

类锁

定义

形如：

static synchronized void method(){ // 在静态成员方法上加锁
    // 临界区
}

void method(){
    synchronized(类名.class){ // 对当前类加锁
        // 临界区
    }
}

两种方式的临界区，对于同一个类是等效的

类锁例子

在静态方法上加锁(不同对象调用相同方法)

@Slf4j(topic = "c.ClassSynchronized")
public class ClassSynchronized {
    public ClassSynchronized(){ // 每次创建新对象，都打印出该对象的 hash 码
        log.debug("创建了 ClassSynchronized 新对象 {}", this.hashCode());
    }

    private static synchronized void getTime0(){ // 在静态成员方法上加锁
        try{
            log.debug("在静态方法加锁");
            Thread.sleep(2000); // sleep() 不会释放锁，用来证明锁起作用了
        }catch (Exception e){
            e.printStackTrace();
        }
        log.debug("结束");
    }

    public void getTime(){ // 最终调用的方法；用来证明：即使是不同对象，锁也是一样的
        getTime0();
    }
}

class Test0{
    public static void main(String[] args) throws InterruptedException {
        ClassSynchronized cs1 = new ClassSynchronized(); // 创建对象 1
        ClassSynchronized cs2 = new ClassSynchronized(); // 创建对象 2

        Thread t1 = new Thread(() -> {
            cs1.getTime(); // 线程 1 中调用对象 1 的普通方法
        }, "t1");

        Thread t2 = new Thread(() -> {
            cs2.getTime();
        }, "t2"); // 线程 2 中调用对象 2 的普通方法

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

① 第 36 秒创建出对象 cs1、cs2

② 紧接着线程 t1 获取到锁，开始执行；第 38 秒结束，释放锁

③  线程 t2 获取到锁，开始执行；第 40 秒结束

综上：虽然 cs1、cs2 是两个不同对象，但是属于同一个类，同一个临界区，t1、t2 它们共用一把类锁

对当前类加锁(不同对象调用相同方法)

@Slf4j(topic = "c.ClassSynchronized")
public class ClassSynchronized {
    public void getTime1(){
        synchronized (ClassSynchronized.class){ // 直接锁住当前类
            try{
                log.debug("synchronized (ClassSynchronized.class)");
                Thread.sleep(2000);
            }catch (Exception e){
                e.printStackTrace();
            }
            log.debug("结束");
        }
    }
}

class Test1{
    public static void main(String[] args) throws InterruptedException {
        ClassSynchronized cs1 = new ClassSynchronized();
        ClassSynchronized cs2 = new ClassSynchronized();

        Thread t1 = new Thread(() -> {
            cs1.getTime1();
        }, "t1");

        Thread t2 = new Thread(() -> {
            cs2.getTime1();
        }, "t2");

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

情况与上面一样，说明这两种加锁方式是等效的 

不同对象调用不同方法

@Slf4j(topic = "c.ClassSynchronized")
public class ClassSynchronized {
    public ClassSynchronized(){ // 每次创建新对象，都打印出该对象的 hash 码
        log.debug("创建了 ClassSynchronized 新对象 {}", this.hashCode());
    }

    public void method1(){ // 方法 1 芜湖
        synchronized (ClassSynchronized.class){ // 直接锁住当前类
            try{
                log.debug("芜湖~");
                Thread.sleep(2000);
            }catch (Exception e){
                e.printStackTrace();
            }
            log.debug("芜湖~");
        }
    }

    public void method2(){ // 方法 2 起飞
        synchronized (ClassSynchronized.class){ // 直接锁住当前类
            try{
                log.debug("起飞!");
                Thread.sleep(2000);
            }catch (Exception e){
                e.printStackTrace();
            }
            log.debug("起飞!");
        }
    }
}

class Test2{
    public static void main(String[] args) throws InterruptedException {
        ClassSynchronized cs1 = new ClassSynchronized();
        ClassSynchronized cs2 = new ClassSynchronized();

        Thread t1 = new Thread(() -> {
            cs1.method1(); // cs1 调用 芜湖
        }, "t1");

        Thread t2 = new Thread(() -> {
            cs2.method2(); // cs2 调用 起飞
        }, "t2");

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

不同对象，调用不同方法，锁依旧起作用；足以说明对于同一个类都属于同一把锁 

线程八锁

 第一锁

@Slf4j(topic = "c.Number")
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();
}

结果：12 或 21

第二锁

@Slf4j(topic = "c.Number")
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();
}

结果：1s 后 12 或 2 过 1s 后 1

第三锁(难点)

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();
}

结果：3 过 1s 后 12 或 32 过 1s 后 1 或 23 过 1s 后 1

说明：方法 c 没有加锁；sleep 会释放时间片，就算第二个线程获得了时间片，由于没有锁进入阻塞；所以不可能出现 "13" 这种结果

第四锁

@Slf4j(topic = "c.Number")
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();
}

结果：2 1s 后 1

第五锁(难点)

@Slf4j(topic = "c.Number")
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();
}

结果：2 1s 后 1

说明：a 加的是类锁，b 加的是对象锁；相当于不同锁，互不影响

第六锁

@Slf4j(topic = "c.Number")
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();
}

结果：2 1s 后 1 或 1s 后 12

第七锁

@Slf4j(topic = "c.Number")
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();
}

结果：2 1s 后 1 

第八锁

@Slf4j(topic = "c.Number")
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();
}

结果：2 1s 后 1 或 1s 后 12

皮皮杨233
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
并发编程锁之synchronized(二)
欢迎来到技术宅的博客
07-03 1123
锁synchronized并发编程中数据同步需要依赖锁进行控制，上篇博文通过ReentrantLock源码分析也对Lock实现锁机制的大致原理有了一个了解，Lock主要是通过编码的方式实现锁，其核心就是：CAS+循环，CAS原子操作需要依赖底层硬件层特殊的CPU指令。这节我们来看下Java中另一种非常常见的实现同步的方式：synchronized。synchronized主要通过底层JVM进行实现...
synchronized+习题
qq_64684446的博客
04-05 410
多线程应用之synchronized synchronized在多线程中保证代码的原子性 可见性 和一致性 简单总结: 当修饰实例方法时:相当于对当前对象实例加锁 当修饰静态方法时,相当于对当前类加锁 当修饰代码块时,若synchronized(this)即表示对当前对象加锁,synchronized(类.class)表示对当前类加锁引航站 下边是一个银行转账的小例子 @Data class Account { /** * 此处是共享变量 */ private int c
Synchronized详解
张井天的博客
05-24 251
1、说明： 随着JavaSE 1.6 对 Synchronized 进行的各种优化后， Synchronized 并不会显得那么重了。 Synchronized 可以把任何一个 非 null 对象作为锁，锁有个专门的名字 对象监视器（Object Monitor） 2、Synchronized 的三个作用： 原子性： 确保线程互斥的访问同步代码。 可见性：保证共享变量的修改能够及时看见，其实是通过 JMM来保证的 对一个变量 unlock 操作之前，必须要同步到主内存中； 如果一个变量进行lock操
线程用synchronized产生死锁的问题及解决
wycyiyang的博客
04-16 1355
线程用synchronized产生死锁的问题及解决
Synchronized的死锁问题和对其优化
weixin_42759398的博客
04-08 334
此代码的问题在于在`method1`和`method2`中，synchronized嵌套使用了`lock1`和`lock2`，导致当`t1`和`t2`在同时运行时，发生了死锁，虽然该问题出现的概率较小，但金鬃发现这样的问题一旦发生，调试和解决都需要耗费很久。在修改后的代码中，我们将锁按照一定的规则划分为多个段，每个段使用一个锁来保护，通过这种方式，当`t1`获取了一个段的锁时，不会影响到`t2`想要获取另一个段的锁，从而避免了Synchronized的死锁问题。
Java并发编程系列- synchronized
最新发布
06-16
总结来说，`synchronized`在Java并发编程中扮演着核心角色，它通过锁机制确保了共享资源的安全访问，解决了多线程环境下的数据一致性问题。正确理解和使用`synchronized`对于编写高效、线程安全的Java代码至关重要。
Java 并发编程学习笔记之Synchronized简介
09-02
Java并发编程中的Synchronized关键字是Java提供的一种内置锁机制，用于解决多线程环境下的线程安全问题。在Java中，线程安全意味着多个线程访问同一份资源时，能够保持数据的一致性和完整性，避免数据冲突。...
Java并发 synchronized锁住的内容解析
08-25
Java并发synchronized锁住的内容解析是Java并发编程中的一种重要机制，用于解决多线程并发访问同一个资源时可能出现的线程安全问题。通过使用synchronized关键字，可以锁住当前对象的当前方法，使得其他线程访问该...
Java并发编程：Synchronized及其实现原理
12-22
Java并发编程中的Synchronized关键字是实现线程安全的关键工具，它提供了锁机制，确保了多线程环境下的数据一致性与安全性。以下将详细介绍Synchronized的使用及其实现原理。 一、Synchronized基本使用 1. 修饰...
Java多线程并发编程 Synchronized关键字
08-30
4. **两种使用方式**： - **synchronized 方法**：在方法声明前加上`synchronized`关键字，整个方法体被视为同步代码块。 - **synchronized 代码块**：使用`synchronized (对象)`结构，指定一个对象作为锁，同步...
Synchronized详解（上）
qq_41665452的博客
08-03 292
前言 在多线程编程中，会出现多个线程同时访问一个共享、可变资源（共享：资源被多个线程同时访问；可变：资源可被多个线程修改）的情况，这个资源我们称为临界资源，这种资源可能是对象、变量、文件等等； 由于线程执行是不可控的，所以需要采用同步机制来协助对象可变状态访问，即在同一时刻，只能有一个线程访问临界资源，所以被称作同步互斥访问； 在Java中提供了两种方式来实现同步互斥访问：synchronized 和 Lock； 同步器的本质就是加锁，其目的：序列化访问临界资源，即同一时刻只能有一个线程访问临界资源；
Synchronized
weixin_43573186的博客
05-29 195
Synchronized synchronized是java中的关键字，是一种同步锁。 使用方式： 修饰一个代码块，被修饰的方法称为同步方法，其作用的范围是整个代码块，作用的对象是调用这个代码块的对象； 修饰一个方法，被修饰的方法称为同步方法，起作用的范围是整个方法，作用的对象是调用这个方法的对象； 修饰一个静态的方法，其作用的范围是整个静态方法，作用的对象是整个类的所有对象； 修饰一个类，作用的范围是整个类，作用的对象是这个类所有的对象； Synchronized修饰代码块 操作资源类: packag
Java之Synchronized小结
fateasstring的博客
05-10 277
1.Synchronized简介 Synchronized的作用：能够保证在同一时刻最多只有一个线程执行该段代码，以达到保证并发的安全的效果。 Synchronized被Java原生支持，是最基本的互斥同步手段。 2.Synchronized的两种用法（对象锁和类锁） 2.1对象锁 对象锁：包括方法锁（默认锁对象为this当前实例对象）和同步代码块锁（自己指定锁对象）。 对象锁分为两种形式： 代码块形式：手动指定锁对象； 方法锁形式：Synchronized修饰普通方法，锁对象默...
Java中Synchronized的用法（简单介绍）
NeiHan2020的博客
03-04 6104
简单介绍 synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种： 　　1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； 　　2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 　　3. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象； 　　4. 修改一个类，其作用的范围是synchronized后面括号括起来的...
Java 中 synchronized的用法详解(四种用法)
SimpleGZW的博客
08-23 3381
Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。本文给大家介绍java中 synchronized的用法，对本文感兴趣的朋友一起看看吧 Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。 1.方法声明时使用,放在范围操作符(public等)之后,返回类型声明(void等)之前.这时,线程获得的是成员锁,即一次只能有一个线程进入该方法,其他线程要想在此时调用该方法,只能排队等候,当
Synchronized 关键字详解
swadian2008的博客
08-17 610
synchronized 是 Java 中的一种同步机制，用于实现线程之间的互斥和同步。当一个线程需要访问一个对象的同步代码块时，如果这个同步代码块已经被另一个线程所占用，那么当前线程就会被阻塞，直到另一个线程执行完毕并释放锁。只有获取到锁的线程才能执行同步代码块。使用关键字修饰一个方法时，该方法被称为同步方法。当一个线程访问一个对象的同步方法时，其他线程将被阻塞，直到该线程执行完毕并释放锁。同步方法的锁对象是当前实例对象。使用关键字修饰一段代码时，称该代码块为同步代码块。
synchronized同步以及双重检索
时代新人的博客
09-01 1130
一、synchronized同步参考 两个线程同时执行会出错，那么最简单的方法是让CPU执行完一个线程，再执行另一个线程，那么Java中给出了一个非常简单的解决办法，【synchronized】：是一种同步锁。简单解释一下：就是synchronized修饰的代码，同时只能有一个线程执行，即执行完一个线程，再执行另一个，其它需要执行的线程都要排队 。 synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种： 1. 修饰一个代码块，被修饰的代码块称为同步语句块......
synchronized 死锁的原因
java初级学习
12-25 702
死锁： 多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能进行，导致俩个或者多个线程都在等待对方释放资源，都停止执行的情形。一个同步快同时拥有"俩个以上对象的锁"时，就可能会发生死锁的问题。 发生于同步中持有多个对象的锁。 避免死锁的方法：同步中只持有一个对象。...
深入解析Java并发：Synchronized与锁机制
Synchronized的锁对象可以通过两种方式确定：1) 如果明确指定锁对象，例如Synchronized(变量名)，锁就是指定的对象；2) 对于非静态方法，锁对象是调用该方法的对象实例；对于静态方法，锁是类的Class对象。这种设计...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值