lock和synchronized对比

已于 2022-12-21 17:41:08 修改
阅读量191 收藏
点赞数
分类专栏： java锁 java基础 文章标签： 算法 java 开发语言
于 2022-03-04 11:08:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45401910/article/details/123269408
版权

黑马程序员

三个层面

不同点

  • 语法层面
    • synchronized 是关键字，源码在 jvm 中，用 c++ 语言实现
    • Lock 是接口，源码由 jdk 提供，用 java 语言实现
    • 使用 synchronized 时，退出同步代码块锁会自动释放，而使用 Lock 时，需要手动调用 unlock 方法释放锁
  • 功能层面
    • 二者均属于悲观锁、都具备基本的互斥、同步、锁重入功能
    • Lock 提供了许多 synchronized 不具备的功能，例如获取等待状态、公平锁、可打断、可超时、多条件变量
    • Lock 有适合不同场景的实现，如 ReentrantLock， ReentrantReadWriteLock
  • 性能层面
    • 在没有竞争时，synchronized 做了很多优化，如偏向锁、轻量级锁，性能不赖
    • 在竞争激烈时，Lock 的实现通常会提供更好的性能

公平锁

  • 公平锁的公平体现
    • 已经处在阻塞队列中的线程（不考虑超时）始终都是公平的，先进先出
    • 公平锁是指未处于阻塞队列中的线程来争抢锁，如果队列不为空，则老实到队尾等待
    • 非公平锁是指未处于阻塞队列中的线程来争抢锁，与队列头唤醒的线程去竞争，谁抢到算谁的
  • 公平锁会降低吞吐量，一般不用

条件变量

  • ReentrantLock 中的条件变量功能类似于普通 synchronized 的 wait，notify，用在当线程获得锁后，发现条件不满足时，临时等待的链表结构
  • 与 synchronized 的等待集合不同之处在于，ReentrantLock 中的条件变量可以有多个，可以实现更精细的等待、唤醒控制

简单的使用

  • 使用lock锁实现线程安全
/*使用lock锁的方式实现多线程安全*/

class Test02{
    public static void main(String[] args) {
        System.out.println("使用了非公平锁");
        Ticket2 ticket = new Ticket2();
        new Thread(()->{
            for (int i = 0; i < 50; i++) {
                ticket.sale();
            }
        }).start();
    }
}

class Ticket2{
    private int ticket = 40;

    Lock lock = new ReentrantLock();

