Synchronized关键字加在普通方法上和加在静态方法上有什么区别?

最新推荐文章于 2024-04-18 17:22:03 发布
最新推荐文章于 2024-04-18 17:22:03 发布
阅读量5.8k 收藏 53
点赞数 21
分类专栏： 多线程 文章标签： java 多线程 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43658899/article/details/107230699
版权
一、Synchronized关键字加在普通方法上和加在静态方法上有什么区别?

synchronized修饰不加static的方法，锁是加在单个对象上，不同的对象没有竞争关系；

synchronized修饰加了static的方法，锁是加载类上，这个类所有的对象竞争一把锁。

  1. Synchronized修饰非静态方法，实际上是对调用该方法的对象加锁，俗称“对象锁”。
  • 情况1：
package com.cx.domain;
public class Thread01 {
    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            Thread thread = new MyThread();
            thread.start();
        }
    }
}

package com.cx.domain;

public class MyThread extends Thread{
    @Override
    public void run() {
        Sync sync = new Sync();
        sync.test();
    }
}

package com.cx.domain;

public class Sync{
    //方法同步
    public synchronized  void test(){
        System.out.println("test1111开始执行。。。。");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("test1111执行结束。。。");
    }
}

执行结果：

image-20200709121317469

结论：

以上是不同的对象执行同一个非static方法，锁并没有生效，原因是Synchronized修饰非静态方法，实际上是对调用该方法的对象加锁，此处是三个对象，并非同一个，所以没有生效。

情况1：不同对象在两个线程中调用同一个同步方法

结果：不会产生互斥。

解释：因为是两个对象，锁针对的是对象，并不是方法，所以可以并发执行，不会互斥。形象的来说就是因为我们每个线程在调用方法的时候都是new 一个对象，那么就会出现两个空间，两把钥匙，

  • 情况2:
package com.cx.domain;

public class Thread02 {
    public static void main(String[] args) {
        Sync sync = new Sync();
        for (int i = 0; i < 3; i++) {
            Thread thread = new MyThread2(sync);
            thread.start();
        }
    }
}

package com.cx.domain;

public class MyThread2 extends Thread{
    private Sync sync;
    public MyThread2(Sync sync) {
        this.sync = sync;
    }
    public void run() {
        sync.test();
    }
}


package com.cx.domain;

public class Sync{
    //方法同步
    public synchronized  void test(){
        System.out.println("test1111开始执行。。。。");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("test1111执行结束。。。");
    }
}

执行结果：

image-20200709122028987

结论：

以上是同一个对象执行同一个非static方法，锁生效了，因为是同一个对象。

  • 情况3:
package com.cx.domain;

public class Thread03 {
    public static void main(String[] args) {
        final Sync sync = new Sync();
				//线程1
        new Thread(new Runnable() {
            public void run() {
                sync.test();
            }
        }).start();
				//线程2
        new Thread(new Runnable() {
            public void run() {
                sync.test2();
            }
        }).start();
				//线程3
        new Thread(new Runnable() {
            public void run() {
                sync.test3();
            }
        }).start();
    }
}


package com.cx.domain;

public class Sync{
    //方法同步
    public synchronized  void test(){
        System.out.println("test1111开始执行。。。。");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("test1111执行结束。。。");
    }
    public synchronized  void test2(){
        System.out.println("test2222开始执行。。。。");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("test2222执行结束。。。");
    }

    //代码块同步
    public  void test3(){
//        String obj = "";
        synchronized(this){
            System.out.println(this);
            System.out.println("test3333开始执行。。。。");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("test3333执行结束。。。");
        }
    }
}

执行结果：

image-20200709122832144

结论：

以上是同一个对象执行不同的非static同步方法，锁生效了。因为是同一个对象锁。需要依次等待释放锁。

情况3：同一个对象在三个线程中分别访问该对象的三个同步方法

结果：会产生互斥。

解释：因为锁针对的是对象，当对象调用一个synchronized方法时，其他同步方法需要等待其执行结束并释放锁后才能执行。

  1. Synchronized修饰静态方法，实际上是对该类对象加锁，俗称“类锁”。
  • 情况1:
package com.cx.domain;

public class Thread01 {
    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            Thread thread = new MyThread();
            thread.start();
        }
    }
}

package com.cx.domain;

public class MyThread extends Thread{
    @Override
    public void run() {
        Sync sync = new Sync();
        sync.test();
    }
}

package com.cx.domain;

public class Sync{
    //静态方法同步
    public synchronized static void test(){
        System.out.println("test1111开始执行。。。。");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("test1111执行结束。。。");
    }
}

