synchronized修饰不同位置的作用

最新推荐文章于 2022-08-08 09:30:37 发布
最新推荐文章于 2022-08-08 09:30:37 发布
阅读量2.2k 收藏 9
点赞数 1
分类专栏： java 多线程 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013041642/article/details/88933136
版权

synchronized修饰不同位置的作用

例1：修饰多个方法

public class SynchronizedTest {
    
    public static void main(String[] args) {
        Hello hello = new Hello();
        new Thread(hello::printA, "线程A").start();
        new Thread(hello::printB, "线程B").start();
    }

    static class Hello {
        synchronized void printA() {
            for (; ; ) {
                System.out.println(Thread.currentThread().getName() + " 我在打印");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        synchronized void printB() {
            for (; ; ) {
                System.out.println(Thread.currentThread().getName() + " 我在打印");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

执行结果：全是线程A在执行。

线程A 我在打印
线程A 我在打印
线程A 我在打印
线程A 我在打印
线程A 我在打印
线程A 我在打印
线程A 我在打印
线程A 我在打印
线程A 我在打印
线程A 我在打印
...

例2：修饰多个代码块

public class SynchronizedTest {

    public static void main(String[] args) {
        Hello hello = new Hello();
        new Thread(hello::printA, "线程A").start();
        new Thread(hello::printB, "线程B").start();
    }

    static class Hello {
        void printA() {
            synchronized (this) {
                for (; ; ) {
                    System.out.println(Thread.currentThread().getName() + " 我在打印");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

        synchronized void printB() {
            synchronized (this) {
                for (; ; ) {
                    System.out.println(Thread.currentThread().getName() + " 我在打印");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

执行结果：全是线程A在执行。

线程A 我在打印
线程A 我在打印
线程A 我在打印
线程A 我在打印
线程A 我在打印
线程A 我在打印
线程A 我在打印
线程A 我在打印
线程A 我在打印
线程A 我在打印
...

例3：修饰一个方法，另一个方法不修饰

public class SynchronizedTest {

    public static void main(String[] args) {
        Hello hello = new Hello();
        new Thread(hello::printA, "线程A").start();
        new Thread(hello::printB, "线程B").start();
    }

    static class Hello {
        void printA() {
            for (; ; ) {
                System.out.println(Thread.currentThread().getName() + " 我在打印");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        synchronized void printB() {
            synchronized (this) {
                for (; ; ) {
                    System.out.println(Thread.currentThread().getName() + " 我在打印");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

执行结果：A和B两个线程交替执行

线程A 我在打印
线程B 我在打印
线程A 我在打印
线程B 我在打印
线程A 我在打印
线程B 我在打印
线程A 我在打印
线程B 我在打印
线程A 我在打印
线程B 我在打印
线程A 我在打印
线程B 我在打印
...

例4：修饰一个对象,对象中的方法都不需要加锁（没有synchronized修饰）

public class SynchronizedTest {

    public static void main(String[] args) {
        Hello hello = new Hello();
        synchronized (hello) {
            new Thread(hello::printA).start();
        }
        synchronized (hello) {
            new Thread(hello::printB).start();
        }
    }

    static class Hello {
        void printA() {
            for (; ; ) {
                System.out.println(Thread.currentThread().getName() + " 我在打印");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        void printB() {
            for (; ; ) {
                System.out.println(Thread.currentThread().getName() + " 我在打印");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

输出，线程交替执行

线程A 我在打印
线程B 我在打印
线程A 我在打印
线程B 我在打印
线程A 我在打印
线程B 我在打印
线程B 我在打印
线程A 我在打印
线程A 我在打印
线程B 我在打印
线程A 我在打印

例5：修饰一个对象，对象中的方法一个有synchronized修饰，一个没有

public class SynchronizedTest {

    public static void main(String[] args) {
        Hello hello = new Hello();
        synchronized (hello) {
            new Thread(hello::printA, "线程A").start();
        }
        synchronized (hello) {
            new Thread(hello::printB, "线程B").start();
        }
    }

    static class Hello {
        synchronized void printA() {
            for (; ; ) {
                System.out.println(Thread.currentThread().getName() + " 我在打印");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        void printB() {
            for (; ; ) {
                System.out.println(Thread.currentThread().getName() + " 我在打印");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

执行结果：

线程A 我在打印
线程B 我在打印
线程A 我在打印
线程B 我在打印
线程A 我在打印
线程B 我在打印
线程A 我在打印
线程B 我在打印
线程A 我在打印

例6： 修饰一个对象，对象中的方法都用synchronized修饰

public class SynchronizedTest {

    public static void main(String[] args) {
        Hello hello = new Hello();
        synchronized (hello) {
            new Thread(hello::printA, "线程A").start();
        }
        synchronized (hello) {
            new Thread(hello::printB, "线程B").start();
        }
    }

    static class Hello {
        synchronized void printA() {
            for (; ; ) {
                System.out.println(Thread.currentThread().getName() + " 我在打印");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        synchronized void printB() {
            for (; ; ) {
                System.out.println(Thread.currentThread().getName() + " 我在打印");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

执行结果：

线程A 我在打印
线程A 我在打印
线程A 我在打印
线程A 我在打印
线程A 我在打印
线程A 我在打印
线程A 我在打印
线程A 我在打印
线程A 我在打印

例7：修饰类

public class SynchronizedTest {

    public static void main(String[] args) {
        Hello hello = new Hello();
        synchronized (Hello.class) {
            new Thread(hello::printA, "线程A").start();
            new Thread(hello::printA, "线程B").start();
        }
    }

    static class Hello {
        void printA() {
            for (; ; ) {
                System.out.println(Thread.currentThread().getName() + " 我在打印");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

         void printB() {
            for (; ; ) {
                System.out.println(Thread.currentThread().getName() + " 我在打印");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

输出:

线程A 我在打印
线程B 我在打印
线程B 我在打印
线程A 我在打印
线程A 我在打印
线程B 我在打印
线程A 我在打印
线程B 我在打印

例8： 修饰类中的静态方法，同时执行synchronized修饰的静态和方法和没有修饰的静态方法

public class SynchronizedTest {

    public static void main(String[] args) {
        new Thread(Hello::printA, "线程A").start();
        new Thread(Hello::printB, "线程B").start();
    }

    static class Hello {
        synchronized static void printA() {
            for (; ; ) {
                System.out.println(Thread.currentThread().getName() + " 我在打印");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        static void printB() {
            for (; ; ) {
                System.out.println(Thread.currentThread().getName() + " 我在打印");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

输出:

线程A 我在打印
线程B 我在打印
线程A 我在打印
线程B 我在打印
线程A 我在打印
线程B 我在打印
线程A 我在打印
线程B 我在打印

例9： 修饰类中的静态方法，同时执行synchronized修饰的静态和方法

public class SynchronizedTest {

    public static void main(String[] args) {
        new Thread(Hello::printA, "线程A").start();
        new Thread(Hello::printB, "线程B").start();
    }

    static class Hello {
        synchronized static void printA() {
            for (; ; ) {
                System.out.println(Thread.currentThread().getName() + " 我在打印");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        synchronized static void printB() {
            for (; ; ) {
                System.out.println(Thread.currentThread().getName() + " 我在打印");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

输出:

线程A 我在打印
线程A 我在打印
线程A 我在打印
线程A 我在打印
线程A 我在打印
线程A 我在打印

总结一下:

  1. synchronized可以修饰静态方法、非静态方法、代码块、一个对象、一个类。
  2. 不管修饰的是谁，锁的都是synchronized 关键字后面的大括号包起来的部分。这一部分是不能被多线程同时访问的。
  3. 哪怕修饰的是对象或者类，只要多个线程执行的时候，不同时执行到对象或类中synchronized 修饰的部分，就可以执行。也就是说，给对象或者类加了锁，同时synchronized修饰的代码块和没有修饰的代码块都是可以的。
alwaysBrother
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于synchronized修饰静态和非静态方法
08-19
基于synchronized修饰静态和非静态方法 synchronized关键字是Java语言中的一种同步机制，用于解决多线程并发问题。在Java中，synchronized可以修饰静态方法和非静态方法，两者的锁机制不同。 非静态方法 ...
Java使用synchronized修饰方法来同步线程的实例演示
09-02
本文将深入探讨synchronized修饰方法在Java中的使用及其工作原理，并通过实例演示其应用。 1. **synchronized原理** synchronized基于Java的内置锁（也称为对象锁或 monitors）机制。当一个线程进入synchronized...
Java中Synchronized修饰不同位置的用法
ivalue的博客
11-23 4805
synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种： 1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； 2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 3. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是
synchronized修饰不同资源
袖卷笛音的博客
08-06 224
内置锁: 每个java对象都可以用做一个实现同步的锁，这些锁称为内置锁。线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法。 互斥锁: 内置锁是一个互斥锁，这就是意味着最多只有一个线程能够获得该锁，当线程A尝试去获得线程B持有的内置锁时，线程A必须等待或者阻塞...
多线程：synchronized 关键字用法（修饰类，方法，静态方法，代码块）
萨达哈鲁的博客
12-19 2万+
多线程：synchronized 关键字用法（修饰类，方法，静态方法，代码块）synchronized用法synchronized修饰的对象有几种： 修饰一个类：其作用的范围是synchronized后面括号括起来的部分，作用的对象是这个类的所有对象； 修饰一个方法：被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 修饰一个静态的方法：其作用的范围是整个方法，作用的
Synchronized在不同位置的用法
小七自学博客
11-27 1749
目录介绍修饰一个代码块例子：创建一个对象时，使用synchronized时创建一个对象时，不使用Synchronized创建两个对象使用synchronized时当一个线程访问synchronized代码块是，另一个线程访问不带有synchronized时修饰一个实例方法修饰一个静态方法使用synchronized时修饰一个类总结：Synchronized放在不同的位置总结代码 介绍 Synchronized是java内置的一个关键字，是一种同步锁，可以用有几种用法： 修饰一个代码块，被修饰的代码块称为同
关于多线程中synchronized的使用位置
光耀天下
12-23 1720
在练习多线程之售票的时候，对于synchronized的使用有些困惑，因为我是用以下代码： public class ThreadDemo5 { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub saleTicket_5 st =
Java多线程程序中synchronized修饰方法的使用实例
09-02
这里的`object`是锁对象，它可以是任何对象，根据同步范围的不同，锁的作用也不同。例如，如果我们希望只同步某个类的静态方法，可以将类的`Class`对象作为锁对象： ```java public class SynchronizedTest2 { ...
Java中synchronized关键字修饰方法同步的用法详解
09-02
以下是关于synchronized修饰方法同步的详细解析： 1. 非静态方法的同步： 当一个非静态方法被synchronized修饰时，该方法被称为同步方法。同步方法通过对象锁进行保护，同一时刻，只有一个线程能够访问该对象的...
Java关键字volatile和synchronized作用和区别
08-30
Java关键字volatile和synchronized是Java语言中两个常用的关键字，它们都是用来解决多线程编程中的同步问题的，但它们的作用和用法却有所不同。 volatile关键字是变量修饰符，它的作用是确保变量在多个线程之间的...
【多线程】synchronized的位置总结
wjx_jasin的博客
09-14 1137
在JAVA中synchronized关键字可以加载很多位置。您可以在一个方法定义上加synchronized关键字、也可以在方法体中加synchronized关键字、还可以在static块中加synchronized关键字。如下的代码都是正确的： // 代码片段1 static { synchronized(ThreadLock.class) { } } // 代码片段2 ...
synchronized的位置该怎么放?
3k油：知道的越多，不知道的越多
12-01 1031
（1）疑问:synchronized的位置应该怎么放? 实现接口的线程类 // 苹果对象实现Runnable接口 class Apple implements Runnable{ private int num = 50; @Override public void run() { for (int i = 0; i < 50; i++) { ...
synchronized
weixin_46049575的博客
02-15 69
在Java代码中，synchronized可使用在代码块和方法中，根据synchronized用的位置可以有这些使用场景： 如图，synchronized可以用在方法上也可以使用在代码块中，其中方法是实例方法和静态方法分别锁的是该类的实例对象和该类的对象。而使用在代码块中也可以分为三种，具体的可以看上面的表格。这里的需要注意的是：如果锁的是类对象的话，尽管new多个实例对象，但他们仍然是属于同一个类依然会被锁住，即线程之间保证同步关系。 ...
synchronized的使用方法
热门推荐
WitsMakeMen的专栏
11-13 3万+
记下来，很重要。 Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。      一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。      二、然而，当一个线程访问object的
synchronized不同位置的实现原理
qq_36707152的博客
11-25 564
1、synchronized加在不同位置的区别 普通同步方法，锁的是当前实例对象 对于同步代码块，锁的是Synchronized括号中的代码块 静态同步方法，锁的是当前Class对象 2、synchronized加在不同位置的实现方式 1、不用锁 首先用一个简单的代码来测试一下，有啥区别，首先是不加锁的正常代码，代码如下： public class Test { public static void main(String[] args) { new Test()
synchronized用法及总结
qq_36908783的博客
05-29 943
1、为什么需要使用synchronized 2、使用范围 2.1 多个线程访问同一个对象的同步代码块 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； public class Solution { public static void main(String[] args) { SyncThread syncThread=new SyncThread(); Thread thread1=new
Java关于Synchronized关键字在不同位置使用的理解
技海拾贝
03-10 4128
Java中的Syncronized关键字可以用来修饰同步方法：像这样synchronized void f() {/*body*/}和同步语句块：像这样synchronized(object){/*body*/}。 其中修饰同步方法可以分为修饰static方法和实例方法。 其中修饰同步语句块还可以分为修饰instance变量，Object Reference对象引用，class 字面常量。
Spring事务和synchronized锁的问题
smileyguo的专栏
06-04 495
场景：为避免信息提交重复，给事务方法增加了synchronized修饰符，实际场景中仍然无法完全避免重复，因为在第一个线程执行完synchronized代码段后，此时spring还未完成事务提交，但是其他线程yiji ...
synchronized修饰类的注意事项
qq_25073223的博客
08-08 337
synchronized修饰类注意事项简介说明
synchronized 修饰有什么作用
最新发布
07-15
synchronized关键字用于实现线程同步，它可以修饰方法或代码块。其作用是确保在同一时间只有一个线程可以访问被修饰的方法或代码块。 具体来说，当一个线程进入一个被synchronized修饰的方法或代码块时，它会自动获取对象的锁。其他线程如果想要执行相同的方法或代码块，必须等待当前线程释放锁。这样可以避免多个线程同时访问共享资源导致的数据不一致或冲突问题。 synchronized关键字的作用包括： 1. 线程安全：确保在多线程环境下对共享资源的访问是安全的。 2. 互斥性：同一时间只有一个线程可以执行被synchronized修饰的方法或代码块，避免了竞争条件。 3. 内存可见性：synchronized关键字会强制将修改过的共享变量的值从线程的本地内存刷新到主内存，以保证不同线程之间的可见性。 需要注意的是，使用synchronized关键字可能会导致性能下降，因为它会引入线程的等待和唤醒操作。在实际应用中，应该根据具体情况合理选择使用synchronized关键字来保证线程安全和性能的平衡。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值