史上最全synchronized用法详解

最新推荐文章于 2023-09-22 22:45:17 发布
最新推荐文章于 2023-09-22 22:45:17 发布
阅读量2.8k 收藏 15
点赞数 7
分类专栏： java并发编程 Java并发编程 文章标签： 多线程 并发 同步 锁 异步
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fuyuwei2015/article/details/71656266
版权

Java中synchronized关键字用于代码的同步执行，他可以修饰代码块、方法、this、Object.class，能够保证在多线程环境中只有线程执行。synchronized作用范围越小并发能力越强，下面我们就各种场景来详解举例说明。

多个synchronized(this)代码块并发执行

当一个线程访问类中的synchronized(this)的代码块时，该类中的其他synchronized(this)同步代码处于阻塞状态，例如：

class SynchronizedThis两个synchronized(this)同步代码块
public class SynchronizedThis {
    public void methodA(){
        synchronized(this){
            System.out.println("this A start:"+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("this A end:"+Thread.currentThread().getName());
        }
    }

    public void methodB(){
        synchronized(this){
            System.out.println("this B start:"+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("this B end:"+Thread.currentThread().getName());
        }
    }
}

两个线程类

public class MyThreadA implements Runnable {

    private SynchronizedThis sthis;

    public MyThreadA(SynchronizedThis sthis){
        this.sthis = sthis;
    }

    @Override
    public void run() {
        sthis.methodA();
    }
}
public class MyThreadB implements Runnable {
private SynchronizedThis sthis;

    public MyThreadB(SynchronizedThis sthis){
        this.sthis = sthis;
    }

    @Override
    public void run() {
        sthis.methodB();
    }
}

启动线程类

public class MainThread {
    public static void main(String[] args) {
        SynchronizedThis sthis = new SynchronizedThis();
        MyThreadA threadA = new MyThreadA(sthis);
        Thread TA = new Thread(threadA,"A");
        TA.start();
        MyThreadB threadB = new MyThreadB(sthis);
        Thread TB = new Thread(threadB,"B");
        TB.start();
    }
}

运行结果，ThreadA运行完成之后ThreadB才能继续执行

this A start:A
this A end:A
this B start:B
this B end:B

synchronized(this)代码块与synchronized方法并发执行

当一个线程访问类中的synchronized(this)的代码块时，该类中的其他synchronized方法处于阻塞状态，例如：
class SynchronizedThis一个synchronized(this)同步代码块一个synchronized方法

public class SynchronizedThis {
    public synchronized void methodA(){
        System.out.println("this A start:"+Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("this A end:"+Thread.currentThread().getName());
    }

    public void methodB(){
        synchronized(this){
            System.out.println("this B start:"+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("this B end:"+Thread.currentThread().getName());
        }
    }
}

两个线程类和启动线程类同上
运行结果，线程A运行完成之后线程B才可以运行

this A start:A
this A end:A
this B start:B
this B end:B

synchronized(this)代码块与非synchronized方法并发执行

synchronized(this)代码块与非同步方法之间是不存在锁竞争的，可以并发执行，例如：

public class SynchronizedThis {
    public void methodA(){
        System.out.println("this A start:"+Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("this A end:"+Thread.currentThread().getName());
    }

    public void methodB(){
        synchronized(this){
            for(int i=0;i<5;i++){
                System.out.println("this B start:"+Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("this B end:"+Thread.currentThread().getName());
            }
        }
    }
}

两个线程类和启动线程类同上
运行结果，线程A和线程B并发一起执行了

this A start:A
this B start:B0
this A end:A
this B end:B0
this B start:B1
this B end:B1
this B start:B2
this B end:B2
this B start:B3
this B end:B3
this B start:B4
this B end:B4

多个synchronized(任意对象)之间并发执行

public class SynchronizedThis {

    private String flag = new String();

    public void method(String name){
        synchronized(flag){
            for(int i=0;i<5;i++){
                System.out.println("this "+name+" start:"+Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("this "+name+" end:"+Thread.currentThread().getName());
            }
        }
    }
}

两个线程类

public class MyThreadA implements Runnable {

    private SynchronizedThis sthis;

    public MyThreadA(SynchronizedThis sthis){
        this.sthis = sthis;
    }

    @Override
    public void run() {
        sthis.method("sunwukong");
    }
}
public class MyThreadB implements Runnable {
private SynchronizedThis sthis;

    public MyThreadB(SynchronizedThis sthis){
        this.sthis = sthis;
    }

    @Override
    public void run() {
        sthis.method("zhubajie");
    }
}

启动线程类
同一个SynchronizedThis

public class MainThread {
    public static void main(String[] args) {
        SynchronizedThis sthis = new SynchronizedThis();
        MyThreadA threadA = new MyThreadA(sthis);
        Thread TA = new Thread(threadA,"A");
        TA.start();
        MyThreadB threadB = new MyThreadB(sthis);
        Thread TB = new Thread(threadB,"B");
        TB.start();
    }
}

运行结果，线程B需要等待线程A运行完成之后才执行

this sunwukong start:A
this sunwukong end:A
this sunwukong start:A
this sunwukong end:A
this sunwukong start:A
this sunwukong end:A
this sunwukong start:A
this sunwukong end:A
this sunwukong start:A
this sunwukong end:A
this zhubajie start:B
this zhubajie end:B
this zhubajie start:B
this zhubajie end:B
this zhubajie start:B
this zhubajie end:B
this zhubajie start:B
this zhubajie end:B
this zhubajie start:B
this zhubajie end:B

多个SynchronizedThis

public class MainThread {
    public static void main(String[] args) {
        SynchronizedThis sthis = new SynchronizedThis();
        MyThreadA threadA = new MyThreadA(sthis);
        Thread TA = new Thread(threadA,"A");
        TA.start();
        SynchronizedThis sthis2 = new SynchronizedThis();
        MyThreadB threadB = new MyThreadB(sthis2);
        Thread TB = new Thread(threadB,"B");
        TB.start();
    }
}

运行结果，由于锁定的对象不是同一个所以可以并发执行，不会阻塞，

this sunwukong start:A
this zhubajie start:B
this zhubajie end:B
this sunwukong end:A
this zhubajie start:B
this sunwukong start:A
this sunwukong end:A
this zhubajie end:B
this zhubajie start:B
this sunwukong start:A
this zhubajie end:B
this sunwukong end:A
this zhubajie start:B
this sunwukong start:A
this zhubajie end:B
this sunwukong end:A
this zhubajie start:B
this sunwukong start:A
this zhubajie end:B
this sunwukong end:A

这边需要注意的是如果synchronized(字符常量)，无论new多少个对象都会阻塞不会并发执行，因为JVM维护了一个String,Integer等常量池，new新的对象他不会创建新的字符串，而是引用字符串常量池中已经存在的字符串。
注：synchronized(obj)obj不能是基本数据类型，可以包装数据类型
例如：

public class SynchronizedThis {

    private String flag = "flag";

    public void method(String name){
        synchronized(flag){
            for(int i=0;i<5;i++){
                System.out.println("this "+name+" start:"+Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("this "+name+" end:"+Thread.currentThread().getName());
            }
        }
    }
}
public class MainThread {
    public static void main(String[] args) {
        SynchronizedThis sthis = new SynchronizedThis();
        MyThreadA threadA = new MyThreadA(sthis);
        Thread TA = new Thread(threadA,"A");
        TA.start();
        SynchronizedThis sthis2 = new SynchronizedThis();
        MyThreadB threadB = new MyThreadB(sthis2);
        Thread TB = new Thread(threadB,"B");
        TB.start();
    }
}

运行结果

this sunwukong start:A
this sunwukong end:A
this sunwukong start:A
this sunwukong end:A
this sunwukong start:A
this sunwukong end:A
this sunwukong start:A
this sunwukong end:A
this sunwukong start:A
this sunwukong end:A
this zhubajie start:B
this zhubajie end:B
this zhubajie start:B
this zhubajie end:B
this zhubajie start:B
this zhubajie end:B
this zhubajie start:B
this zhubajie end:B
this zhubajie start:B
this zhubajie end:B

上面的private String flag = new String();是个全局变量，如果我们改成局部变量，即使我们只new一个对象，也会并发执行，因为JVM会为每个线程分配一个私有的空间，TheadA和TheadB两个线程锁定的不是同一个flag，下面让我们来验证下：

public class SynchronizedThis {

    public void method(String name){
        String flag = new String();
        synchronized(flag){
            for(int i=0;i<5;i++){
                System.out.println("this "+name+" start:"+Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("this "+name+" end:"+Thread.currentThread().getName());
            }
        }
    }
}

线程类同上，直接看启动线程类

public class MainThread {
    public static void main(String[] args) {
        SynchronizedThis sthis = new SynchronizedThis();
        MyThreadA threadA = new MyThreadA(sthis);
        Thread TA = new Thread(threadA,"A");
        TA.start();
        MyThreadB threadB = new MyThreadB(sthis);
        Thread TB = new Thread(threadB,"B");
        TB.start();
    }
}

运行结果，A和B并发执行了

this sunwukong start:A
this zhubajie start:B
this zhubajie end:B
this sunwukong end:A
this zhubajie start:B
this sunwukong start:A
this sunwukong end:A
this zhubajie end:B
this sunwukong start:A
this zhubajie start:B
this zhubajie end:B
this sunwukong end:A
this zhubajie start:B
this sunwukong start:A
this sunwukong end:A
this zhubajie end:B
this zhubajie start:B
this sunwukong start:A
this zhubajie end:B
this sunwukong end:A

synchronized(任意对象)与synchronized方法之间

public class SynchronizedThis {

    private Integer flag = new Integer(0);
    public void method(String name){
        synchronized(flag){
            for(int i=0;i<5;i++){
                System.out.println("this "+name+" start:"+Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("this "+name+" end:"+Thread.currentThread().getName());
            }
        }
    }

    public synchronized void method2(String name){
        System.out.println("this"+name+" start:"+Thread.currentThread().getName());
        System.out.println("this"+name+" end:"+Thread.currentThread().getName());
    }
}

两个线程类：

public class MyThreadA implements Runnable {

    private SynchronizedThis sthis;

    public MyThreadA(SynchronizedThis sthis){
        this.sthis = sthis;
    }

    @Override
    public void run() {
        sthis.method("sunwukong");
    }
}
public class MyThreadB implements Runnable {
private SynchronizedThis sthis;

    public MyThreadB(SynchronizedThis sthis){
        this.sthis = sthis;
    }

    @Override
    public void run() {
        sthis.method2("zhubajie");
    }
}

启动线程类

public class MainThread {
    public static void main(String[] args) {
        SynchronizedThis sthis = new SynchronizedThis();
        MyThreadA threadA = new MyThreadA(sthis);
        Thread TA = new Thread(threadA,"A");
        TA.start();
        MyThreadB threadB = new MyThreadB(sthis);
        Thread TB = new Thread(threadB,"B");
        TB.start();
    }
}

运行结果，线程A和线程B可以并发异步执行，因为他们锁的对象不是一个，一个是flag，一个是当前实例this

this sunwukong start:A
thiszhubajie start:B
thiszhubajie end:B
this sunwukong end:A
this sunwukong start:A
this sunwukong end:A
this sunwukong start:A
this sunwukong end:A
this sunwukong start:A
this sunwukong end:A
this sunwukong start:A
this sunwukong end:A

多个synchronized方法之间

public class SynchronizedThis {

    public synchronized void method(String name){
        for(int i=0;i<5;i++){
            System.out.println("this "+name+" start:"+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("this "+name+" end:"+Thread.currentThread().getName());
        }
    }

    public synchronized void method2(String name){
        System.out.println("this"+name+" start:"+Thread.currentThread().getName());
        System.out.println("this"+name+" end:"+Thread.currentThread().getName());
    }
}

两个线程类，线程启动类同上
运行结果，线程B需要等待线程A执行完成之后再执行，这是因为synchronized方法和synchronized(this)效果一样，都是锁定当前this

this sunwukong start:A
this sunwukong end:A
this sunwukong start:A
this sunwukong end:A
this sunwukong start:A
this sunwukong end:A
this sunwukong start:A
this sunwukong end:A
this sunwukong start:A
this sunwukong end:A
thiszhubajie start:B
thiszhubajie end:B

synchronized方法与synchronized(*.class)

public class SynchronizedThis {

    public void method(String name){
        synchronized(SynchronizedThis.class){
            for(int i=0;i<5;i++){
                System.out.println("this "+name+" start:"+Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("this "+name+" end:"+Thread.currentThread().getName());
            }
        }
    }

    public synchronized void method2(String name){
        System.out.println("this"+name+" start:"+Thread.currentThread().getName());
        System.out.println("this"+name+" end:"+Thread.currentThread().getName());
    }
}

两个线程类

public class MyThreadA implements Runnable {

    private SynchronizedThis sthis;

    public MyThreadA(SynchronizedThis sthis){
        this.sthis = sthis;
    }

    @Override
    public void run() {
        sthis.method("sunwukong");
    }
}
public class MyThreadB implements Runnable {
private SynchronizedThis sthis;

    public MyThreadB(SynchronizedThis sthis){
        this.sthis = sthis;
    }

    @Override
    public void run() {
        sthis.method2("zhubajie");
    }
}

线程启动类

public class MainThread {
    public static void main(String[] args) {
        SynchronizedThis sthis = new SynchronizedThis();
        MyThreadA threadA = new MyThreadA(sthis);
        Thread TA = new Thread(threadA,"A");
        TA.start();
        MyThreadB threadB = new MyThreadB(sthis);
        Thread TB = new Thread(threadB,"B");
        TB.start();
    }
}

运行结果，线程A和线程B可以并发异步执行，他们一个锁的是this一个当前对象class

this sunwukong start:A
thiszhubajie start:B
thiszhubajie end:B
this sunwukong end:A
this sunwukong start:A
this sunwukong end:A
this sunwukong start:A
this sunwukong end:A
this sunwukong start:A
this sunwukong end:A
this sunwukong start:A
this sunwukong end:A

静态synchronized方法与synchronized(*.class)

public class SynchronizedThis {

    public void method(String name){
        synchronized(SynchronizedThis.class){
            for(int i=0;i<5;i++){
                System.out.println("this "+name+" start:"+Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("this "+name+" end:"+Thread.currentThread().getName());
            }
        }
    }

    public static synchronized void method2(String name){
        System.out.println("this"+name+" start:"+Thread.currentThread().getName());
        System.out.println("this"+name+" end:"+Thread.currentThread().getName());
    }
}

两个线程类和线程启动类同上
运行结果，线程B需要等待线程A运行完成之后才能运行，因为静态静态方法添加synchronized之后锁定的是当前类.class

this sunwukong start:A
this sunwukong end:A
this sunwukong start:A
this sunwukong end:A
this sunwukong start:A
this sunwukong end:A
this sunwukong start:A
this sunwukong end:A
this sunwukong start:A
this sunwukong end:A
thiszhubajie start:B
thiszhubajie end:B

synchronized(*.class)之间并发执行

public class SynchronizedThis {

    public void method(String name){
        synchronized(SynchronizedThis.class){
            for(int i=0;i<5;i++){
                System.out.println("this "+name+" start:"+Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("this "+name+" end:"+Thread.currentThread().getName());
            }
        }
    }

    public static synchronized void method2(String name){
        synchronized(SynchronizedThis.class){
            for(int i=0;i<5;i++){
                System.out.println("this "+name+" start:"+Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("this "+name+" end:"+Thread.currentThread().getName());
            }
        }
    }
}

线程启动类，我new一个对象

public class MainThread {
    public static void main(String[] args) {
        SynchronizedThis sthis = new SynchronizedThis();
        MyThreadA threadA = new MyThreadA(sthis);
        Thread TA = new Thread(threadA,"A");
        TA.start();
        MyThreadB threadB = new MyThreadB(sthis);
        Thread TB = new Thread(threadB,"B");
        TB.start();
    }
}

运行结果，线程B需要等待线程A执行完之后才能执行

this sunwukong start:A
this sunwukong end:A
this sunwukong start:A
this sunwukong end:A
this sunwukong start:A
this sunwukong end:A
this sunwukong start:A
this sunwukong end:A
this sunwukong start:A
this sunwukong end:A
this zhubajie start:B
this zhubajie end:B
this zhubajie start:B
this zhubajie end:B
this zhubajie start:B
this zhubajie end:B
this zhubajie start:B
this zhubajie end:B
this zhubajie start:B
this zhubajie end:B

如果new两个对象

public class MainThread {
    public static void main(String[] args) {
        SynchronizedThis sthis = new SynchronizedThis();
        MyThreadA threadA = new MyThreadA(sthis);
        Thread TA = new Thread(threadA,"A");
        TA.start();
        SynchronizedThis sthis2 = new SynchronizedThis();
        MyThreadB threadB = new MyThreadB(sthis2);
        Thread TB = new Thread(threadB,"B");
        TB.start();
    }
}

运行结果，和new一个对象效果一样，说明synchronized(SynchronizedThis.class)是对JVM中所有对象实例加锁，后面我再写一篇文章介绍下synchronized在JVM中是怎么工作的

this sunwukong start:A
this sunwukong end:A
this sunwukong start:A
this sunwukong end:A
this sunwukong start:A
this sunwukong end:A
this sunwukong start:A
this sunwukong end:A
this sunwukong start:A
this sunwukong end:A
this zhubajie start:B
this zhubajie end:B
this zhubajie start:B
this zhubajie end:B
this zhubajie start:B
this zhubajie end:B
this zhubajie start:B
this zhubajie end:B
this zhubajie start:B
this zhubajie end:B

总结（这里的同一个对象是指我上面的SynchronizedThis sthis = new SynchronizedThis();new了一个还是两个）：
1、多个synchronized(this)
同一个对象：不能并发执行，不同对象：可以并发
2、synchronized(this)代码块与synchronized方法
同一个对象：：两个加锁效果一样，不能并发执行；不同对象：可以并发
3、synchronized(任意对象)与synchronized方法
同一个对象：可以并发，不同对象：可以并发
4、多个synchronized方法
同一个对象：不能并发执行，不同对象：可以并发
5、synchronized方法与synchronized(*.class)
同一个对象：可以并发，不同对象：可以并发
6、静态synchronized方法与synchronized(*.class)
同一个对象：不能并发执行，不同对象：不能并发执行
7、synchronized(*.class)之间
同一个对象：不能并发执行，不同对象：不能并发执行
下篇文章我会对synchronized在JVM中怎么工作的进行详细讲解。

孙悟空2015
关注
  • 7
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
synchronized用法详解
ganmaotong的博客
06-01 1万+
目录1.线程安全问题2.使用同步机制管理共享数据3.synchronized原理概述3.1 同步代码块的实现原理3.2 同步方法的原理4.synchronized的使用4.1同步代码块 4.2同步普通方法4.3同步静态方法5.synchronized的不可中断性与可重入性5.1 不可中断性5.2 可重入性6.使用synchronized的注意事项6.1注意synchronized同步块的粒度 6.2 对 String 加锁 6.3 对Integer、Long、Short等包装类加锁 线程允许程
java synchronized用法详解
09-01
本篇文章主要介绍了java synchronized用法详解，synchronized是Java中的关键字，是一种同步锁。有兴趣的同学可以了解一下。
synchronized详解
codedot
01-09 7万+
synchronized详解
Synchronized 关键字原理
钱立清的博客
10-13 6万+
众所周知synchronized关键字是解决并发问题常用解决方案，有以下四种使用方式： 修饰代码块，即同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象。 修饰方法，即同步方法，其作用的范围是整个方法，作用的对象是调...
一文彻底理解synchronized（通俗易懂的synchronized）
最新发布
fu_bobo
09-22 1732
一文搞懂synchronized
Java 中 synchronized的用法详解(四种用法)
09-03
Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。本文给大家介绍java中 synchronized的用法，对本文感兴趣的朋友一起看看吧
Java中的关键字synchronized 详解
08-26
主要介绍了Java中的关键字synchronized，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java中synchronized正确使用方法解析
08-25
主要介绍了Java中syncronized正确使用方法解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java 同步锁(synchronized)详解及实例
08-30
主要介绍了Java 同步锁(synchronized)详解及实例的相关资料,需要的朋友可以参考下
synchronized原理详解（通俗易懂超级好）
拉格朗日的学习笔记
04-15 5519
目标 【理解】synchronized底层原理 【掌握】synchronized 的用法 目录目标一、synchronized原理1.1 原子性1.2 可见性1.3 有序性1.4 可重入性二、synchronized 的用法三、synchronized 的底层原理3.1 对象头在JVM中存储的形式3.1.1 对象头3.1.2 对象实例数据3.1.3 对齐填充3.2 Monitor3.3 synchronized锁的优化3.3.1 synchronized锁的状态3.3.2 偏向锁3.3.3. 轻量级锁3.
Synchronized 用法和底层原理
击水三千里的专栏
08-11 1692
一、对象锁和类锁 1. 对象锁 在 Java 中，每个对象都会有一个 monitor 对象，这个对象其实就是 Java 对象的锁，通常会被称为“内置锁”或“对象锁”。类的对象可以有多个，所以每个对象有其独立的对象锁，互不干扰。 2. 类锁 在 Java 中，针对每个类也有一个锁，可以称为“类锁”，类锁实际上是通过对象锁实现的，即类的 Class 对象锁。每个类只有一个 Class 对象，所...
Java中Synchronized的用法
热门推荐
阳光日志
06-24 49万+
synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种： 1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； 2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 3.修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象； 4..
Lock和Synchronize区别
e54332的博客
01-21 2万+
1、两者所处层面不同 synchronized是Java中的一个关键字，当我们调用它时会从在虚拟机指令层面加锁，关键字为monitorenter和monitorexit Lock是Java中的一个接口，它有许多的实现类来为它提供各种功能，加锁的关键代码为大体为Lock和unLock； 2、获锁方式 synchronized可对实例方法、静态方法和代码块加锁，相对应的，加锁前需要获得实例对象的锁或类...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值