执行结果：

image-20200709123637764

结论：

以上是不同对象执行同一个静态同步方法，锁生效了。因为Synchronized修饰静态方法，实际上是对该类对象加锁，尽管Sync对象不同，但是类对象是同一个，还是得依次等候。

  • 情况2:
package com.cx.domain;

public class Thread02 {
    public static void main(String[] args) {
        Sync sync = new Sync();
        for (int i = 0; i < 3; i++) {
            Thread thread = new MyThread2(sync);
            thread.start();
        }
    }
}


package com.cx.domain;

public class MyThread2 extends Thread{
    private Sync sync;
    public MyThread2(Sync sync) {
        this.sync = sync;
    }
    public void run() {
        sync.test();
    }
}

package com.cx.domain;

public class Sync{
    //静态方法同步
    public synchronized static void test(){
        System.out.println("test1111开始执行。。。。");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("test1111执行结束。。。");
    }
}

执行结果：

image-20200709124228086

结论：

以上是同一个对象执行同一个静态同步方法。锁生效了。因为Synchronized修饰静态方法，实际上是对该类对象加锁，类对象是同一个，还是得依次等候。

  • 情况3:
package com.cx.domain;

public class Thread03 {
    public static void main(String[] args) {
        final Sync sync = new Sync();

        new Thread(new Runnable() {
            public void run() {
                sync.test();
            }
        }).start();

        new Thread(new Runnable() {
            public void run() {
                sync.test2();
            }
        }).start();
}


package com.cx.domain;

public class Sync{
    //方法同步
    public synchronized static void test(){
        System.out.println("test1111开始执行。。。。");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("test1111执行结束。。。");
    }
    public synchronized  void test2(){
        System.out.println("test2222开始执行。。。。");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("test2222执行结束。。。");
    }
}

执行结果：

结论：

以上是同一个对象执行一个静态方法一个非静态方法，锁未生效。因为虽然是一个对象调用，但是两个方法的锁类型不同，调用的静态方法实际上是类对象在调用，即这两个方法产生的并不是同一个对象锁，因此不会互斥，会并发执行。

情况3：一个对象在两个线程中分别调用一个静态同步方法和一个非静态同步方法

结果：不会产生互斥。

解释：因为虽然是一个对象调用，但是两个方法的锁类型不同，调用的静态方法实际上是类对象在调用，即这两个方法产生的并不是同一个对象锁，因此不会互斥，会并发执行。

  • 情况4:
package com.cx.domain;

public class Thread03 {
    public static void main(String[] args) {
        final Sync sync = new Sync();
				//线程1
        new Thread(new Runnable() {
            public void run() {
                sync.test();
            }
        }).start();
				//线程2
        new Thread(new Runnable() {
            public void run() {
                sync.test2();
            }
        }).start();
				//线程3
        new Thread(new Runnable() {
            public void run() {
                sync.test3();
            }
        }).start();
    }
}


package com.cx.domain;

public class Sync{
    //方法同步
    public synchronized static void test(){
        System.out.println("test1111开始执行。。。。");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("test1111执行结束。。。");
    }
    public synchronized static void test2(){
        System.out.println("test2222开始执行。。。。");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("test2222执行结束。。。");
    }

    //代码块同步
    public static void test3(){
        synchronized(Sync.class){
            System.out.println("test3333开始执行。。。。");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("test3333执行结束。。。");
        }
    }
}

执行结果：

image-20200709125249660

结论：

执行三个不同的静态方法，锁生效，因为类对象是同一个（Sync.class）。

  1. 总结：

    对于类锁synchronized static，是通过该类直接调用加类锁的方法，而对象锁是创建对象调用加对象锁的方法，两者访问是不冲突的，对于同一类型锁锁住的方法，同一对象是无法同时访问的，因为调用类锁锁住的方法无法创建实例对象，所以同一个类中只有加了对象锁的两个方法可以被同时访问，前提是new两个对象。

    对象锁：

    1. 同一个对象访问同一个非static方法，对象锁一致，锁生效。
    2. 同一个对象访问不同非static方法，对象锁一致，锁生效。
    3. 同一个对象访问static方法和非static方法，锁失效。锁类型不一致。
    4. 不同对象访问同一个非static方法，对象锁不一致，锁失效。

    类锁：

