Synchronized关键字

最新推荐文章于 2024-05-21 15:37:32 发布
最新推荐文章于 2024-05-21 15:37:32 发布
阅读量84 收藏
点赞数
分类专栏： Java线程与进程 文章标签： java jvm c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58510930/article/details/126032343
版权

概述

原文链接
我们都知道Synchronized是实现线程同步的一个机制，为了使多个线程一次获得某个资源，那么Synchronized到底锁的是什么？？

修饰方法

非静态方法a

非静态方法锁的是对象

下面是两个线程分别执行同一个对象的两个方法，打印是顺序按照线程运行的顺序进行

package 多线程.编程目标与挑战;

import java.util.Date;

/**
 * @author zss
 * @date 2022-07-28 10:42:09
 * @description 
 */
public class RaceExample {

    public static void main(String[] args) {
        App A = new App();

        new Thread(() -> {
            A.sayHello();
        }, "thread1").start();
        new Thread(() -> {
            A.sayGood();
        }, "thread").start();
    }
}

class App {
    public  void sayHello() {
        System.out.println("hello");
    }

    public void sayGood() {
        System.out.println("good");
    }
}

image-20220728114943864

那么现在我们给这个方法加上，线程同步机制Synchronized，同时使sayHello方法沉睡10秒，那么现在我们仍旧执行上面的方法，那么按照这个方法，应该先输出good，10秒后在输出hello

package 多线程.编程目标与挑战;

import java.util.Date;

/**
 * @author zss
 * @date 2022-07-28 10:42:09
 * @description 竞态的展示
 */
public class RaceExample {

    public static void main(String[] args) {
        App A = new App();

        new Thread(() -> {
            System.out.println("第一个线程开始了");
            A.sayHello();
        }, "thread1").start();
        new Thread(() -> {
            System.out.println("第二个线程开始了");
            A.sayGood();
        }, "thread").start();
    }
}

class App {
    public synchronized void sayHello() {
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("hello");
    }

    public synchronized void sayGood() {
        System.out.println("good");
    }
}

image-20220728115657858

但是我们执行之后发现，竟然整个都等待了10秒钟，good也没有先行出来。

那是因为在这个过程中， App A = new App()中A对象被锁住了，线程二明明已经开始，但是得不到A对象，而sayGood方法也因为线程同步机制所申请的资源无法得到

但是如果对于一个普通方法来说，并不会产生这个问题，假如SayHello是用Synchronized修饰，而sayGood仅仅是一个普通方法，那么就算A被锁，sayGood仍旧可以获得资源

class App {
    public synchronized void sayHello() {
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("hello");
    }

    public  void sayGood() {
        System.out.println("good");
    }
}

image-20220728120019904

静态方法

对于静态方法来说，我们锁定的是类，也就是上述方法中的APP，而不是实例对象A

首先我们先不适用静态方法，但是我们创建两个对象实例A与B，我们会发现两个方法虽然加了锁，但是对象不同，还是无法锁住

package 多线程.编程目标与挑战;

import java.util.Date;

/**
 * @author zss
 * @date 2022-07-28 10:42:09
 * @description 竞态的展示
 */
public class RaceExample {

    public static void main(String[] args) {
        App A = new App();
        App B=new App();

        new Thread(() -> {
            System.out.println("第一个线程开始了");
            A.sayHello();
        }, "thread1").start();
        new Thread(() -> {
            System.out.println("第二个线程开始了");
            B.sayGood();
        }, "thread").start();
    }
}

class App {
    public synchronized void sayHello() {
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("hello");
    }

    public synchronized void sayGood() {
        System.out.println("good");
    }
}

image-20220728120512843

那么现在我们更改为静态方法，因为锁定的是APP这个对象，那么现在还是要等待一个线程释放APP这个类之后，才可以继续执行

package 多线程.编程目标与挑战;

import java.util.Date;

/**
 * @author zss
 * @date 2022-07-28 10:42:09
 * @description 竞态的展示
 */
public class RaceExample {

    public static void main(String[] args) {
        App A = new App();
        App B=new App();

        new Thread(() -> {
            System.out.println("第一个线程开始了");
            A.sayHello();
        }, "thread1").start();
        new Thread(() -> {
            System.out.println("第二个线程开始了");
            B.sayGood();
        }, "thread").start();
    }
}

class App {
    public static synchronized void sayHello() {
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("hello");
    }

    public static synchronized void sayGood() {
        System.out.println("good");
    }
}

image-20220728120618543

代码块

代码块锁的是我们传入的对象

我们首先运行一段普通的代码，此时5个线程开始运行，仅仅是执行的普通的方法

package 多线程.编程目标与挑战;

import java.util.Date;

