线程同步 synchronized 和 Lock 的区别

最新推荐文章于 2022-03-23 01:42:14 发布
最新推荐文章于 2022-03-23 01:42:14 发布
阅读量309 收藏 3
点赞数 1
分类专栏： 线程同步 文章标签： 同步 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43912697/article/details/114272399
版权 
synchronized 和 Lock 的区别：
① synchronized是内置的Java关键字，Lock是一个接口
② synchronized无法判断是否获取到锁，Lock可以判断是否获取到锁
③ synchronized会自动释放锁，Lock必须要手动释放锁，否则可能会死锁！
④ synchronized当有两个线程，其中一个得到锁，另一个线程则死等，Lock不一定会死等
⑤ synchronized是可重入锁 不可中断的 非公平锁，Lock是可重入锁 可以判断锁 可设为公平锁
⑥ synchronized适合锁少量的代码同步问题，Lock适合锁大量的同步代码
卖票举例：

① 使用synchronized进行线程同步：

public class Demo01 {
    public static void main(String[] args) {
        // 并发，多线程操作统一资源
        Ticket ticket = new Ticket();

        new Thread(()->{ // Lambda表达式
            for (int i = 0; i < 60; i++) {
                ticket.saleTicket();
            }
        },"张三").start();
        new Thread(()->{
            for (int i = 0; i < 60; i++) {
                ticket.saleTicket();
            }
        },"李四").start();
        new Thread(()->{
            for (int i = 0; i < 60; i++) {
                ticket.saleTicket();
            }
        },"王五").start();
    }
}
class Ticket{
    private int number = 50;

    public synchronized void saleTicket(){ // 同步方法
        if (number>0){
            System.out.println(Thread.currentThread().getName()+"卖出了第"+(number--)+"张票");
        }
    }
}

结果：

张三卖出了第50张票
张三卖出了第49张票
张三卖出了第48张票
张三卖出了第47张票
......(此处省略)
张三卖出了第5张票
张三卖出了第4张票
张三卖出了第3张票
张三卖出了第2张票
张三卖出了第1张票

② 使用Lock进行线程同步：

public class Demo02 {
    public static void main(String[] args) {
        // 并发，多线程操作统一资源
        Ticket2 ticket = new Ticket2();

        // Lambda表达式
        new Thread(()->{ for (int i = 0; i < 60; i++) ticket.saleTicket(); },"张三").start();
        new Thread(()->{ for (int i = 0; i < 60; i++) ticket.saleTicket(); },"李四").start();
        new Thread(()->{ for (int i = 0; i < 60; i++) ticket.saleTicket(); },"王五").start();
    }
}
class Ticket2{
    private int number = 50;
    Lock lock = new ReentrantLock();

    public void saleTicket(){
        lock.lock(); // 加锁
        try{
            if (number>0){
                System.out.println(Thread.currentThread().getName()+"卖出了第"+(number--)+"张票");
            }
        }finally {
            lock.unlock(); // 解锁
        }
    }
}

结果：

张三卖出了第50张票
张三卖出了第49张票
张三卖出了第48张票
张三卖出了第47张票
张三卖出了第46张票
......(此处省略)
张三卖出了第5张票
张三卖出了第4张票
张三卖出了第3张票
张三卖出了第2张票
张三卖出了第1张票
生产者消费者问题

线程之间交替操作num，当num==0时，num加一，当num>0时，num减一
① 使用synchronized进行线程同步：

public class Demo03 {
    public static void main(String[] args) {
        Num num = new Num();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    num.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    num.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
    }
}
class Num{
    private int num = 0;
    // +1：当num==0时，加一
    public synchronized void increment() throws InterruptedException {
        if (num!=0){
            this.wait(); // 等待
        }
        num++;
        System.out.println(Thread.currentThread().getName()+"-->"+num);
        this.notifyAll(); // 唤醒，通知其他线程+1完毕
    }
    // -1：当num>0时，减一
    public synchronized void decrement() throws InterruptedException {
        if (num==0){
            this.wait(); // 等待
        }
        num--;
        System.out.println(Thread.currentThread().getName()+"-->"+num);
        this.notifyAll(); // 唤醒，通知其他线程-1完毕
    }
}

结果：

A-->1
B-->0
A-->1
B-->0
A-->1
B-->0
A-->1
B-->0
A-->1
B-->0
A-->1
B-->0
A-->1
B-->0
A-->1
B-->0
A-->1
B-->0
A-->1
B-->0