    1. 不同对象访问同一个static方法，锁生效，同一个类锁。类锁一致，对象锁不一致。
    2. 同一个对象访问不同的static方法，锁生效，同一个类锁。类锁一致，对象锁一致。
    3. 同一个对象访问static方法和非static方法，锁失效。锁类型不一致。
二、Synchronized和Lock的比较

ava多线程可以通过：

  • synchronized关键字
  • Java.util.concurrent包中的lock接口和ReentrantLock实现类

这两种方式实现加锁.

如果一个代码块被synchronized修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只会有两种情况：

  1. 获取锁的线程执行完了该代码块，然后线程释放对锁的占有；
  2. 线程执行发生异常，此时JVM会让线程自动释放锁。

那么如果这个获取锁的线程由于要等待IO或者其他原因（比如调用sleep方法）被阻塞了，但是又没有释放锁，其他线程便只能干巴巴地等待，试想一下，这多么影响程序执行效率。因此就需要有一种机制可以不让等待的线程一直无期限地等待下去（比如只等待一定的时间或者能够响应中断），通过Lock就可以办到。

再举个例子：当有多个线程读写文件时，读操作和写操作会发生冲突现象，写操作和写操作会发生冲突现象，但是读操作和读操作不会发生冲突现象。

但是采用synchronized关键字来实现同步的话，就会导致一个问题：

如果多个线程都只是进行读操作，所以当一个线程在进行读操作时，其他线程只能等待无法进行读操作。因此就需要一种机制来使得多个线程都只是进行读操作时，线程之间不会发生冲突，通过Lock就可以办到。

另外，通过Lock可以知道线程有没有成功获取到锁。这个是synchronized无法办到的。
对比：

  • Lock不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性。Lock是一个类，通过这个类可以实现同步访问；
  • Lock和synchronized有一点非常大的不同，采用synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；而Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。

总结来说，Lock和synchronized有以下几点不同：