/**
 * @author zss
 * @date 2022-07-28 10:42:09
 * @description 竞态的展示
 */
public class RaceExample {

    public static void main(String[] args) {
        App A = new App();
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                A.sayHello();
            }, "thread1").start();
        }
    }
}

class App {
    public void sayHello() {
        {
            System.out.println("hello");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("我又说一遍hello");
        }

    }

}

image-20220728121859304

对象实例

现在我们要对这个对象实例进行上锁，那么后面的线程应该等待先前的线程释放 App A = new App()中的A

class App {
    public void sayHello() {
        synchronized(this){
            System.out.println("hello");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("我又说一遍hello");
        }

    }

image-20220728122104395

现在如果我们调整一下main方法中的策略，将main方法移动到for循环内部，每一次都创建一个新的对象，所以这个锁就不会发生作用

image-20220728122228399

image-20220728122316507

类

假如说现在我们锁住这个类APP，那么上面的代码又将会发生不同,类只有一个必须等待线程释放锁

class App {
    public void sayHello() {
        synchronized(App.class){
            System.out.println("hello");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("我又说一遍hello");
        }
    }
}

image-20220728122508107

其他类型

局部变量

我们对局部变量上锁，而这个局部变量仅仅有一个，那么就必须等待释放局部变量，Integer定义的数据是对象

class App {
    public void sayHello() {
        Integer a= 5;
        synchronized(a){
            System.out.println("hello");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("我又说一遍hello");
        }

    }

}

image-20220728123138074

全局变量

我们将这个a作为参数传递进行，那么这个a相当于全局变量，注意参数在main中的位置

package 多线程.编程目标与挑战;

import java.util.Date;

/**
 * @author zss
 * @date 2022-07-28 10:42:09
 * @description 竞态的展示
 */
public class RaceExample {

    public static void main(String[] args) {
        Integer a=5;
        for (int i = 0; i < 5; i++) {
            App A = new App();
            new Thread(() -> {
                A.sayHello(a);
            }, "thread1").start();
        }
    }
}

class App {
    public void sayHello(Integer a) {
        synchronized(a){
            System.out.println("hello");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("我又说一遍hello");
        }

    }

}

image-20220728123334897

那么假如说我们每一个方法都传入不同的a，那么结果也会不同

package 多线程.编程目标与挑战;

import java.util.Date;

/**
 * @author zss
 * @date 2022-07-28 10:42:09
 * @description 竞态的展示
 */
public class RaceExample {

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            Integer a=i;
            App A = new App();
            new Thread(() -> {
                A.sayHello(a);
            }, "thread1").start();
        }
    }
}

class App {
    public void sayHello(Integer a) {
        synchronized(a){
            System.out.println("hello");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("我又说一遍hello");
        }

    }

}

image-20220728123521414

但是如果传入的相同的a，那么他的结果还是需要排队的，当然你这里如果使用Integer a=new Integer(5);这个构造器，那么结果又会不相同，这个就涉及到常量池和堆的问题，和String类很相似，而且同时由于Integer的特殊性，Integer a=5;使用-128-127都会在常量池中产生，而这个范围之外会在堆中产生，大家可以多尝试

image-20220728123737092

