Synchronized使用方式

最新推荐文章于 2024-03-03 21:02:09 发布
最新推荐文章于 2024-03-03 21:02:09 发布
阅读量180 收藏
点赞数 1
分类专栏： 集合源码+JUC源码 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45862170/article/details/120515334
版权

Synchronized使用方式

demo1

package com.w.juc;

public class SynchronizedDemo {

    static int value;


    public static void increment() {
        for (int i = 0; i <10000; i++) {
            value++;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> increment(), "线程【A】");
        Thread thread1 = new Thread(() -> increment(), "线程【B】");
        thread.start();
        thread1.start();
        thread.join();//等待线程A执行完毕后返回
        thread1.join();
        System.out.println(value);//这里正常想要打印出来2万
    }
}

上面代码并没有用到synchronized，也就是说并未同步。先说明上面代码是一个有着并发问题的代码：value是一个共享变量，而value++其实是三步操作，先读取，后+1，最后写入。对于A，B线程来说，可能出现如下场景，线程A读取了value=4，在未+1时，线程B也读取到了value=4。这时线程A执行完毕value=5，但是对于线程B执行后的结果也是value=5,这就少加了一次。

可见，多个线程共同访问修改一个共享变量会出现并发问题，所以需要解决，这里就使用到了synchronized，当然并发包下的也可以用。

synchronized实现同步的三种方式。

  • 可以锁普通方法
  • 锁静态方法
  • 代码块

demo2

package com.w.juc;

public class SynchronizedDemo {

    static int value;


    public static synchronized void increment() {
        for (int i = 0; i <10000; i++) {
            value++;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> increment(), "线程【A】");
        Thread thread1 = new Thread(() -> increment(), "线程【B】");
        thread.start();
        thread1.start();
        thread.join();
        thread1.join();
        System.out.println(value);//一定输出2万
    }
}

先使用的是在静态方法上使用。锁的是当前Class对象，类对象。或者

demo3

package com.w.juc;

public class SynchronizedDemo {

    static int value;


    public  synchronized void increment() {
        for (int i = 0; i <10000; i++) {
            value++;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        SynchronizedDemo sd = new SynchronizedDemo();
        Thread thread = new Thread(sd::increment, "线程【A】");//Java8特性，方法引用
        Thread thread1 = new Thread(() -> sd.increment(), "线程【B】");//Lambda表达式
        thread.start();
        thread1.start();
        thread.join();
        thread1.join();
        System.out.println(value);
    }
}

demo3锁的是对象实例，也就是sd。现在demo3锁的是Class对象，对于demo2和demo3来说好像没什么区别都是正常输出2万

但是现在看看demo4

package com.w.juc;

public class SynchronizedDemo {

    static int value;


    public  synchronized void increment() {
        for (int i = 0; i <10000; i++) {
            value++;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        SynchronizedDemo sd = new SynchronizedDemo();
        SynchronizedDemo sd2 = new SynchronizedDemo();//和demo3区别
        Thread thread = new Thread(sd::increment, "线程【A】");
        Thread thread1 = new Thread(() -> sd2.increment(), "线程【B】");//区别
        thread.start();
        thread1.start();
        thread.join();
        thread1.join();
        System.out.println(value);
    }
}

对于普通方法上加锁，锁的是当前实例对象，也就是demo4中sd和sd2这是俩对象，所以线程A持有锁sd，线程B持有锁sd1，这样大家互不干扰，也就都可以同时访问修改value和deom1一样的并发问题出现了。怎么解决呢？看看demo2，锁的是类对象，而类对象只存在一个。看demo5吧

demo5

package com.w.juc;

public class SynchronizedDemo {

    static int value;


    public static synchronized void increment() {//加static，锁的就是类对象
        for (int i = 0; i <10000; i++) {
            value++;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        SynchronizedDemo sd = new SynchronizedDemo();
        SynchronizedDemo sd2 = new SynchronizedDemo();
        Thread thread = new Thread(()->sd.increment(), "线程【A】");//这里我的会报错。。。因为加了阿里巴巴规范插件，不推荐我使用对象实例调用类的静态成员
        Thread thread1 = new Thread(() -> sd2.increment(), "线程【B】");
        thread.start();
        thread1.start();
        thread.join();
        thread1.join();
        System.out.println(value);//正常输出2万
    }
}

锁了类对象，俩实例对象sd和sd2就会独占的获取锁，同一时刻只有一个线程才能进入increment方法

以问题深入记忆三种使用方式

可以看视频

问题1：标志访问先打印哪个？

package com.w.juc;

class Person{
    public synchronized void eatFood(){
        System.out.println("吃肉");
    }