  1. Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；
  2. synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；
  3. Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；（I/O和Synchronized都能相应中断，即不需要处理interruptionException异常）
  4. 通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。
  5. Lock可以提高多个线程进行读操作的效率。
  6. 在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。所以说，在具体使用时要根据适当情况选择。
学习中啊哈哈
关注
  • 21
    点赞
  • 踩
  • 53
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
synchronized与static synchronized的区别
01-20
大家在学习java多线程的时候肯定会遇到这个问题，而且在面试的时候也可能会谈到java多线程这一块的知识。今天我们就来看看这个东西~~~ synchronized 这个是对类实例进行加锁，可以简称为“实例锁”或者是“对象锁”。当某个线程调用synchronized方法的时候，就会给它加上了一个锁，其他线程就会无法访问，等到这个锁被释放，别的线程拿到这个锁的时候，才可以访问该方法。 static synchronized这个是“全局锁”或者是“类锁”，该锁针对的是类，不管实例了多少个对象，线程都共享该锁。 下面我们来看代码： import java.util.concurrent.TimeUni
synchronized修饰静态方法和普通方法有什么区别
qq_35181209的博客
07-08 1万+
在Java中，synchronized是用来表示同步的，我们可以synchronized来修饰一个方法。也可以synchronized来修饰方法里面的一个语句块。 在static方法前加synchronizedstatic：静态方法属于类方法，它属于这个类，获取到的锁，是属于类的锁。 在普通方法前加synchronizedstatic：非static方法获取到的锁，是属于当前对象的锁。
Synchronized锁
T_karine的博客
12-06 3399
Synchronized锁原理及锁的升级过程
怎样在静态方法中使用 synchronized
老梁的专栏
12-05 7453
synchronized 的实现方式synchronized 的类型可以分为两种： synchronized method synchronized block 两者的实现方式是不一样的，jvm 规范中写道，编译后的 synchronized method 会有一个 ACC_SYNCHRONIZED 的 flag，也就是说当 jvm 的方法调用指令（the method invocation ins
Java中synchronized 用在static方法和非static方法上面的区别
Alen
08-20 2541
在Java中，synchronized是用来表示同步的，我们可以synchronized来修饰一个方法。也可以synchronized来修饰方法里面的一个语句块。那么，在static方法和非static方法前面加synchronized到底有什么不同呢？大家都知道，static的方法属于类方法，它属于这个Class（注意：这里的Class不是指Class的某个具体对象），那么static获取到的锁......
Synchronized加在静态方法和普通方法的区别
qq_46130027的博客
05-12 947
当多个线程同时访问同一个共享对象的同步方法时，synchronized可以确保每个线程依次执行方法中的代码块，从而防止多个线程同时修改对象的状态，从而导致数据不一致的问题。相反，如果一个类中有多个普通方法，这些方法都加上了synchronized关键字，那么这些方法将会使用不同的对象作为锁。这意味着即使有多个线程同时访问这些方法，只要它们操作的是不同的对象，它们也可以并发执行，因为每个对象都有自己的锁。这意味着同一时刻只有一个线程可以访问这些方法，即使这些方法操作的是不同的对象。
synchronized 应用于静态方法
Steve Guo
09-23 874
多线程 synchronized 静态方法
synchronized加在方法上
fallingcarter的博客
04-25 5095
synchronized如果加在了非静态方法上，表示的是synchronized(调用方法的类的对象) {}，如果加在了静态方法上，表示的是synchronized(类.class) {}
Java多线程--synchronized修饰普通方法和修饰静态方法的区别
学亮编程手记
05-09 1085
初始化一个对象时，会自动生成一个与该对象对应的对象锁，被synchronized 修饰的方法就得依靠对象锁工作。当多线程同时访问某个被synchronized修饰的方法时，一旦某个进程抢得对象锁之后，其他的进程只有排队对待。 一、synchronized修饰普通方法 初始化一个对象时，会自动生成一个与该对象对应的对象锁，被synchronized 修饰的方法就得依靠对象锁工作。当多线程同时...
synchronized的四种用法
热门推荐
行走江湖的少侠哥
06-06 6万+
一  修饰一个方法 Synchronized修饰一个方法很简单，就是在方法的前面加synchronized，synchronized修饰方法和修饰一个代码块类似，只是作用范围不一样，修饰代码块是大括号括起来的范围，而修饰方法范围是整个函数。 例如： 方法一 public synchronized void method() { // todo }方法二 public v
基于synchronized修饰静态和非静态方法
08-19
主要介绍了基于synchronized修饰静态和非静态方法,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
加不加 synchronized 有什么区别？
12-21
博客专家 原创文章 214获赞 1070访问量 37万+ 关注 他的留言板 展开阅读全文 作者：LieBrother
java多线程编程之使用Synchronized关键字同步类方法
09-04
JAVA中要想解决“脏数据”的问题，最简单的方法就是使用synchronized关键字来使run方法同步,看下面的代码，只要在void和public之间加上synchronized关键字
java中synchronized（同步代码块和同步方法）详解及区别
08-31
主要介绍了 java中synchronized（同步代码块和同步方法）详解及区别的相关资料,需要的朋友可以参考下
Java中synchronized关键字修饰方法同步的用法详解
09-02
synchronized可以用来同步静态和非静态方法,下面就具体来看一下Java中synchronized关键字修饰方法同步的用法详解:
【1524】java投票管理系统Myeclipse开发mysql数据库web结构java编程计算机网页项目
qq_251836457的博客
04-18 690
2、开发环境为TOMCAT7.0,Myeclipse8.5开发，数据库为Mysql5.0，使用java语言开发。(5)投票选项管理：对投票选项信息进行添加、删除、修改和查看。(6)投票记录管理：对投票记录信息进行添加、删除、修改和查看。(1)管理员管理：对管理员信息进行添加、删除、修改和查看。(2)用户管理：对用户信息进行添加、删除、修改和查看。(3)公告管理：对公告信息进行添加、删除、修改和查看。(4)投票管理：对投票信息进行添加、删除、修改和查看。4）投票浏览查看、查看投票、投票记录。
2.8 构建gradle环境
最新发布
蚊者逆袭的博客
04-18 2178
Gradle是一种现代化的构建工具，用于自动化地构建、测试和部署软件项目。它是一种基于JVM（Java虚拟机）的构建工具，最初是为了解决Apache Ant和Apache Maven等传统构建工具的一些限制而开发的。
Web前端 Javascript笔记5
cycyzh的博客
04-18 874
script>'console.log("哈哈哈佳人们好困")'}, 3000)​let t1 = setTimeout('console.log("你们看到这句话的时候我早已身价百万！！")', 4000)​</script>3秒，四秒后出来的东西，出现前会返回计时器编号。
Java springboot使用EasyExcel读Excel文件，映射不到属性值，对象属性值都是null
没有简介就是简介
04-16 433
Java springboot使用EasyExcel读Excel文件，映射不到属性值，对象属性值都是null
synchronized用于静态方法与普通方法有区别吗？
03-26
但是，对于静态方法和实例方法，synchronized在效果上是有区别的。 实例方法： 当一个线程调用对象的实例方法时，它会获得该实例的锁，这意味着其他线程无法在同时调用该实例的同一个同步方法。但是，不同实例的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值