偷掉月亮的阿硕
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
synchronized关键字
一切有为法，如梦亦如幻，如露亦如电，应作如是观。
10-23 229
1.Synchronized关键字概述 synchronized关键字解决的是多个线程之间访问资源的同步性，synchronized关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。 另外，在 Java 早期版本中，synchronized属于重量级锁，效率低下。 为什么呢？ 因为监视器锁（monitor）是依赖于底层的操作系统的Mutex Lock来实现的，Java 的线程是映射到操作系统的原生线程之上的。如果要挂起或者唤醒一个线程，都需要操作系统帮忙完成，而...
Synchronized关键字详解
qq_37134175的博客
07-30 241
一、Synchronized关键字 synchronized 内置锁是一种对象锁，作用粒度是对象而非引用变量，可将任何非空对象当做“锁”，可用来修饰方法或代码块以保证同一时刻最多只有一个线程执行被修饰方法或代码块。synchronized 修饰的地方不相同，但它的锁都在一个对象上，它持有相同对象锁的地方发产生互斥，而不是只有当前所指的代码块或者方法体。 相对于显示锁，synchroniz...
synchronized关键字的使用
qq_44286009的博客
05-21 398
synchronized 是 Java 中的一个关键字，用于实现多线程之间的同步访问。它用于确保在多线程环境中，同一时间只有一个线程可以执行某个方法或代码块。这是通过锁定一个对象或类来实现的，以防止多个线程同时访问共享资源，从而导致数据不一致或其他并发问题。在方法声明中使用synchronized，将其放在范围操作符（如public）后，返回类型声明（如void）之前。这样，当一个线程进入该方法时，其他线程将被阻塞，直到该线程退出该方法。例如：// 方法体。
synchronized关键字详解
LYQ20010417的博客
04-13 4481
内容包括：synchronized的锁类型、实际应用、实现原理、锁升级过程和锁优化等
举例讲解Java中synchronized关键字的用法
09-02
在Java编程语言中，`synchronized`关键字是一个非常重要的概念，它主要用于多线程环境中的线程同步，确保共享资源的正确访问，防止数据不一致性。以下是对`synchronized`关键字使用方法的详细讲解： 1. **修饰实例...
Java synchronized关键字使用方式及特性解析
08-25
需要注意的是，synchronized关键字的使用需要遵守一定的原则，例如避免使用synchronized关键字在循环语句中，以免出现死锁等问题。此外，synchronized关键字也可以与其他线程同步工具结合使用，以实现更复杂的线程...
简单了解Java synchronized关键字同步
08-25
Java synchronized关键字同步详解 Java 中的 synchronized 关键字是用于实现线程同步的重要机制。下面我们将详细介绍 synchronized 关键字的使用方法和原理。 synchronized 关键字的作用 synchronized 关键字可以...
JAVA面试题 简谈你对synchronized关键字的理解
08-25
JAVA面试题简谈你对synchronized关键字的理解 Synchronized关键字是Java语言中的一种同步机制，主要用于解决多线程之间的同步问题。下面我们将详细介绍synchronized关键字的特性、用法和注意事项。 Synchronized...
java synchronized关键字的用法
09-02
0; public synchronized void...综上所述，synchronized 关键字是 Java 中实现线程同步的重要手段，它通过加锁机制保证了线程安全。然而，在实际应用中，我们需要根据具体场景选择合适的同步策略，以兼顾性能和正确性。
Java synchronized关键字和Lock接口实现原理
08-25
Java synchronized关键字和Lock接口实现原理 Java 中的 synchronized 关键字和 Lock 接口是两种常用的线程同步机制，它们都可以用来解决并发问题。下面我们将详细介绍 synchronized 关键字和 Lock 接口的实现原理。...
Lock接口与synchronized关键字
04-19
### Lock接口与synchronized关键字详解 #### 一、概述 在Java并发编程中，Lock接口与synchronized关键字都是实现同步的重要工具。它们虽然都用于控制多线程对共享资源的访问，但在使用方式、功能特性及灵活性方面...
Java多线程并发编程 Synchronized关键字
08-30
Java中的`synchronized`关键字是多线程编程中用于实现线程同步的重要机制，它确保了在多线程环境下对共享资源的访问具有互斥性和可见性。这些特性使得`synchronized`成为解决并发问题的关键工具。 1. **同步锁机制*...
java synchronized关键字原理、自定义一把锁来实现同步等
02-19
### Java synchronized 关键字原理与自定义锁实现详解 #### 一、Java synchronized 关键字原理 `synchronized` 是 Java 中的关键字之一，用于实现线程间的同步控制，确保共享资源的安全访问。它主要应用于以下两种...
深入讲解java线程与synchronized关键字
08-31
【深入讲解Java线程与synchronized关键字】 Java中的多线程同步是通过对象锁机制来实现的，synchronized关键字正是这一机制的关键。它确保了在任何时刻，只有一个线程能够访问特定的共享资源，从而避免数据不一致的...
Java中synchronized关键字引出的多种锁 问题
08-25
Java中synchronized关键字引出的多种锁问题 Java 中的 synchronized 关键字可以在多线程环境下用来作为线程安全的同步锁。synchronized 关键字有三种用法，分别为：用在普通方法上，能够锁住当前对象；用在静态方法...
详解java中的synchronized关键字
09-03
在Java编程语言中，`synchronized`关键字是一个重要的并发控制机制，用于确保多线程环境下的数据一致性。本文将深入探讨`synchronized`关键字的使用和功能。 首先，`synchronized`关键字可以应用于方法和代码块，以...
深入理解Java中的synchronized关键字：同步机制与应用
最新发布
07-05
Java提供了多种机制来处理并发问题，其中synchronized关键字是最基本也是最常用的同步手段之一。本文将深入探讨synchronized关键字的工作原理、使用方式以及在实际编程中的应用。 synchronized关键字是Java中实现...
java的线程同步机制synchronized关键字的理解_.docx
10-09
Java 线程同步机制中 synchronized 关键字的理解 Java 的线程同步机制是为了解决多个线程共享同一片存储空间所带来的访问冲突问题。其中，synchronized 关键字是 Java 语言中解决这种冲突的重要机制。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值