synchronized修饰方法、static方法、this、.class、obj的代码示例

最新推荐文章于 2023-06-15 22:58:50 发布
最新推荐文章于 2023-06-15 22:58:50 发布
阅读量411 收藏 1
点赞数 3
分类专栏： 面试笔试题 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangjin1120/article/details/120665687
版权

对象锁

一、非静态方法，方法头部加入synchronized关键字，例如：public synchronized void printC() {...}。不同线程访问同一个对象的该方法时，会产生互斥。在jdk中，StringBuffer的append()方法就属于这种类型。

public class PrintTool {

    public synchronized void printC()  {
        System.out.println(new SimpleDateFormat("HH:mm:ss").format(new Date())+" " + Thread.currentThread().getName() + "获得锁");
        System.out.println(new SimpleDateFormat("HH:mm:ss").format(new Date()) + " " + Thread.currentThread().getName() + "释放锁");
    }
}

public class MyThread extends Thread {
    PrintTool pt;

    public MyThread(PrintTool pt, String name) {
        super(name);
        this.pt = pt;
    }

    @Override
    public void run() {
        this.pt.printC();
    }
}

public class SyncTest {

    public static void main(String[] args) {
        PrintTool pt = new PrintTool();

        for (int i = 0; i < 5; i++) {
           new MyThread(pt, "t" + i).start();
        }
    }
}

运行结果：

可以看到，t0最先获得锁，后面的每一个线程，只能等待上一个线程释放锁之后，才能执行这个方法。

二、在非static方法的方法体中，加入synchronized(obj){...}代码块。拥有同一个指定对象obj的多个线程,如果同时执行这段代码块，会产生互斥。这种写法，常见于自定义线程中，多个线程同时修改一个对象。经典的多线程卖票就是这种情况。

public class PrintTool {

    public void printC()  {
        System.out.println(new SimpleDateFormat("HH:mm:ss").format(new Date())+" " + Thread.currentThread().getName() + "获得锁");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(new SimpleDateFormat("HH:mm:ss").format(new Date()) + " " + Thread.currentThread().getName() + "释放锁");
    }
}

public class SyncTest {

    public static void main(String[] args) {
        PrintTool pt = new PrintTool();
        for (int i = 1; i <=3; i++) {
           new Thread(new Runnable(){
               @Override
               public void run() {
                   synchronized (pt) {
                       pt.printC();
                   }
               }
           }, "t" + i).start();
        }
    }
}

运行结果：

每隔两秒，会有一个线程获得锁。而不是t1,t2,t3同时进入方法。
对象锁必须是同一个对象，才起作用。如果是不同对象，就无效。把上面的代码SyncTest修改如下，看看结果：

public class SyncTest {
    public static void main(String[] args) {
        for (int i = 1; i <=3; i++) {
           new Thread(new Runnable(){
               @Override
               public void run() {
                   PrintTool pt = new PrintTool();
                   synchronized (pt) {
                       pt.printC();
                   }
               }
           }, "t" + i).start();
        }
    }
}

可以看到，3个线程同时获得了三个不同的锁，2秒后，又同时释放。synchronized就失效了。

三、在一个普通类（线程类除外）的非static方法的方法体中，使用synchronized(this){...}代码块。拥有该普通类的同一个对象的多个线程，同时访问这个方法中的同步代码块时，会产生互斥。这种写法的场景和第二种有些不同，这种写法，经常是用于多个线程只修改同一个的对象的某一个属性，其他属性不用考虑多线程的情况，synchronized使用在同步类的内部，而不是其他类和线程的run方法中。

public class PrintTool {

    public void printC() {
        synchronized (this) {
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(new Date()) + " " + Thread.currentThread().getName() + "进入同步代码块");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(new Date()) + " " + Thread.currentThread().getName() + "释放锁");
        }
    }
}

public class SyncTest {
    public static void main(String[] args) {
        PrintTool pt = new PrintTool();
        for (int i = 1; i <=3; i++) {
           new Thread(new Runnable(){
               @Override
               public void run() {
                   pt.printC();
               }
           }, "t" + i).start();
        }
    }
}

运行结果：

后面的线程等待前一个线程释放锁后，才能执行同步代码。
如果是不同对象，synchronized就会失效。SyncTest代码修改如下：

