Synchronized

最新推荐文章于 2024-04-04 19:44:22 发布
最新推荐文章于 2024-04-04 19:44:22 发布
阅读量543 收藏 1
点赞数
分类专栏： juc 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44740736/article/details/129188994
版权

1 介绍

可以修饰一下四种类型

  • 修饰代码块
  • 修饰方法
  • 修饰静态方法
  • 修饰类
    本质上修饰的只有两种
  • 实例化的对象
  • 类

2 用法

2.1 修饰代码块

synchronized 这里修饰的是代码快，实际修饰的是Object这个对象的实例lock（给lcok这个对象实例加锁）。
两个代码块运行都需要lock这个对象，所以保证了同步

public static void main(String[] args) throws InterruptedException {
    // 创建锁对象 lock
    Object lock = new Object();
    Thread thread1 = new Thread(() -> {
        // synchronized修饰下面代码，执行下面代码需要获取lock对象，并且不让其他人获取lock对象
        synchronized (lock) {
            for (int i = 0; i < 5000; i++) {
                count++;
            }
        }
    });

    Thread thread2 = new Thread(() -> {
        // synchronized修饰下面代码，执行下面代码需要获取lock对象，并且不让其他人获取lock对象
        synchronized (lock) {
            for (int i = 0; i < 5000; i++) {
                count--;
            }
        }
    });
    thread1.start();
    thread2.start();
    thread1.join();
    thread2.join();
    System.out.println(count);
}

2.2 修饰方法

修饰非静态方法，锁的是这个方法的对象（实例）

public class Demo {

    static int count = 0;

    public static void main(String[] args) throws InterruptedException {
        SyncDemo demo = new SyncDemo();
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                demo.add();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                demo.add();
            }
        });
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println(count);
    }
}

public class SyncDemo {
    public synchronized void add(){
        Demo.count++;
    }
}

2.3 修饰静态方法

这里synchronized修饰的是静态方法add()，那就是给这个静态方法所属的类加锁
运行这个方法需要获取当前类，也就是当前类的class对象

static int count = 0;

public static void main(String[] args) throws InterruptedException {
     Thread thread1 = new Thread(() -> {
         add();
     });

     Thread thread2 = new Thread(() -> {
         add();
     });
     thread1.start();
     thread2.start();
     thread1.join();
     thread2.join();
     System.out.println(count);
 }
 /**
  * synchronized修饰方法,表示该方法被使用时会上锁，不能被其他线程调用
  */
 public synchronized static void add() {
     for (int i = 0; i < 5000; i++) {
         count++;
     }
 }

2.4 修饰类

static int count = 0;

public static void main(String[] args) throws InterruptedException {
  
    Thread thread1 = new Thread(() -> {
        synchronized (SyncDemo.class) {
            for (int i = 0; i < 5000; i++) {
                count ++;
            }
        }
        
    });

    Thread thread2 = new Thread(() -> {
        synchronized (SyncDemo.class) {
            for (int i = 0; i < 5000; i++) {
                count --;
            }
        }
    });
    thread1.start();
    thread2.start();
    thread1.join();
    thread2.join();
    System.out.println(count);
}

3 线程八锁

3.1

synchronized 修饰成员方法，修饰对象实例
结果12 或者21

@Slf4j
public class Demo {

    public static void main(String[] args) throws InterruptedException {
        Number number = new Number();
        new Thread(() -> {
            log.info("begin...");
            number.a();
        }).start();
        new Thread(() -> {
            log.info("begin...");
            number.b();
        }).start();
    }
}

@Slf4j
class Number {
    public synchronized void a() {
        log.info("1");
    }

    public synchronized void b() {
        log.info("2");
    }
}

3.2

synchronized 修饰成员方法，修饰对象实例
结果 1 1秒后 2 | 2 1秒后 1

@Slf4j
public class Demo {

    public static void main(String[] args) throws InterruptedException {
        Number number = new Number();
        new Thread(() -> {
            log.info("begin...");
            number.a();
        }).start();
        new Thread(() -> {
            log.info("begin...");
            number.b();
        }).start();
    }
}