    public synchronized void drinkWater(){
        System.out.println("喝水");
    }
}

public class SynchronizedDemo {
    
    public static void main(String[] args) throws InterruptedException {
        Person person = new Person();
        new Thread(()->person.eatFood(),"t1").start();
        new Thread(()->person.drinkWater(),"t2").start();
    }
}
//吃肉
//喝水

解释：对普通方法使用synchronized锁的是当前实例对象person，当线程t1启动则获取到锁，线程t2必须等待t1执行结束后执行

问题2：吃饭用2s，先打印哪个？

package com.w.juc;

class Person{
    public synchronized void eatFood(){
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("吃肉");
    }

    public synchronized void drinkWater(){
        System.out.println("喝水");
    }
}

public class SynchronizedDemo {

    public static void main(String[] args) throws InterruptedException {
        Person person = new Person();
        new Thread(()->person.eatFood(),"t1").start();
        new Thread(()->person.drinkWater(),"t2").start();
    }
}
//吃肉
//喝水

解释:和问题1一样
问题3：新增普通方法sleep，先打印哪个？

package com.w.juc;

class Person{
    public synchronized void eatFood(){
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("吃肉");
    }

    public synchronized void drinkWater(){
        System.out.println("喝水");
    }

    public void toSleep(){
        System.out.println("睡觉");
    }
}

public class SynchronizedDemo {

    public static void main(String[] args) throws InterruptedException {
        Person person = new Person();
        new Thread(()->person.eatFood(),"t1").start();
        new Thread(()->person.toSleep(),"t2").start();
    }
}
睡觉
吃肉

解释：睡觉是个普通未同步方法，随时可以访问，只要线程t2不去抢实例对象person锁，则不会被阻塞。

问题4:俩人，先吃肉还是喝水？

package com.w.juc;

class Person{
    public synchronized void eatFood(){
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("吃肉");
    }

    public synchronized void drinkWater(){
        System.out.println("喝水");
    }

    public void toSleep(){
        System.out.println("睡觉");
    }
}

public class SynchronizedDemo {

    public static void main(String[] args) throws InterruptedException {
        Person person1 = new Person();
        Person person2 = new Person();
        new Thread(()->person1.eatFood(),"t1").start();
        new Thread(()->person2.drinkWater(),"t2").start();
    }
}
喝水
吃肉

解释：俩人只要不去干同一件事就不会有冲突，锁的是当前实例对象，线程t1和线程t2持有的锁不一样，就不会冲突，也就不存在因为锁阻塞线程

问题5:静态同步方法，一个人，先吃肉还是喝水？

package com.w.juc;

class Person{
    public static synchronized void eatFood(){
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("吃肉");
    }

    public static synchronized void drinkWater(){
        System.out.println("喝水");
    }

    public void toSleep(){
        System.out.println("睡觉");
    }
}

public class SynchronizedDemo {

    public static void main(String[] args) throws InterruptedException {
        Person person1 = new Person();
        Person person2 = new Person();
        new Thread(()->person1.eatFood(),"t1").start();
        new Thread(()->person1.drinkWater(),"t2").start();
    }
}
吃肉
喝水

解释：在静态方法上面用synchroniezd，锁的是当前类对象，只有一个类对象。所以各个线程还是需要等待锁的获取

package com.w.juc;

class Person{
    public static synchronized void eatFood(){
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("吃肉");
    }

    public static synchronized void drinkWater(){
        System.out.println(Thread.currentThread()+"喝水");
    }

    public void toSleep(){
        System.out.println("睡觉");
    }
}

public class SynchronizedDemo {

    public static void main(String[] args) throws InterruptedException {
        Person person1 = new Person();
        Person person2 = new Person();
        new Thread(()->person1.eatFood(),"t1").start();

        new Thread(()->person1.drinkWater(),"t2").start();
        new Thread(()->person1.drinkWater(),"t1").start();
    }
}
吃肉
Thread[t1,5,main]喝水
Thread[t2,5,main]喝水

这里按照程序顺序应该是线程t2先喝水，为什么执行却是线程t1先喝？因为重进入，虽然线程t1和t2喝水都被阻塞了，但是t1先持有锁，可重进入锁就快

问题6:静态同步方法，俩人，先打印吃肉还是喝水?

package com.w.juc;

class Person{
    public static synchronized void eatFood(){
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("吃肉");
    }