public class SyncTest {
    public static void main(String[] args) {
        for (int i = 1; i <=3; i++) {
           new Thread(new Runnable(){
               @Override
               public void run() {
                   PrintTool pt = new PrintTool();
                   pt.printC();
               }
           }, "t" + i).start();
        }
    }
}

从结果看出，同步失效了。原因是三个线程拥有三个不同的对象，拥有三个不同的锁。

类锁

先看看，在不使用synchronized关键字的情况下，多个线程同时执行一个类的static方法，会出现什么情况。

public class PrintTool {

    public static void printStaticNormal()  {
        System.out.println(new SimpleDateFormat("HH:mm:ss").format(new Date())+" " + Thread.currentThread().getName() + "开始执行");
        System.out.println(new SimpleDateFormat("HH:mm:ss").format(new Date()) + " " + Thread.currentThread().getName() + "结束执行");
    }
}

public class SyncTest {

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
           new Thread(new Runnable(){
               @Override
               public void run() {
                   PrintTool.printStaticNormal();
               }
           }, "t" + i).start();
        }
    }
}

运行结果：

可以看到，多个线程同时进入这个方法，并不是等待一个线程执行完之后，另一个线程再开始执行。
下面探索synchronized类锁的作用：

一、static方法体中，使用synchronized(XX.class){...}。不同线程访问同一个类的static方法时，不管是不是同一个方法，都会产生互斥。这种写法，常见于单例模式。

public class PrintFruit {
    public static void printA(){
        System.out.println(new SimpleDateFormat("HH:mm:ss").format(new Date())+" Apple");
    }

    public static void printB(){
        System.out.println(new SimpleDateFormat("HH:mm:ss").format(new Date())+" Banana");

    }
}

