Synchronized 和 ReentrantLock 区别

最新推荐文章于 2024-04-22 18:41:55 发布
最新推荐文章于 2024-04-22 18:41:55 发布
阅读量174 收藏
点赞数
文章标签： java lock synchronized
原文链接：https://www.cnblogs.com/newAndHui/p/12831089.html https://zhuanlan.zhihu.com/p/126085068
版权

代码

package com.auth.Sercurity.TreadDemo;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.locks.ReentrantLock;
import java.util.stream.Collectors;

/**
 * @author hujian
 * @version 1.0
 * @description: 线程模式售票
 * @date 2022/2/22 15:29
 */
public  class TicketDemo {

    protected static List<Integer> list=new ArrayList<>();

    static class  TicketThread extends Thread{
        private static Integer tickets=100;
        private static final ReentrantLock lock=new ReentrantLock();
        private  Object objectLock=new Object();
        @Override
        public void run(){
            while (tickets>0){
                selaTicketLock();
//                或者选择Synchornized方法
//                selaTicketSychronyzed();
            }
            System.out.println("==========");
            System.out.println(Thread.currentThread().getName()+"售票结束");
        }

        private void selaTicketLock() {
            try {
//                代码加锁
                lock.lock();
                if (tickets>0){
                    System.out.println(Thread.currentThread().getName() + "-" + "卖出最后第" + tickets + "张票");
                    list.add(tickets);
                    tickets--;
                }
            }catch (Exception e){
                System.out.println(e.getMessage());
            }finally {
//                必须手动解锁
                lock.unlock();
            }
        }


        /**
         * 如果是实例方法，那么默认的同步监听对象就是this，
         * 如果是静态方法，默认的同步监听对象是类的字节码对象;
         * 1.实例方法 private synchronized void sellTicketSyn(),默认的同步监听对象就是this,只能锁住同一个对象,在当前使用会出现重复售票;
         * 2.静态方法 private static synchronized void sellTicketSyn(),同步监听对象是类的字节码对象,相当于全局锁; 
         */
        private void selaTicketSychronyzed() {
            /**
             * 1.synchronized锁住的是括号里得对象，而不是代码
             * 2.常用的锁对象（this,字节码）
             *      a.当synchronized (TicketThread.class),程序正常执行，只有一份字节码，谁拥有字节码就有执行权
             *      b.当chnchronized(objectLock)或chnchronized(this),this代表当前对象，启动线程的时候看的实例了几次						TicketThread 类，如果
             *        TicketThread ticketThread = new TicketThread();
             *         Thread thread1=new Thread(ticketThread,"窗口1");
             *         Thread thread2=new Thread(ticketThread,"窗口2");
             *         那么只会有一个objectLock对象或者TicketThread对象。如果
             *          Thread  thread1= new TicketThread();
             *         Thread  thread2= new TicketThread();
             *         那么就会多个objectLock对象或者TicketThread对象，也会重复卖票
             *      c.synchronized（tickets），因为数量是变化的，所以当存在数量不相等时会同时进行。
             *
             */
            synchronized (this){
                if (tickets>0){
                    System.out.println(Thread.currentThread().getName() + "-" + "卖出最后第" + tickets + "张票");
                    list.add(tickets);
                    tickets--;
                }
            }
        }
    }


    public static void main(String[] args) {
        TicketThread ticketThread = new TicketThread();
        Thread thread1=new Thread(ticketThread,"窗口1");
        Thread thread2=new Thread(ticketThread,"窗口2");
        Thread thread3=new Thread(ticketThread,"窗口3");

//        Thread  thread1= new TicketThread();
//        Thread  thread2= new TicketThread();
//        Thread  thread3= new TicketThread();
//        thread1.setName("窗口1");
//        thread2.setName("窗口2");
//        thread3.setName("窗口3");
        System.out.println("开始售票");
        System.out.println("=================");
        thread1.start();
        thread2.start();
        thread3.start();
        // 提取出重复的票数，供自己参考
        List<Integer> result=new ArrayList<>();
        Map<Integer, Long> collect = list.stream().collect(Collectors.groupingBy(e -> e, Collectors.counting()));
        collect.forEach((a,b)->{
            if (b>1){
                result.add(a);
            }
        });
        System.out.println(result.toString());
        System.out.println(list.toString());
    }
}

特性

1.锁的对象
  1. synchorized锁的是对象，锁是保存在对象头里面的，根据对象头的数据来标识是否有线程获得锁和争抢锁。
  2. ReentrantLock锁的是线程，根据进入的线程和int类型的state标识锁的状态。
2.底层实现
  1. synchronized是JVM层面的锁，是Java的关键字，通过monitor的对象完成。对象只有在同步代码块或同步方法中才能调用wait/notify方法。synchronized的实现涉及锁的升级，具体为无锁，偏向锁，自旋锁，向OS申请重量级锁。
  2. ReentrantLock实现则是通过利用CAS(CompareAndSwap)自旋机制保证线程操作的原子性和volatile保证数据可见性以实现锁的功能。