    public static synchronized void drinkWater(){
        System.out.println(Thread.currentThread()+"喝水");
    }

    public void toSleep(){
        System.out.println("睡觉");
    }
}

public class SynchronizedDemo {

    public static void main(String[] args) throws InterruptedException {
        Person person1 = new Person();
        Person person2 = new Person();
        new Thread(()->person1.eatFood(),"t1").start();

        new Thread(()->person2.drinkWater(),"t2").start();

    }
}
吃肉
Thread[t2,5,main]喝水

解释：和问题5一样，静态方法，获取到的锁是类对象，只有一个，也就是说同时只有一个线程可以获取到锁，去执行方法。

问题7：一个静态同步方法,一个普通方法，一个人,会先打印什么

package com.w.juc;

class Person{
    public static synchronized void eatFood(){
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("吃肉");
    }

    public static synchronized void drinkWater(){
        System.out.println(Thread.currentThread()+"喝水");
    }

    public void toSleep(){
        System.out.println("睡觉");
    }
}

public class SynchronizedDemo {

    public static void main(String[] args) throws InterruptedException {
        Person person1 = new Person();
        Person person2 = new Person();
        new Thread(()->person1.eatFood(),"t1").start();

        new Thread(()->person1.toSleep(),"t2").start();

    }
}
睡觉
吃肉

解释: 普通方法可以任意访问，不受限制

问题8：一个静态同步方法,一个普通方法，俩个人,会先打印什么

package com.w.juc;

class Person{
    public static synchronized void eatFood(){
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("吃肉");
    }

    public static synchronized void drinkWater(){
        System.out.println(Thread.currentThread()+"喝水");
    }

    public void toSleep(){
        System.out.println("睡觉");
    }
}

public class SynchronizedDemo {