    public void sale(){
        try{
            lock.lock();
            if (ticket>0){
                System.out.println("卖出了"+ticket+"号票。剩余"+--ticket+"张票..。");
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

lock中的condiction可以指定某一个线程的执行，condition的await方法会释放锁。condition内部维护了一个 等待队列，所有调用condition.await方法的线程会加入到等待队列中，并且线程状态转换为等待状态。如果该线程能够从await()方法返回的话一定是该线程获取了与condition相关联的lock。>具体原理参考推荐文章

  • 使用synchronized实现线程安全
package com.dongmu.test;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Test01 {
    public static void main(String[] args) {
        /*获得CPU的核数*/
//        System.out.println(Runtime.getRuntime().availableProcessors());
//        System.out.println(5>>2);
//
        Ticket ticket = new Ticket();
        new Thread(()->{
            for (int i = 0; i < 50; i++) {
                ticket.sale();
            }
        }).start();
        new Thread(()->{
            for (int i = 0; i < 50; i++) {
                ticket.sale();
            }
        }).start();
        new Thread(()->{
            for (int i = 0; i < 50; i++) {
                ticket.sale();
            }
        }).start();

    }
}

class Ticket{
    private int ticket = 40;

    public synchronized void sale(){
        if (ticket>0){
            System.out.println("卖出了"+ticket+"号票。剩余"+--ticket+"张票。");
        }
    }
}

//能够保证打印的顺序未ABC
class Data3{
    private int num = 1;
    Lock lock = new ReentrantLock();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();
    public void A(){
        lock.lock();

        try {
            while (num!=1){
                condition1.await();
            }
            num = 2;
            System.out.println("AAAA");
            condition2.signal();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void B(){
        lock.lock();

        try {
            while (num!=2){
                condition2.await();
            }
            num = 3;
            System.out.println("BBBB");
            condition3.signal();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void C(){
        lock.lock();

        try {
            if (num!=3){
                condition3.await();
            }
            num = 1;
            System.out.println("CCCC");
            condition1.signal();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

lock的读写锁

package com.dongmu.test;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Test005 {
    public static void main(String[] args) {

        MyCacheLock cache = new MyCacheLock();

        for (int i = 0; i < 15; i++) {
            final int k = i+1;
            new Thread(()->{
                cache.put(k);
            }).start();
        }

        for (int i = 0; i < 15; i++) {
            final int k = i+1;
            new Thread(()->{
                cache.get(k);
            }).start();
        }

    }
}

class MyCache{
    private Map<Integer,String> map = new HashMap<>();

    public void put(int k){
        System.out.println("写入了一个元素"+k);
        map.put(k,"value");
        System.out.println("写入"+k+"完成");
    }

    public String get(Integer k){
        System.out.println("读取下标为"+k+"的元素。");
        String  s = map.get(k);
        System.out.println("读取下标是"+k+"的元素完成");
        return s;
    }
}

class MyCacheLock{
    private Map<Integer,String> map = new HashMap<>();

    ReadWriteLock lock = new ReentrantReadWriteLock();

    public void put(int k){
        lock.writeLock().lock();
        try {
            System.out.println("写入了一个元素"+k);
            map.put(k,"value");
            System.out.println("写入"+k+"完成");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.writeLock().unlock();
        }
    }

    public String get(Integer k){
        String s = null;
        lock.readLock().lock();

        try {
            System.out.println("读取下标为"+k+"的元素。");
            s = map.get(k);
            System.out.println("读取下标是"+k+"的元素完成");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.readLock().unlock();
        }
        return s;
    }
}

锁
使用CAS实现锁，底层使用的是Unsafe类，能够保证原子性操作

package com.dongmu.test;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

/**
 * cas实现乐观锁
 */
public class Test014 {
    public static void main(String[] args) {
        myLock lock = new myLock();


        new Thread(()->{


            try {
                lock.lock();
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unLock();
            }
        },"t1").start();

        new Thread(()->{
            try {
                lock.lock();
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unLock();
            }
        },"t2").start();
    }

}
//锁的实现
class myLock{
    public volatile AtomicReference<Thread> atomicReference = new AtomicReference<>();


    public void lock(){
        Thread thread = Thread.currentThread();

        System.out.println("lock-->"+thread.getName());
        while (!atomicReference.compareAndSet(null,thread)){

        }
    }

    public void unLock(){
        Thread thread = Thread.currentThread();

        atomicReference.compareAndSet(thread,null);

        System.out.println("unLock-->"+thread.getName());
    }

}

CAS解决ABA问题：（带版本号的原子操作），可以通过循环实现乐观锁

package com.dongmu.test;

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicStampedReference;

public class Test012 {
    public static void main(String[] args) {
        AtomicStampedReference atomicStampedReference = new AtomicStampedReference<>(1,1);

        new Thread(()->{
            atomicStampedReference.compareAndSet(1,2,
                    atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println("值"+atomicStampedReference.getReference());
            System.out.println("版本号"+atomicStampedReference.getStamp());

            atomicStampedReference.compareAndSet(2,1,
                    atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println("值"+atomicStampedReference.getReference());
            System.out.println("版本号"+atomicStampedReference.getStamp());
        }).start();



        new Thread(()->{
            atomicStampedReference.compareAndSet(1,2,
                    1,2);

            System.out.println("版本号"+atomicStampedReference.getStamp());
            System.out.println("值"+atomicStampedReference.getReference());
        }).start();

    }


}
北海冥鱼未眠
关注
专栏目录
lock锁，lock锁和synchronized的对比
11-19
lock锁，lock锁和synchronized的对比 # Lock锁 JDK5.0后Java提供了一种更加强大的线程同步机制。一种显式定义同步锁对象来实现锁，提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问...
【java面试题】lock和synchronized有什么区别？
黑马程序员官方博客
01-12 319
学习目标： 掌握 lock 与 synchronized 的区别 理解 ReentrantLock 的公平、非公平锁 理解 ReentrantLock 中的条件变量 lock 与 synchronized 的区别有三个层面 学习内容： 1.不同点 语法层面 synchronized 是关键字，源码在 jvm 中，用 c++ 语言实现 Lock 是接口，源码由 jdk 提供，用 java 语言实现 使用 synchronized 时，退出同步代码块锁会自动释放，而使用 Lock 时，需要手动调
lock和synchronized 对比
weixin_30677617的博客
07-21 261
1、特色：reentainLock 可以维持公平性、响应中断、超时机制 2、性能：并发不严重sync更优，高并发reentainLock好。 3、底层实现：sync和lock 有同步队列、也有等待队列，sync是基于 object 的wait/notify,lock 是基于condition的await/sigal，底层是locksupport.park/unpark。 4、synchron...
synchronized和Lock（ReentrantLock）及二者区别
最新发布
m0_61160520的博客
08-19 893
synchronized 更适合简单的同步需求，代码更简洁。Lock 适用于更复杂的同步需求，提供了更多的控制选项。
Lock和Synchronized的对比和实现
felix
08-05 238
Lock 拥有锁获取与释放的可操作性、可中断的获取锁以及超时获取锁 Lock lock = new ReentrantLock(); lock.lock(); try { // .. } finally { lock.unlock(); } 注意：在finally块中释放锁，目的是保证在获取到锁之后，最终能够被释放。不要将获取锁的过程写在try块中，因为如果在获取锁（自定义锁的实现）时发生了异常，异常抛出的同时，会提前进行unlock导致IllegalMonitorSt
JAVA面试题分享十七：synchronized和lock的区别，哪个更好？怎么选择？
之乎者也·的博客
11-24 1044
synchronized是关键字,Lock是接口// lock接口的方法synchronized是隐式的加锁,lock是显式的加锁// synchronized 作用于方法上时,是看不到有锁的释放的// lock 作用于代码块, 经常是 try lock finally unlock// 一起使用, 是有主动去加锁和解锁的synchronized可以作用于方法上,lock只能作用于方法块// synchronized作用于静态方法和普通方法的区别是?
synchronized和Lock
qq_51417143的博客
04-01 965
而轻量级锁是在多个线程竞争同一个锁时才会触发，当一个线程尝试获取锁失败时，会自动将锁升级为轻量级锁。其中，写锁和悲观读锁的使用方式类似于读写锁，而乐观读锁是一种不加锁的读取方式，它返回一个"邮戳（stamp）"，表示当前共享数据的版本号，在读取共享数据时需要使用这个邮戳进行验证，以确保数据的一致性。在Synchronized锁升级之前，每个Synchronized锁都是一个重量级锁，它包含了一个互斥量和一个条件变量，当多个线程竞争同一个锁时，会导致不必要的线程上下文切换和内存开销，从而影响程序的性能。
Java Lock与synchronized对比分析及ReentrantLock实例
"本文详细解析了Java Lock接口的实现原理及实例，对比了Lock与synchronized的区别，探讨了synchronized的局限性和Lock的优势。" 在Java并发编程中，Lock接口是Java.util.concurrent.locks包下的一个重要组件，它...
Java多线程Lock与synchronized对比分析
在Java多线程编程中，Lock接口提供了比`synchronized`关键字更为灵活的锁机制。Lock接口定义在`java.util.concurrent.locks`包中，其核心功能是允许程序员更精确地控制线程的同步。在使用Lock时，需要注意的一个关键...
Java Lock与synchronized对比分析及自定义Lock实现
"这篇文档详细解析了Java中的Lock锁机制，并与synchronized进行了对比，强调了Lock的灵活性和可控制性。通过一个示例代码展示了ReentrantLock的使用，包括lock()、unlock()以及interruptibly获取锁的方式。此外，还...
synchronized和lock对比
04-24
下面是 `synchronized` 和 `Lock` 的一些对比: 1. 使用方法不同：`synchronized` 关键字是 Java 的内置关键字，可以直接使用；而 `Lock` 是 Java 的一个类，需要通过实例化来使用。 2. 加锁方式不同：`...
Synchronized和Lock你选哪一个
个人站点：javatv.net
09-24 1919
Lock是什么 在之前的文章synchronized底层实现说到synchronized是属于JVM层面的锁，而且它只是一个关键字，是不能查看Java源码的，因此我们可以把它当做隐式锁。 有了 synchronized 为什么还要 Lock？ Lock又是做什么的呢？我们知道synchronized在1.6之前把它叫做重量锁，这时还没有偏向锁和轻量锁级别的优化，因此Doug Lea觉得很不爽，于是就自己开发了一套锁，也就是我们熟知的JUC（java.util.concurrent ）包的作者，我们可以叫他并
synchronized与Lock使用哪个
Wengzhengcun的博客
02-21 283
只有当synchronized无法满足需求时，才需要使用Lock，否则，一律使用synchronized。 使用Lock的场景：可定时的、可轮询的、可中断的锁获取操作，公平队列（synchronized只实现了非公平锁），非块结构的锁。 内置锁与ReentrantLock相比还有另一个优点：在线程转储（使用jstack）中能给出在哪些调用帧中获得了哪些锁，并能检测和识别发生死锁的线程。JVM并...
说一下synchronized 和 Lock 的比较？
weixin_41980692的博客
04-27 180
1.Lock 是接口，而 synchronized 是 Java 中的关键字，synchronized 是内置的语言实现； 2.synchronized 在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而 Lock 在发生异常时，如果没有主动通过 unLock()去释放锁，则很可能造成死锁现象，因此使用 Lock 时需要在 finally 块中释放锁； 3.Lock 可以让等待锁的...
synchronized 和 Lock 的比较
西瓜游侠的博客
05-27 545
synchronized 和 Lock 的区别： Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现。 synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生。而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁。 Lock可以让等待锁的线程响应中断，而synchronized却不行。使用synchronized时，等待的线程会一直等
面经-Lock与synchronized比较
LYly_B的博客
08-24 265
语法层面 synchronized是关键字，源码在jvm中，用c++语言实现。 Lock是接口，源码由jdk提供，用Java语言实现。 使用synchronized时，退出同步代码块，锁会自动释放。 使用Lock时，需要手动调用unlock方法释放锁。 功能层面 二者均属于悲观锁，都具备互斥(一个线程成功，其他线程阻塞)，同步(一个线程运行时发现需要其他线程的结果，则等待其他线程返回结果后才继续...
Java并发编程大揭秘：synchronized和Lock谁更胜一筹？
孤芳不自赏
04-25 484
这篇文章你值得一阅！讲技术我觉得应该让外行也能看明白，而不是一堆专业术语堆砌，像在读天书一般，到最后感觉云里雾里。
Lock与Synchronized的区别
riemann_的博客
07-18 1215
两者区别 1、首先synchronized是java内置关键字，在jvm层面，Lock是个java类； 2、synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁； 3、synchronized会自动释放锁(a 线程执行完同步代码会释放锁 ；b 线程执行过程中发生异常会释放锁)，Lock需在finally中手工释放锁（unlock()方法释放锁），否则容易造成线程死锁； 4...
synchronized和lock比较浅析
缠中说禅的博客
03-01 251
synchronized是基于jvm底层实现的数据同步，lock是基于Java编写，主要通过硬件依赖CPU指令实现数据同步。下面一一介绍 一、synchronized的实现方案 　　1.synchronized能够把任何一个非null对象当成锁，实现由两种方式： 　　a.当synchronized作用于非静态方法时，锁住的是当前对象的事例，当synchronized作用于静态方法时，锁住的是
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

北海冥鱼未眠

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值