@Slf4j
class Number {
    public synchronized void a() throws InterruptedException {
        TimeUnit.SECONDS.sleep(1);
        log.info("1");
    }

    public synchronized void b() {
        log.info("2");
    }
}

3.3

这里多了一个c方法，但是没有被synchronized 修饰
所以c方法的运行和 a b方法没有关系
a b互斥 c随意
c的运行一定在a前

@Slf4j
public class Demo {

    public static void main(String[] args) throws InterruptedException {
        Number number = new Number();
        new Thread(() -> {
            log.info("begin...");
            number.a();
        }).start();
        new Thread(() -> {
            log.info("begin...");
            number.b();
        }).start();
        new Thread(() -> {
            log.info("begin...");
            number.c();
        }).start();
    }
}

@Slf4j
class Number {
    public synchronized void a() throws InterruptedException {
        TimeUnit.SECONDS.sleep(1);
        log.info("1");
    }

    public synchronized void b() {
        log.info("2");
    }
    
    public void c() {
        log.info("2");
    }
}

3.4

锁的不是同一个对象实例，所以a b没有关系

@Slf4j
public class Demo {

    public static void main(String[] args) throws InterruptedException {
        Number number1 = new Number();
        Number number2 = new Number();
        new Thread(() -> {
            log.info("begin...");
            number1.a();
        }).start();
        new Thread(() -> {
            log.info("begin...");
            number2.b();
        }).start();
    }
}

@Slf4j
class Number {
    public synchronized void a() throws InterruptedException {
        TimeUnit.SECONDS.sleep(1);
        log.info("1");
    }

    public synchronized void b() {
        log.info("2");
    }
}

3.5

a锁的是类，b锁的是对象实例，二者没有关系

@Slf4j
public class Demo {