public class SyncTest {
    public static void main(String[] args) {
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                synchronized (PrintFruit.class) {
                    PrintFruit.printA();
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        Thread t1 = new Thread(r1, "t1");
        Thread t2 = new Thread(r1,"t2");
        Thread t3 = new Thread(r1, "t3");

        Runnable r2 = new Runnable() {
            @Override
            public void run() {
                synchronized (PrintFruit.class) {
                    PrintFruit.printB();
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };

        Thread t4 = new Thread(r2, "t4");
        Thread t5 = new Thread(r2, "t5");
        Thread t6 = new Thread(r2, "t6");

        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
        t6.start();
    }
}

运行结果：

可以根据时间间隔看出，每隔3秒，下一个线程才开始执行代码块。即使printA和printB是两个不同的方法，也会出现互斥。

二、在static方法头中，加入synchronized关键字。不同线程同时访问该类的static方法，即使是不同方法，也会产生互斥。

public class PrintTool {

    public synchronized static void printC()  {
        System.out.println(new SimpleDateFormat("HH:mm:ss").format(new Date())+" " + Thread.currentThread().getName() + "获得锁");
        System.out.println(new SimpleDateFormat("HH:mm:ss").format(new Date()) + " " + Thread.currentThread().getName() + "释放锁");
    }

    public synchronized  static  void printD()  {
        System.out.println(new SimpleDateFormat("HH:mm:ss").format(new Date())+" " + Thread.currentThread().getName() + "获得锁");
        System.out.println(new SimpleDateFormat("HH:mm:ss").format(new Date()) + " " + Thread.currentThread().getName() + "释放锁");
    }
}

public class SyncTest {

    public static void main(String[] args) {
        for (int i = 1; i <=3; i++) {
           new Thread(new Runnable(){
               @Override
               public void run() {
                   PrintTool.printC();
               }
           }, "t" + i).start();
        }

        for (int i = 4; i <=6; i++) {
           new Thread(new Runnable(){
               @Override
               public void run() {
                   PrintTool.printD();
               }
           }, "t" + i).start();
        }
    }
}

运行结果：

t1,t2,t3执行的是printC，t4,t5,t6执行的是printD。可以看到，即使是不同方法，也会出现互斥。

感谢：
synchronized(this) 与synchronized(class) 之间的区别
synchronized的四种用法
Java之Synchronized修饰实例方法和静态方法
Synchronized同步静态方法和非静态方法总结

zhangjin1120
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java基本教程之synchronized关键字 java多线程教程
09-04
当一个线程执行synchronized修饰的方法或代码块时，会获取到与该对象关联的同步锁。如果另一个线程试图在锁已被占用的情况下访问这些同步结构，它会被阻塞，直到当前线程完成其执行并释放锁。这种机制确保了同一时间...
Synchronized同步静态方法和非静态方法总结
奔跑入坑大数据
11-16 1827
1.Synchronized修饰非静态方法，实际上是对调用该方法的对象加锁，俗称“对象锁”。 Java中每个对象都有一个锁，并且是唯一的。假设分配的一个对象空间，里面有多个方法，相当于空间里面有多个小房间，如果我们把所有的小房间都加锁，因为这个对象只有一把钥匙，因此同一时间只能有一个人打开一个小房间，然后用完了还回去，再由JVM 去分配下一个获得钥匙的人。 情况1：同一个对象在两个线程中分别访问该对象的两个同步方法 结果：会产生互斥。 解释：因为锁针对的是对象，当对象调用一个synch...
Java中Synchronized的用法（简单介绍）
NeiHan2020的博客
03-04 6062
简单介绍 synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种： 　　1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； 　　2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 　　3. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象； 　　4. 修改一个类，其作用的范围是synchronized后面括号括起来的...
Java Synchronized 和 Static 关键字的总结与使用
qq_36883397的博客
11-29 662
一、Synchronized 同步锁的使用与注意事项 synchronized的4种用法 Synchronized即同步锁，主要应用在多线程之间同步作用，下面是Synchronized的四种使用方法。 1.方法声明时使用,放在范围操作符(public等)之后,返回类型声明(void等)之前.即一次只能有一个线程进入该方法,其他线程要想在此时调用该方法,只能排队等候,当前线程(就是在sy
类锁和对象锁，synchronized修饰static方法与非static方法的区别
杨杨杨~~的博客
09-11 2903
类锁和对象锁，synchronized修饰static方法与非static方法的区别 当synchronized修饰一个static方法时，多线程下，获取的是类锁(即Class本身，注意:不是实例)， 作用范围是整个静态方法，作用的对象是这个类的所有对象。 当synchronized修饰一个非static方法时，多线程下，获取的是对象锁(即类的实例对象)， ...
Java中synchronized 用在static方法和非static方法上面的区别
Alen
08-20 2580
在Java中，synchronized是用来表示同步的，我们可以synchronized来修饰一个方法。也可以synchronized来修饰方法里面的一个语句块。那么，在static方法和非static方法前面加synchronized到底有什么不同呢？大家都知道，static的方法属于类方法，它属于这个Class（注意：这里的Class不是指Class的某个具体对象），那么static获取到的锁......
.net 面试题.docx
11-26
14) abstract不能与static、native、synchronized同时使用，因为它们的性质相互冲突。 15) String是密封类，不能被继承。 16) Override是重写父类方法，重载是同一类中方法名相同但参数列表不同的方法。 17) C#中...
第8章 内部类和Object.docx
09-03
}}权限修饰符在属性或方法上的控制不同类的代码示例public class ModifierTest1{public int pubVar = 100;protected int protVar = 200;int defVar = 300;private int privVar = 400;}public class ModifierTest2 ...
JavaSE笔试问答题.docx
05-19
1. 当Class实现Cloneable和Comparable接口时，需要实现`clone()`和`compareTo(Object obj)`方法。`clone()`用于创建当前对象的一个副本，而`compareTo()`用于比较两个对象的顺序，通常用于排序操作。 2. 这个方法是...
Java中的同步与互斥机制–synchornized学习
12-22
当 `synchronized` 修饰静态方法时，锁定的是类的 Class 对象。这意味着，对于所有实例，同一时间只有一个线程可以执行该静态方法： ```java public static synchronized void fun_3() { // ... } ``` 等同于...
整理synchronized、static synchronized以及synchronized(obj)区别
tianshui0823的专栏
02-08 238
文章目录synchronized用户发结论：demo测试用例 对java中synchronized应用场景做下整理，方面自己以后查看 synchronized用户发结论： 1.public synchronized void syncMethod(String flag){} 锁当前对象this,等价代码块锁synchronized (this){} 1.1 同一个实例对象同一个时刻只能有一个在调用，不同实例可以同时调用 2.public static synchronized void syncS
深入分析 Synchronized 原理
养歌的博客
02-07 2032
Synchronized 简介 Synchronized 是 Java 中的关键字，是一种同步锁。在多线程编程中，有可能会出现多个线程同时争抢同一个共享资源的情况，这个资源一般被称为临界资源。这种共享资源可以被多个线程同时访问，且又可以同时被多个线程修改，然而线程的执行是需要 CPU 的资源调度，其过程是不可控的，所以需要采用一种同步机制来控制对共享资源的访问，于是线程同步锁—— Synchronized 就应运而生了。 Synchronized 用法 Synchronized 关键字主要有以下 3 种使用
访问synchronized的static 方法
u012575573的专栏
06-09 326
public class ThreadTest4 { public static void main(String args[]) { MyTest mytest=new MyTest(); MyThreadTest m=new MyThreadTest(mytest); MyThreadTest2 e=new MyThreadTest2(mytest); m.start();
深入理解Synchronized（对象锁）和Static Synchronized（类锁）的区别
Darling_qi的博客
03-20 1630
通过分析这两个用法的分析，我们可以理解java中锁的概念。一个是实例锁（锁在某一个实例对象上，如果该类是单例，那么该锁也具有全局锁的概念），一个是全局锁（该锁针对的是类，无论实例多少个对象，那么线程都共享该锁）。实例锁对应的就是synchronized关键字，而类锁（全局锁）对应的就是static synchronized（或者是锁在该类的class或者classloader对象上）。
synchronized(this/object/类.class)的区别
欧阳的博客
04-11 2909
synchronized this object Class的区别 首先放上结论: 1.this:相当于只有一把钥匙的多把锁,他可以锁住多个代码块,但是每次开锁只能一个,如果钥匙在其他代码块手上,那么新来的被锁的多个代码块就拿不到钥匙,进不了方自己的代码块 2.object:每一个object相当于一把锁,那么不同的锁会有不同的钥匙,这样如果自己的锁不同,一样的锁没有被其他人占据,自己开...
synchronized(this)、synchronized(class)与synchronized(Object)的区别
最新发布
零落凉辰@的专栏
06-15 576
当一个线程访问ObjectService的一个synchronized (this)同步代码块时，其它线程对同一个ObjectService中其它的synchronized (this)同步代码块的访问将是堵塞，这说明synchronized (this)使用的对象监视器是一个。上面三个小例子我们可以知道，多个线程调用同一个对象中的不同名称的synchronized同步方法或synchronized(this)同步代码块时，是同步的。②同一时间只有一个线程执行synchronized同步方法中的代码。
java 静态方法同步_【java 基础】java 同步synchronized加到static和非static方法
weixin_36319938的博客
02-21 248
java多线程共享属性时要用到同步块(synchronized)使对共享属性的操作保证原子性、可见性和有序性。今天探讨一下synchronized修饰static方法和非static方法时的锁对象。看下面的代码：public class ThreadClass {public synchronized static void get(){System.out.println("======star...
Java并发基础(4)：Synchronized原理和锁优化升级过程
mingyuli的博客
09-25 2428
自旋、偏向锁、轻量级锁、重量级锁区别_pocher的博客-CSDN博客 Java并发——Synchronized关键字和锁升级，详细分析偏向锁和轻量级锁的升级_tongdanping的博客-CSDN博客Java中Synchronized的用法_阳光日志-CSDN博客_synchronized【Java并发编程之深入理解】Synchronized的使用_青苔小榭-CSDN博客_synchronized 深入理解Java并发之synchronized实现原理_zejian的博客-CSDN博客_synchro.
Java 中同步机制的几种方式及使用
IT徐师兄
05-14 3313
Java 中同步机制的几种方式及使用
synchronized 代码块 对this .class对象 成员对象 静态成员对象 加锁有什么区别,详细解释并给出代码示例
06-02
在上述代码中，synchronizedMethod() 方法和 synchronized (MyClass.class) 代码块都是锁定 MyClass 类对象。而 nonSynchronizedMethod() 方法中的 synchronized (MyClass.class) 代码块也是锁定 MyClass 类对象。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值