    public static void main(String[] args) throws InterruptedException {
        Person person1 = new Person();
        Person person2 = new Person();
        new Thread(()->person1.eatFood(),"t1").start();

        new Thread(()->person2.toSleep(),"t2").start();

    }
}
睡觉
吃肉

解释：和问题7一样，没有同步的方法并不会是独占的，任意线程都可以访问。

以上只是写了怎么使用和一些理解。主要还得深究原理，和JVM相关，对象头。

天上飞的云传奇
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
synchronized三种使用方式(有图)
半页童话
11-06 2593
什么是线程安全 从图中可以看出线程安全只要包括变量在多个线程之间共享、生命周期内状态可以改变、最后结果和预期一致，就是线程安全的。 Synchronized的三种使用方式 1.普通同步方法(实例方法)锁是当前实例对象,进入同步代码前要获得当前实例的锁 2.静态同步方法,锁是当前类的class对象,进入同步代码前要获得当前类对象的锁 3.同步方法块,锁是括号里面的对象,对给定对象加锁,进入同步代...
Synchronized 使用方式
User_meng的博客
03-10 165
Synchronized 使用方式 修饰到方法上 以下的m1\m2方法上加锁相当于，把锁加在this对象上，所以只有m1下城执行完成m2线程才可以继续执行 public class T1 { private static synchronized void m1() { for (int i = 0; i < 10; i++) { try { Thread.sleep(1000); Syst
synchronized用法详解
最新发布
qq_43842093的博客
03-03 3285
synchronized 是 Java 中的关键字，是一种同步锁。主要应用于多线程环境下保证线程的安全性。A. 无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。B. 每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。C. 实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。
synchronized的4种用法
WJ S的专栏
11-21 1044
原文地址：http://hi.baidu.com/wojiubaibudu/blog/item/a27d671ed654cae6e1fe0b42.html synchronized的4种用法 1.方法声明时使用,放在范围操作符(public等)之后,返回类型声明(void等)之前.即一次只能有一个线程进入该方法,其他线程要想在此时调用该方法,只能排队等候,当前线程(就是在synchroni
synchronized 的 8 种用法，你会几种？
weixin_64051447的博客
08-29 720
本文将介绍8种同步方法的访问场景，我们来看看这8种情况下，多线程访问同步方法是否还是线程安全的。这些场景是多线程编程中经常遇到的，而且也是面试时高频被问到的问题，所以不管是理论还是实践，这些都是多线程场景必须要掌握的场景。本文总结了并用代码实现和验证了各种使用场景，以及各种场景发生的原因和结论。我们分析的理论基础都是关键字的锁对象究竟是谁？多个线程之间竞争的是否是同一把锁？根据这个条件来判断线程是否是安全的。
Java中synchronized正确使用方法解析
08-25
Java 中 synchronized 正确使用方法解析 Java 中 synchronized 关键字是解决线程安全问题的重要手段，它可以确保在多线程环境下，共享资源的访问安全性。本文将详细介绍 Java 中 synchronized 的正确使用方法，通过...
Java synchronized关键字使用方式及特性解析
08-25
synchronized关键字可以用于实现线程同步，以下是使用synchronized的四种方式： 1. 作用在方法上，保证了访问同一个对象的同一个方法的线程同步 在Java中，使用synchronized关键字可以作用在方法上，从而保证了...
Java Synchronized的使用详解
08-18
3. Synchronized的三种应用方式 Java中每一个对象都可以作为锁，这是Synchronized实现同步的基础： * 普通同步方法（实例方法）：锁是当前实例对象，进入同步代码前要获得当前实例的锁。 * 静态同步方法：锁是当前...
Synchronized 和 Lock 的区别和使用场景
01-20
本文将深入探讨两种主要的锁机制：`synchronized`关键字和`Lock`接口，以及它们各自的特点、应用场景和使用方式。 一、Synchronized `synchronized`是Java中的一个内置关键字，用于提供线程安全。它的主要作用是...
Java中使用synchronized关键字实现简单同步操作示例
09-03
根据具体需求，可以选择合适的方式使用`synchronized`关键字，以确保同步的粒度和效率。需要注意的是，过度使用`synchronized`可能导致性能下降，因此在设计多线程程序时，应谨慎权衡同步与性能之间的关系。
synchronized的使用方法
叶落啼莺
08-31 1756
转来的，谢谢版主... Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。      一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。      二、然而，当一个线程访问o...
Synchronized原理分析
m0_37235955的博客
04-25 263
Synchronized原理分析 加锁和释放锁的原理 深入JVM看字节码，创建如下的代码： 1 public class SynchronizedDemo2 { 2 Object object = new Object(); 3 public void method1() { 4 synchronized (object) { 5 6 } 7 } 8 } 使用 javac命令进行编译生成 .class文件 >javac Synchronize
synchronized 看一遍就能懂
yangaliang的博客
03-19 508
synchronized的三种应用方式synchronized关键字最主要有以下3种应用方式，下面分别介绍修饰实例方法，作用于当前实例加锁，进入同步代码前要获得当前实例的锁修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。synchronized作用于实例方法所谓的实例对象锁就是用synchroniz...
synchronized的使用方法（2）
Heaven_of_relaxing的博客
05-08 458
Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。      一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。      二、然而，当一个线程访问object的一个s
synchronized的四种用法
诚的博客
05-07 9135
同步锁 synchronized顾名思义，就是用来进行一些同步工作的，我们常常在多线程的环境中使用到它，实现互斥的效果。 每一个java对象都可以当做一个同步锁，线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得锁的唯一途径就是进入这个锁的保护的同步代码块或方法。这里的同步代码块和同步方法，就是使用synchronized关键字标记的代码块和方法。比如： synchronized (object) { //doSomething... .
synchronized 的用法
晓游的专栏
06-02 1233
synchronized 是java中的关键字，同步锁，用于解决多线程安全问题。 有以下几种用法一. 修饰一个代码块， 被修饰的代码块称为同步语句块，其同步的作用范围是大括号{}括起来的代码块，锁住的对象由synchronized 后面的小括号里的内容决定。锁会有同步代码块执行完成时释放.     小括号里的内容有以下几种场景  a、synchronized(this) { 同步代码块 }    ...
synchronized最主要的使用方式
07-13
synchronized最主要的使用方式是通过修饰方法或代码块来实现线程安全和线程同步。 1. 修饰方法：将synchronized关键字直接应用于方法上，可以保证同一时刻只有一个线程可以执行该方法。当一个线程进入synchronized...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值