    public static void main(String[] args) throws InterruptedException {
        Number number1 = new Number();
        Number number2 = new Number();
        new Thread(() -> {
            log.info("begin...");
            try {
                Number.a();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        new Thread(() -> {
            log.info("begin...");
            number2.b();
        }).start();
    }
}

@Slf4j
class Number {
    public static synchronized void a() throws InterruptedException {
        TimeUnit.SECONDS.sleep(1);
        log.info("1");
    }

    public synchronized void b() {
        log.info("2");
    }
}

3.6

a b锁的都是类，互斥

@Slf4j
public class Demo {

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            log.info("begin...");
            try {
                Number.a();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        new Thread(() -> {
            log.info("begin...");
            Number.b();
        }).start();
    }
}

@Slf4j
class Number {
    public static synchronized void a() throws InterruptedException {
        TimeUnit.SECONDS.sleep(1);
        log.info("1");
    }

    public static synchronized void b() {
        log.info("2");
    }
}

3.7

a 锁的是类 b 锁对象实例 二者没有关系

@Slf4j
public class Demo {

    public static void main(String[] args) throws InterruptedException {
        Number number1 = new Number();
        Number number2 = new Number();
        new Thread(() -> {
            log.info("begin...");
            try {
                number1.a();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        new Thread(() -> {
            log.info("begin...");
            number2.b();
        }).start();
    }
}

@Slf4j
class Number {
    public static synchronized void a() throws InterruptedException {
        TimeUnit.SECONDS.sleep(1);
        log.info("1");
    }

    public synchronized void b() {
        log.info("2");
    }
}

3.8

a锁类 b锁类 二者互斥

@Slf4j
public class Demo {

    public static void main(String[] args) throws InterruptedException {
        Number number1 = new Number();
        Number number2 = new Number();
        new Thread(() -> {
            log.info("begin...");
            try {
                number1.a();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        new Thread(() -> {
            log.info("begin...");
            number2.b();
        }).start();
    }
}

@Slf4j
class Number {
    public static synchronized void a() throws InterruptedException {
        TimeUnit.SECONDS.sleep(1);
        log.info("1");
    }

    public static synchronized void b() {
        log.info("2");
    }
}

3 用法

别偏爱我
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
synchronized锁（方法锁, 代码块锁）
Lucifer ZHAO
05-16 5715
synchronized锁可以解决线程安全问题，但是相应的，只要是锁，就会带来性能开销，所以尽可能减小锁的范围尤为重要。 synchronized锁无非修饰普通方法，修饰静态方法，修饰代码块，我认为无非就两种（对象锁、类锁），只不过是锁的使用对象不同而已，实际上synchronized锁的作用范围，取决于使用对象的生命周期。接下来简单介绍几种不同影响范围的锁。...
java线程同步代码块_线程间的同步与通信(1)——同步代码块Synchronized
weixin_26824299的博客
02-26 347
前言同步代码块(Synchronized Block) 是java中最基础的实现线程间的同步与通信的机制之一，本篇我们将对同步代码块以及监视器锁的概念进行讨论。什么是同步代码块(Synchronized Block)同步代码块简单来说就是将一段代码用一把锁给锁起来, 只有获得了这把锁的线程才访问, 并且同一时刻, 只有一个线程能持有这把锁, 这样就保证了同一时刻只有一个线程能执行被锁住的代码.这里...
synchronized到底锁住的是谁？
最新发布
weixin_39038328的博客
04-04 773
我们使用synchronized关键字是用来实现线程同步的，当多个线程同时去争抢同一个资源的时候在资源上边加一个synchronized关键字，能够使得线程排队去完成操作。
Java关键字——synchronized
weixin_42547014的博客
07-21 2870
什么是synchronize 如何使用 底层原理 做过那些优化 对象在内存中 用户态？内核态？ 为什么效率低 一、认识 Synchronized synchornized 是 Java 中的一个关键字，解决的是多个线程之间访问资源的同步性，synchronized 关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。 另外，在 Java 早期版本中，synchronized 属于 重量级锁，效率低下。 重量级锁：其他线程试图获取锁时，都会被阻塞，只有持有锁的线程释放锁之后才会唤醒这些线.
【多线程】(3)(synchronized 关键字 可重入 synchronized修饰方法 修饰代码块 Java标准库中线程安全类 volatile 关键字 wait 和 notify)
m0_68800221的博客
07-14 152
CPU读取寄存器比读取内存速度快很多,一次就会在CPU内部引入缓存cache,寄存器存储空间小,读写速度快,贵,中间有个cache,它存储空间居中读写速度居中,成本居中,内存的存储空间大,读写速度慢,便宜.当CPU要读取一个内存数据的时候,可能是直接读内存,也可能是读cache,还可能是读寄存器.比如t1,t2两个线程,希望t1先干活,等干的差不多了,再让t2来干.就可以让t2先wait(阻塞,主动放弃CPU),等t1干的差不多了,再通过notify通知t2,把t2唤醒让t2接着干.
synchronized 代码块（静态变量与.class区别 ）
m0_60879619的博客
05-24 180
请帮解惑其中区别原理，目前发现 示例中 synchronized (digitCard) 就是上面第三种，看结果是保证了线程同步执行，但是看打印语句，又似乎每个线程还未执行完，就释放锁，执行其他线程，然后又回来哈哈😂，但是最终结果是对的，就是还是保证了原子性，难道是jvm自己排序了，导致打印错乱了，实际上运行时正确的？请热心大佬帮看下，我在看相关文章时，测试敲一下相关代码，发现 synchronized 代码块 的三种情况（其实还有一种成员变量 一会在试下），发现有。
synchronized.md
02-24
关于synchronized的自学笔记
详解java中的synchronized关键字
09-03
在Java编程语言中，`synchronized`关键字是一个重要的并发控制机制，用于确保多线程环境下的数据一致性。本文将深入探讨`synchronized`关键字的使用和功能。 首先，`synchronized`关键字可以应用于方法和代码块，以...
Java中synchronized正确使用方法解析
08-25
Java 中 synchronized 正确使用方法解析 Java 中 synchronized 关键字是解决线程安全问题的重要手段，它可以确保在多线程环境下，共享资源的访问安全性。本文将详细介绍 Java 中 synchronized 的正确使用方法，通过...
简单了解synchronized和lock的区别
08-25
了解synchronized和lock的区别 synchronized是Java语言中的一个关键字，用于线程同步，主要用于解决多线程之间的竞争问题。它可以将某个方法或代码块锁定，使得只有一个线程可以执行该方法或代码块，其他线程只能...
Java使用synchronized修饰方法来同步线程的实例演示
09-02
在Java编程语言中，synchronized关键字用于实现线程同步，以确保多线程环境下的数据一致性。它主要用于控制对共享资源的并发访问，防止多个线程同时进入临界区，可能导致数据不一致或竞态条件的问题。本文将深入探讨...
synchronized详解
weixin_53818213的博客
09-06 316
synchronized简介，使用，底层原理，synchronized的优化，锁对比等。
多线程：Synchronized的使用（一）——修饰方法、静态方法、代码块
weixin_41975299的博客
10-20 3444
Synchronized是什么？ Synchronized是Java的关键字，字面意思上是同步的意思，也就是说可以用它修饰普通方法、静态方法、代码块，达到同步的效果，就是我们俗称的上锁。 Synchronized作用域和作用对象？ 使用Synchronized修饰普通方法 使用Synchronized修饰普通方法，作用域是整个方法，作用对象是该类的当前对象，不同对象会持有不同的锁。下面我们来看看代码： public class SynchronizedMethodTest { sync
JAVA中同步锁synchronized的使用
qq_35321791的博客
11-16 2815
JAVA中同步锁synchronized的使用
多线程：synchronized 关键字用法（修饰类，方法，静态方法，代码块）
热门推荐
萨达哈鲁的博客
12-19 2万+
多线程：synchronized 关键字用法（修饰类，方法，静态方法，代码块）synchronized用法synchronized修饰的对象有几种： 修饰一个类：其作用的范围是synchronized后面括号括起来的部分，作用的对象是这个类的所有对象； 修饰一个方法：被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 修饰一个静态的方法：其作用的范围是整个方法，作用的
Java多线程（三）------深度解析：synchronized修饰方法与代码块的区别
weixin_44431073的博客
10-15 1320
初学多线程，肯定会接触同步。我们知道synchronized关键词可以修饰代码块，也可以修饰方法。那么具体修饰有什么区别呢？ 一、含义 关于含义的资料随便一搜就是一大把，我在这里列出一篇文章的介绍： synchronized 是同步锁，用来实现互斥同步。 在 Java 中，关键字 synchronized 可以保证在同一个时刻，只有一个线程可以执行某个方法或者某个代码块（主要是对方法或者代码块中存在共享数据的操作）。 syn...
synchronized修饰方法和修饰方法块（二）
feicongcong的博客
08-13 673
synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。 　　1. synchronized 方法：通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如： 　　public synchronized void accessVal(int newVal); 　　synchronized 方法控制
使用synchronized的几种场景
weixin_33912638的博客
10-05 656
1.修饰一个方法synchronized 修饰一个方法很简单，就是在方法的前面加synchronized，例如： public synchronized void method() { // todo } 在定义接口方法时不能使用synchronized关键字。 构造方法不能使用synchronized关键字，但可以使用synchronized代码块来进行同步。 synchroniz...
synchronized修饰代码块-对象锁
努力改变人生
06-02 389
测试主函数： package test0602; /** * @author zhongzhilong * @date 2021/6/2 * @description 测试synchronized修饰代码块 */ public class ThreadTest { public static void main(String[] args) { ClassLock classLock = new ClassLock(); // 线程1 Thr
synchronized
09-13
synchronized 是 Java 中用于实现线程同步的关键字。当一个方法或一个代码块被 synchronized 修饰时，意味着在同一时间只能有一个线程访问该方法或代码块。 使用 synchronized 可以避免多个线程同时访问共享资源而...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值