3.是否可手动释放
  1. synchroized不需要用户自己去释放锁，Synchronized锁的代码执行完后系统会自动让线程释放对锁的占用；
  2. ReentrantLocak则需要用户手动加锁和释放锁，不手动使用unlock（）可能会导致死锁现象。
4.是否可绑定条件

synchronized不能绑定，ReentrantLock通过绑定Condition结合await（）/singal（）方法实现线程的精准唤醒，而不是像synchronized通过Object类wait（）/notify（）/notifyAll（）那样要么随即唤醒要么全部唤醒。

package com.auth.Sercurity.TreadDemo;

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

/**
 * @author hujian
 * @version 1.0
 * @description: ReentrantLock绑定条件
 *     依次打印 A/B/C
 * @date 2022/2/23 14:38
 */
public class ReentrantLockCondition {
    int number=1;
    private ReentrantLock lock=new ReentrantLock();
    private Condition condition1=lock.newCondition();
    private Condition condition2=lock.newCondition();
    private Condition condition3=lock.newCondition();

    void print1(){
        lock.lock();
        try {
            while (number!=1){
//                等待
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"---"+number);
            number=2;
//            唤醒
            condition2.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    void print2(){
        lock.lock();
        try {
            while (number!=2){
//                等待
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+"---"+number);
            number=3;
//            唤醒
            condition3.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    void print3(){
        lock.lock();
        try {
            while (number!=3){
//                等待
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+"---"+number);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

// 
    public static void main(String[] args) {
        ReentrantLockCondition reentrantLockCondition=new ReentrantLockCondition();
        new Thread(()-> reentrantLockCondition.print1(),"A:").start();
        new Thread(()->reentrantLockCondition.print2(),"B:").start();
        new Thread(()->reentrantLockCondition.print3(),"C:").start();
    }
}
5.是否公平

synchronized为非公平锁 ReentrantLock则即可以选公平锁也可以选非公平锁，通过构造方法new ReentrantLock时传入boolean值进行选择，为空默认false非公平锁，true为公平锁。

    private ReentrantLock lock=new ReentrantLock(true);
    private ReentrantLock lock=new ReentrantLock(false);
6是否可以中断
  1. synchronized是不可中断类型的锁，除非加锁的代码中出现异常或正常执行完成；
  2. ReentrantLock则可以中断，可通过trylock(long timeout,TimeUnit unit)设置超时方法或者将lockInterruptibly()放到代码块中，调用interrupt方法进行中断。
           try {
//                代码加锁
                lock.lock();
                lock.tryLock(2, TimeUnit.SECONDS);
                lock.lockInterruptibly();
                if (tickets>0){
                    System.out.println(Thread.currentThread().getName() + "-" + "卖出最后第" + tickets + "张票");
                    list.add(tickets);
                    tickets--;
                }
            }catch (Exception e){
                System.out.println(e.getMessage());
            }finally {
//                必须手动解锁
                lock.unlock();
            }
网瘾教父
关注
synchronized 和 ReentrantLock 的区别是什么
小小鱼儿小小林的博客
03-29 232
synchronized和ReentrantLock都是Java中用于实现线程同步的有效工具，但它们在锁的获取方式、公平性、灵活性和用法上存在一些关键区别。
谈谈synchronized 和 ReentrantLock 的区别？
CYK_byte的博客
09-26 862
synchronized和ReentrantLock都是Java中的可重入锁；
Synchronized和ReentrantLock区别
be_gin_ner的博客
08-25 308
Synchronized和ReentrantLock区别 相似点： 都是加锁方式同步，并且都是阻塞式的同步，即一个线程获取了对象锁，进入同步块，其他访问该同步块的线程必须阻塞在同步块的外面等待，而线程进行阻塞和唤醒的代价是比较高的， 功能区别： synchornized是Java语言的关键字，是原生语法层面的互斥，需要JVM实现，而ReentrantLock是JDK1.5以后提供的API层...
Synchronized和Reentrantlock的区别
qq_38845271的博客
08-09 242
Synchronized 是一个关键字, Reentrantlock 是一个类; Synchronized 会自动加锁释放锁, Reentrantlock 需要程序员手动加锁释放锁; Synchronized 是 JVM层面的锁, Reentrantlock 是API层面的锁; Synchronized 是非公平锁, Reentrantlock 可以选择公平锁或非公平锁; Synchronized 锁的是对象，锁信息保存在对象头中， Reentrantlock 是通过代码中 int类型的 state标识来判
ReentrantLock 到底锁定了哪个对象了？
qq_41282282的博客
09-17 2334
一个简单的ReentrantLock的例子, 情景是几个朋友吃饭, 可是美味的汤只有一锅, 勺子只有一个. 这样一来, 难免就会有你抢我争的情况了. 但是, 如果有更美味的其他食物, 当然可以先转头去找其他的了. synchronized是无法做到这点的. Lunch类, 包括勺子(ReentrantLock)和"舀"的动作, 当这帮朋友想要"舀"的时候, 就只能一个人动手, 其他人乖乖等着, 或者被叫去干其他事情 package concurrent.lunch; import java.util.con
Java 中的Lock锁对象(ReentrantLock/ReentrantReadWriteLock)详解
swadian2008的博客
08-29 3342
当有线程获取读锁时，如果当前没有线程持有写锁，则读锁将立即被获取，读锁计数器加一，表示当前有一个线程持有读锁。在 getValue() 方法中，线程会获取锁，返回共享变量 value 的值，最后释放锁。例如，如果一个线程在尝试获取锁的过程中遇到了饥饿现象（即一直获取不到锁），那么系统可能会采用类似于睡眠的方式，让该线程暂时让出 CPU 资源，等待一段时间后再次尝试获取锁。接着，它获取读锁，释放写锁，这样就实现了锁降级。这是因为写锁是独占锁，不能被多个线程同时持有，而读锁是共享锁，可以被多个线程同时持有。
ReentrantLock
最新发布
Adepth的博客
04-22 1334
这是标准库给我们提供的另一种锁，前面我们学到的一种是顾名思义，Reentrant:可重入的 但我们也知道，synchronized锁不也是可重入的嘛?那这个锁到底有什么其他的过人之处呢？
synchronized和ReentrantLock区别
03-28
synchronized和ReentrantLock都是Java中用于实现线程同步的机制，它们的主要区别如下： 1. 锁的获取方式： - synchronized是Java内置的关键字，可以直接在方法或代码块上使用。当线程进入synchronized代码块时，会...
synchronized和reentrantlock区别
04-14
Synchronized 和 ReentrantLock 都是实现并发控制的方式，它们的主要区别如下： 1. Synchronized 是关键字，用于同步代码块或方法，而 ReentrantLock 是一个类，需要手动创建和释放锁。 2. Synchronized 在发生...
ReentrantLock详解
热门推荐
weixin_56738054的博客
01-09 1万+
ReentrantLock使用，
ReentrantLock源码详解--条件锁
08-25
主要介绍了ReentrantLock源码之条件锁，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，下面我们来一起学习一下吧
Java并发编程之锁对象ReentrantLock和条件对象Condition
yzpbright的博客
03-03 1156
ReentrantLock被称为显示锁，synchronized被称为隐式锁。 public class ReentrantLock implements Lock, java.io.Serializable { } ReentrantLock实现了Lock接口。 用 ReentrantLock 保护代码块的基本结构如下： myLock.lock(); // a ReentrantLock o...
同步方法中的锁对象_ReentrantLock 中 锁和解锁的底层原理浅析
weixin_34640046的博客
01-14 443
关于 ReentrantLock 中锁 lock() 和解锁 unlock() 的底层原理浅析如下代码，当我们在使用 ReentrantLock 进行加锁和解锁时，底层到底是如何帮助我们进行控制的啦？ static Lock lock = new ReentrantLock(); public static void main(String[] args) { // 使用...
ReentrantLock锁的一种误用分析
hongweigg的专栏
09-28 2254
在网上看到一个兄弟写的关于ReentrantLock的文章，介绍得挺详细的，但是有个例子却讲得有点问题。看下面的代码： import java.util.concurrent.locks.ReentrantLock; public class ReentrantLockPractice3 { static ReentrantLock lock = new Reentr
Sychronized ReentrantLock 类锁 对象锁
weixin_37763484的博客
08-13 1000
如标题所描述，在一个demo里展示了这四种锁的区别。 类锁会造成类中的所有同步方法都被阻塞执行，对象锁能保证一个对象在多线程中的安全性。假设现在有一个order，金额是100元，oder中的方法E和E_1使用了类锁 order如下： package com.kafkaDemo.sychronized; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class
Java并发之同步 —— 锁对象与条件对象（ReentrantLock 、ReentrantReadWriteLock、Condition）
zl_momomo的博客
07-25 584
I.锁对象 有两种机制防止代码受并发访问的干扰。Java语言提供一个 synchronized 关键字达 到这一目的，并且 Java SE 5.0 引入了 ReentrantLock 类。 i.ReentrantLock 重入锁 private ReentrantLock lock = new ReentrantLock(); public void transfer(){ ...
ReentrantLock 锁详解
m0_37235955的博客
04-27 3429
ReentrantLock 支持公平锁和非公平锁，可重入锁 ReentrantLock的底层是通过 **AQS[链接]**实现。 一、BAT 大厂的面试题 **【1】**什么是可重入，什么是可重入锁? 它用来解决什么问题? 【2】ReentrantLock 的核心是 AQS，那么它怎么来实现的，继承吗? 说说其类内部结构关系。 【3】ReentrantLock 是如何实现公平锁的? 【4】ReentrantLock 是如何实现非公平锁的? 【5】ReentrantLock 默认实现的是公平还是非公平锁.
并发编程学习总结(五) ：java 显式锁ReentrantLock使用详解之条件对象(2)
远方和诗 的博客
06-13 8091
(1) ReentrantLock的条件对象 通常，线程进入临界区，却发现在某一条件满足之后才能执行，条件对象就是用来管理那些已经获得了锁，但是却不能做有用工作的线程。 一个锁对象可以有一个或多个相关的条件对象，我们可用lock.newCondition()方法获得一个条件对象。 ReentrantLock myLock = new ReentrantLock(); // 获得锁myLock
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值