当有线程超过两个时，可能会出现虚假唤醒的情况，所以判断语句用while循环，避免虚假唤醒

public class Demo04 {
    public static void main(String[] args) {
        Num2 num = new Num2();
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    num.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    num.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    num.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    num.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}
class Num2{
    private int num = 0;
    // +1：当num==0时，加一
    public synchronized void increment() throws InterruptedException {
        while (num!=0){  // 使用while循环，避免虚假唤醒
            this.wait(); // 等待
        }
        num++;
        System.out.println(Thread.currentThread().getName()+"-->"+num);
        this.notifyAll(); // 唤醒，通知其他线程+1完毕
    }
    // -1：当num>0时，减一
    public synchronized void decrement() throws InterruptedException {
        while (num==0){  // 使用while循环，避免虚假唤醒
            this.wait(); // 等待
        }
        num--;
        System.out.println(Thread.currentThread().getName()+"-->"+num);
        this.notifyAll(); // 唤醒，通知其他线程-1完毕
    }
}

结果：

A-->1
B-->0
A-->1
B-->0
A-->1
B-->0
A-->1
B-->0
A-->1
B-->0
C-->1
D-->0
C-->1
D-->0
C-->1
D-->0
C-->1
D-->0
C-->1
D-->0

② 使用Lock进行线程同步：
Condition：同步监视器

public class Demo05 {
    public static void main(String[] args) {
        Num3 num = new Num3();
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    num.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    num.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    num.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    num.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}
class Num3{
    private int num = 0;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    // +1：当num==0时，加一
    public void increment() throws InterruptedException {
        lock.lock();
        try {
            while (num!=0){
                condition.await(); // 等待 相当于synchronized中的wait()
            }
            num++;
            System.out.println(Thread.currentThread().getName()+"-->"+num);
            condition.signalAll(); // 唤醒，通知其他线程+1完毕 相当于synchronized中的notifyAll()
        }finally {
            lock.unlock();
        }
    }
    // -1：当num>0时，减一
    public void decrement() throws InterruptedException {
        lock.lock();
        try {
            while (num==0){
                condition.await(); // 等待 相当于synchronized中的wait()
            }
            num--;
            System.out.println(Thread.currentThread().getName()+"-->"+num);
            condition.signalAll(); // 唤醒，通知其他线程-1完毕 相当于synchronized中的notifyAll()
        }finally {
            lock.unlock();
        }
    }
}

结果：

A-->1
B-->0
A-->1
B-->0
A-->1
B-->0
A-->1
B-->0
C-->1
B-->0
C-->1
D-->0
C-->1
D-->0
C-->1
D-->0
C-->1
D-->0
A-->1
D-->0

Condition 实现精准通知唤醒：

// A执行完执行B，B执行完执行C，C执行完执行A
public class Demo06 {
    public static void main(String[] args) {
        Num4 num = new Num4();
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                num.printA();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                num.printB();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                num.printC();
            }
        },"C").start();
    }
}
class Num4{
    private int num = 1;
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
    public void printA(){
        lock.lock();
        try {
            while (num!=1){
                condition1.await(); //等待
            }
            num = 2;
            System.out.println(Thread.currentThread().getName()+"-->"+"AAA");
            condition2.signal(); // 唤醒B
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void printB(){
        lock.lock();
        try {
            while (num!=2){
                condition2.await(); //等待
            }
            num = 3;
            System.out.println(Thread.currentThread().getName()+"-->"+"BBB");
            condition3.signal(); // 唤醒C
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void printC(){
        lock.lock();
        try {
            while (num!=3){
                condition3.await(); //等待
            }
            num = 1;
            System.out.println(Thread.currentThread().getName()+"-->"+"CCC");
            condition1.signal(); // 唤醒A
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

结果：

A-->AAA
B-->BBB
C-->CCC
A-->AAA
B-->BBB
C-->CCC
A-->AAA
B-->BBB
C-->CCC
A-->AAA
B-->BBB
C-->CCC
A-->AAA
B-->BBB
C-->CCC

Lock用法跟synchronized差不多，但能够显现精准唤醒
流水伊旧
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
Synchronized与lock锁区别
xc_blog
09-02 1万+
1、synchronized是java关键字，他是jvm层面； lock是接口（相应的实现比如ReentrantLock)； 2、synchronized无法获取到锁的状态， lock可以获取到锁的状态； 3、synchronized是自动锁，如果代码执行完毕或发生异常， 他会自动释放锁的资源， lock手动锁，需要人工进行调用unlock方法进行释放锁的资源， 一般都是放在finally； 如果不释放会发生死锁； 4、synchronized如果线程a获取到锁的资源，发生阻塞，线程b会一直等待， 而
synchronized和ReentrantLock的5个区别！
磊哥聊Java
04-27 1万+
作者 | 磊哥来源 | Java面试真题解析（ID：aimianshi666）转载请联系授权（微信ID：GG_Stone）在 Java 中，常用的锁有两种：synchronized（内置锁）和 ReentrantLock（可重入锁），二者的功效都是相同得，但又有很多不同点，所以我们今天就来聊聊。区别1：用法不同synchronized 可用来修饰普通方法、静态方法和代码块...
锁和同步的区别
学亮编程手记
02-08 1500
● 请说明一下锁和同步的区别。 考察点：锁 参考回答： 用法上的不同： synchronized既可以加在方法上，也可以加载特定代码块上，而lock需要显示地指定起始位置和终止位置。 synchronized是托管给JVM执行的，lock的锁定是通过代码实现的，它有比synchronized更精确的线程语义。 性能上的不同： lock接口的实现类ReentrantLock，不仅具有和synchro...
详解synchronized与Lock的区别与使用
热门推荐
brickworkers的博客
03-22 21万+
引言： 昨天在学习别人分享的面试经验时，看到Lock的使用。想起自己在上次面试也遇到了synchronized与Lock的区别与使用。于是，我整理了两者的区别和使用情况，同时，对synchronized的使用过程一些常见问题的总结，最后是参照源码和说明文档，对Lock的使用写了几个简单的Demo。请大家批评指正。 技术点： 1、线程与进程： 在开始之前先把进程与线程进行区分一下，一个程序最...
Synchronized 和 Lock 的区别和使用场景
01-20
本文将深入探讨两种主要的锁机制：`synchronized`关键字和`Lock`接口，以及它们各自的特点、应用场景和使用方式。 一、Synchronized `synchronized`是Java中的一个内置关键字，用于提供线程安全。它的主要作用是...
简单了解synchronized和lock的区别
08-25
了解synchronized和lock的区别 synchronized是Java语言...在Java中，synchronized和lock都是用于实现线程同步的机制，但它们有不同的实现机制和性能特点。在选择使用哪种机制时，需要考虑到具体的应用场景和性能要求。
Java编程synchronized与lock的区别【推荐】
08-29
synchronized 和 Lock 是 Java 编程中两种常用的同步机制，用于实现线程安全的访问。两者都可以实现同步访问，但是它们有着不同的设计理念和使用场景。 synchronized 的缺陷 synchronized 是 Java 语言内置的...
Java synchronized关键字和Lock接口实现原理
08-25
Java 中的 synchronized 关键字和 Lock 接口是两种常用的线程同步机制，它们都可以用来解决并发问题。下面我们将详细介绍 synchronized 关键字和 Lock 接口的实现原理。 synchronized 关键字 synchronized 关键字...
线程同步Synchronized，监视器monitor和锁lock的关系3---马克-to-win java视频
06-10
线程同步Synchronized，监视器monitor和锁lock的关系2---马克-to-win java视频
java中的lock和synchronized
caoliangbo的博客
03-21 192
1、ReentrantLock 拥有Synchronized相同的并发性和内存语义，此外还多了 锁投票，定时锁等候和中断锁等候 线程A和B都要获取对象O的锁定，假设A获取了对象O锁，B将等待A释放对O的锁定， 如果使用 synchronized ，如果A不释放，B将一直等下去，不能被中断 如果 使用ReentrantLock，如果A不释放，可以使B在等待了足够长...
线程同步（互斥锁与信号量的作用与区别）
tietao的专栏
03-19 4万+
“信号量用在多线程多任务同步的，一个线程完成了某一个动作就通过信号量告诉别的线程，别的线程再进行某些动作（大家都在semtake的时候，就阻塞在 哪里）。而互斥锁是用在多线程多任务互斥的，一个线程占用了某一个资源，那么别的线程就无法访问，直到这个线程unlock，其他的线程才开始可以利用这 个资源。比如对全局变量的访问，有时要加锁，操作完了，在解锁。有的时候锁和信号量会同时使用的” 也就是说，信
java线程、线程池，类、对象锁 java线程通信，线程的状态 wait/notify
emmmsuperdan的博客
03-23 5865
同步：发送一个指令，需要等待返回结果，才能发出下一个指令，需要等待； 异步：发送一个指令，不需要等待，即可直接发出下一个指令； 一般情况下，都采用异步，效率更高；但是比如说银行系统，必须采用同步，这样才能保证数据的共享和安全性； synchronize关键字： 每个 synchronized 方法都必须获得调用该方法的类实例的锁（或者类锁）方能执行，否则所属线程阻塞；直到synchr...
深入浅出的理解线程同步和同步锁
weixin_52234647的博客
03-23 337
多线程使用共享资源出现的线程安全问题 线程安全是什么： 当多个线程访问某个方法时，不管你通过怎样的调用方式或者说这些线程如何交替的执行，我们在主程序中不需要去做任何的同步，这个类的结果行为都是我们设想的正确行为，那么我们就可以说这个类是线程安全的。 以下是一个不符合线程安全定义的代码 Tickets类的代码 package com.lk.syn0322; public class Tickets { int tickets=100; } Users类的代码 package com.lk.syn032
Lock与Synchronized区别
weixin_41010294的博客
03-16 6146
先说结论,后面详解 synchronized是关键字,Lock是接口; synchronized是隐式的加锁,lock是显式的加锁; synchronized可以作用于方法上,lock只能作用于方法块; synchronized底层采用的是objectMonitor,lock采用的AQS; synchronized是阻塞式加锁,lock是非阻塞式加锁支持可中断式加锁,支持超时时间的加锁; synchronized在进行加锁解锁时,只有一个同步队列和一个等待队列, lock有一个同步队
synchronized和Lock有什么区别
不羁朔风的博客
11-09 1452
java语言中提供了两种锁机制来实现对某个共享资源的同步:synchronized和Lock.其中synchronized使用Object对象本身的notify,wait和notifyAll来实现线程之间的调度.而Lock可以使用Condition进程线程之间的调度 ①用法不同 synchronized可以加在方法上,也可以加在特定的代码块中,括号中表示需要锁的对象 Lock需要显式地指定起...
Java线程同步的解决方案——synchronized与Lock
Hopefully Sky的博客
03-19 5034
要说明线程同步问题首先要说明Java线程的两个特性，可见性和有序性。多个线程之间是不能直接传递数据交互的，它们之间的交互只能通过共享变量来实现。例如，假设在多个线程之间共享了Count类的一个对象，Count类有一个私有域num和一个公有方法count(),count()方法对num进行加1操作。这个对象是被创建在主内存(堆内存)中，每个线程都有自己的工作内存(线程栈)，工作内存存储了主内存Cou
java synchronized对象锁与类锁的区别、同步代码块与同步方法的区别
Top5软件工程硕士，先后在京东、字节从事多年Java后端开发、实时和离线大数据开发
05-19 1万+
终于搞明白synchronized的作用了，献上一篇，如下： java的内置锁：每个java对象都可以用做一个实现同步的锁，这些锁成为内置锁。线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。 获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法。 java内置锁是一个互斥锁，这就是意味着最多只有一个线程能够获得该锁，当线程A尝试去获得线程B持有的内
Synchronized Lock 锁 同步
qq_30436011的博客
04-25 3133
如果锁的是类对象的话，尽管new多个实例对象，但他们仍然是属于同一个类依然会被锁住，即线程之间保证同步关系。 字符串作为锁对象的参考 一、synchronized的性质 1、可重入性 官方解释：指的是同一线程的外层函数获得锁之后，内层函数可以直接再次获得该锁； 通俗解释：获得一次锁之后，如果调用其它同步方法，不需要重新获取锁，可以直接使用； 在方法1中调用方法2，两个方法都是同步方法，在获取方法1的锁之后，是可以直接调用方法2，而不需要重新获取锁，这就是可重入性，可重入性是线程范围，可以...
java线程同步synchronized
最新发布
07-27
除了使用synchronized关键字外，还可以使用Lock接口的实现类，如ReentrantLock来实现线程同步。相比于synchronized关键字，Lock提供了更灵活的控制和更多的功能。 需要注意的是，在使用synchronized关键字时要注意...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值