说一下synchronized与Lock的区别与使用

Java中synchronized与Lock的区别与使用 当我们谈论Java多线程编程时,线程同步是一个避免资源竞争和保证线程安全的关键概念。在Java中,主要有两种机制来实现线程同步:synchronized关键字和Lock接口。这篇博客将详细介绍这两种同步机制的区别和使用方法,并通过示例来加深理解。 阅读详情

点击上方“Github爱好者社区”,选择星标

回复“资料”,获取小编整理的一份资料

3d75cf40c391fe1f7a5cd0ff2238474a.png

来源:https://blog.youkuaiyun.com/u012403290/

引言:

昨天在学习别人分享的面试经验时,看到Lock的使用。想起自己在上次面试也遇到了synchronized与Lock的区别与使用。

于是,我整理了两者的区别和使用情况,同时,对synchronized的使用过程一些常见问题的总结,最后是参照源码和说明文档,对Lock的使用写了几个简单的Demo。请大家批评指正。

技术点:

1、线程与进程:

在开始之前先把进程与线程进行区分一下,一个程序最少需要一个进程,而一个进程最少需要一个线程。关系是线程–>进程–>程序的大致组成结构。所以线程是程序执行流的最小单位,而进程是系统进行资源分配和调度的一个独立单位。以下我们所有讨论的都是建立在线程基础之上。

2、Thread的几个重要方法:

我们先了解一下Thread的几个重要方法。

  • start()方法,调用该方法开始执行该线程;

  • stop()方法,调用该方法强制结束该线程执行;

  • join方法,调用该方法等待该线程结束。

  • sleep()方法,调用该方法该线程进入等待。

  • run()方法,调用该方法直接执行线程的run()方法,但是线程调用start()方法时也会运行run()方法,区别就是一个是由线程调度运行run()方法,一个是直接调用了线程中的run()方法!!

看到这里,可能有些人就会问啦,那wait()和notify()呢?要注意,其实wait()与notify()方法是Object的方法,不是Thread的方法!!同时,wait()与notify()会配合使用,分别表示线程挂起和线程恢复。

这里还有一个很常见的问题,顺带提一下:wait()与sleep()的区别,简单来说wait()会释放对象锁而sleep()不会释放对象锁。这些问题有很多的资料,不再赘述。

3、线程状态:

0434c61c7f528563b85f9f336028ba85.png

线程总共有5大状态,通过上面第二个知识点的介绍,理解起来就简单了。

  • 新建状态:新建线程对象,并没有调用start()方法之前

  • 就绪状态:调用start()方法之后线程就进入就绪状态,但是并不是说只要调用start()方法线程就马上变为当前线程,在变为当前线程之前都是为就绪状态。值得一提的是,线程在睡眠和挂起中恢复的时候也会进入就绪状态哦。

  • 运行状态:线程被设置为当前线程,开始执行run()方法。就是线程进入运行状态

  • 阻塞状态:线程被暂停,比如说调用sleep()方法后线程就进入阻塞状态

  • 死亡状态:线程执行结束

4、锁类型

  • 可重入锁:在执行对象中所有同步方法不用再次获得锁

  • 可中断锁:在等待获取锁过程中可中断

  • 公平锁:按等待获取锁的线程的等待时间进行获取,等待时间长的具有优先获取锁权利

  • 读写锁:对资源读取和写入的时候拆分为2部分处理,读的时候可以多线程一起读,写的时候必须同步地写

synchronized与Lock的区别

1、我把两者的区别分类到了一个表中,方便大家对比:

050e736dba7ce2bef055517e852ba10f.png

或许,看到这里还对LOCK所知甚少,那么接下来,我们进入LOCK的深入学习。

Lock详细介绍与Demo

以下是Lock接口的源码,笔者修剪之后的结果:

public interface Lock {

    /**
     * Acquires the lock.
     */
    void lock();

    /**
     * Acquires the lock unless the current thread is
     * {@linkplain Thread#interrupt interrupted}.
     */
    void lockInterruptibly() throws InterruptedException;

    /**
     * Acquires the lock only if it is free at the time of invocation.
     */
    boolean tryLock();

    /**
     * Acquires the lock if it is free within the given waiting time and the
     * current thread has not been {@linkplain Thread#interrupt interrupted}.
     */
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

    /**
     * Releases the lock.
     */
    void unlock();

}

从Lock接口中我们可以看到主要有个方法,这些方法的功能从注释中可以看出:

  • lock():获取锁,如果锁被暂用则一直等待

  • unlock():释放锁

  • tryLock(): 注意返回类型是boolean,如果获取锁的时候锁被占用就返回false,否则返回true

  • tryLock(long time, TimeUnit unit):比起tryLock()就是给了一个时间期限,保证等待参数时间

  • lockInterruptibly():用该锁的获得方式,如果线程在获取锁的阶段进入了等待,那么可以中断此线程,先去做别的事

通过 以上的解释,大致可以解释在上个部分中“锁类型(lockInterruptibly())”,“锁状态(tryLock())”等问题,还有就是前面子所获取的过程我所写的“大致就是可以尝试获得锁,线程可以不会一直等待”用了“可以”的原因。

下面是Lock一般使用的例子,注意ReentrantLock是Lock接口的实现。

lock():
package com.brickworkers;

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

public class LockTest {
    private Lock lock = new ReentrantLock();

    //需要参与同步的方法
    private void method(Thread thread){
        lock.lock();
        try {
            System.out.println("线程名"+thread.getName() + "获得了锁");
        }catch(Exception e){
            e.printStackTrace();
        } finally {
            System.out.println("线程名"+thread.getName() + "释放了锁");
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        LockTest lockTest = new LockTest();

        //线程1
        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                lockTest.method(Thread.currentThread());
            }
        }, "t1");

        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                lockTest.method(Thread.currentThread());
            }
        }, "t2");

        t1.start();
        t2.start();
    }
}
//执行情况:线程名t1获得了锁
//         线程名t1释放了锁
//         线程名t2获得了锁
//         线程名t2释放了锁
tryLock():
package com.brickworkers;

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

public class LockTest {
    private Lock lock = new ReentrantLock();

    //需要参与同步的方法
    private void method(Thread thread){
/*        lock.lock();
        try {
            System.out.println("线程名"+thread.getName() + "获得了锁");
        }catch(Exception e){
            e.printStackTrace();
        } finally {
            System.out.println("线程名"+thread.getName() + "释放了锁");
            lock.unlock();
        }*/


        if(lock.tryLock()){
            try {
                System.out.println("线程名"+thread.getName() + "获得了锁");
            }catch(Exception e){
                e.printStackTrace();
            } finally {
                System.out.println("线程名"+thread.getName() + "释放了锁");
                lock.unlock();
            }
        }else{
            System.out.println("我是"+Thread.currentThread().getName()+"有人占着锁,我就不要啦");
        }
    }

    public static void main(String[] args) {
        LockTest lockTest = new LockTest();

        //线程1
        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                lockTest.method(Thread.currentThread());
            }
        }, "t1");

        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                lockTest.method(Thread.currentThread());
            }
        }, "t2");

        t1.start();
        t2.start();
    }
}

//执行结果: 线程名t2获得了锁
//         我是t1有人占着锁,我就不要啦
//         线程名t2释放了锁

看到这里相信大家也都会使用如何使用Lock了吧,关于tryLock(long time, TimeUnit unit)和lockInterruptibly()不再赘述。前者主要存在一个等待时间,在测试代码中写入一个等待时间,后者主要是等待中断,会抛出一个中断异常,常用度不高,喜欢探究可以自己深入研究。

前面比较重提到“公平锁”,在这里可以提一下ReentrantLock对于平衡锁的定义,在源码中有这么两段:

/**
     * Sync object for non-fair locks
     */
    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;

        /**
         * Performs lock.  Try immediate barge, backing up to normal
         * acquire on failure.
         */
        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }

    /**
     * Sync object for fair locks
     */
    static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;

        final void lock() {
            acquire(1);
        }

        /**
         * Fair version of tryAcquire.  Don't grant access unless
         * recursive call or no waiters or is first.
         */
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }

从以上源码可以看出在Lock中可以自己控制锁是否公平,而且,默认的是非公平锁,以下是ReentrantLock的构造函数:

public ReentrantLock() {
        sync = new NonfairSync();//默认非公平锁
    }

尾记录:

笔者水平一般,不过此博客在引言中的目的已全部达到。这只是笔者在学习过程中的总结与概括,如存在不正确的,欢迎大家批评指出。

补充

1、两种锁的底层实现方式:

synchronized:我们知道java是用字节码指令来控制程序(这里不包括热点代码编译成机器码)。在字节指令中,存在有synchronized所包含的代码块,那么会形成2段流程的执行。

0ae698bfb0bd51035548e0472453e43c.png

我们点击查看SyncDemo.java的源码SyncDemo.class,可以看到如下:

b95ced6e02d6967d1a5800d73952aa42.png

如上就是这段代码段字节码指令,没你想的那么难吧。言归正传,我们可以清晰段看到,其实synchronized映射成字节码指令就是增加来两个指令:monitorenter和monitorexit。当一条线程进行执行的遇到monitorenter指令的时候,它会去尝试获得锁,如果获得锁那么锁计数+1(为什么会加一呢,因为它是一个可重入锁,所以需要用这个锁计数判断锁的情况),如果没有获得锁,那么阻塞。当它遇到monitorexit的时候,锁计数器-1,当计数器为0,那么就释放锁。

那么有的朋友看到这里就疑惑了,那图上有2个monitorexit呀?马上回答这个问题:上面我以前写的文章也有表述过,synchronized锁释放有两种机制,一种就是执行完释放;另外一种就是发送异常,虚拟机释放。图中第二个monitorexit就是发生异常时执行的流程,这就是我开头说的“会有2个流程存在“。而且,从图中我们也可以看到在第13行,有一个goto指令,也就是说如果正常运行结束会跳转到19行执行。

这下,你对synchronized是不是了解的很清晰了呢。接下来我们再聊一聊Lock。

Lock:Lock实现和synchronized不一样,后者是一种悲观锁,它胆子很小,它很怕有人和它抢吃的,所以它每次吃东西前都把自己关起来。而Lock呢底层其实是CAS乐观锁的体现,它无所谓,别人抢了它吃的,它重新去拿吃的就好啦,所以它很乐观。具体底层怎么实现,博主不在细述,有机会的话,我会对concurrent包下面的机制好好和大家说说,如果面试问起,你就说底层主要靠volatile和CAS操作实现的。

现在,才是我真正想在这篇博文后面加的,我要说的是:尽可能去使用synchronized而不要去使用LOCK

什么概念呢?我和大家打个比方:你叫jdk,你生了一个孩子叫synchronized,后来呢,你领养了一个孩子叫LOCK。起初,LOCK刚来到新家的时候,它很乖,很懂事,各个方面都表现的比synchronized好。你很开心,但是你内心深处又有一点淡淡的忧伤,你不希望你自己亲生的孩子竟然还不如一个领养的孩子乖巧。这个时候,你对亲生的孩子教育更加深刻了,你想证明,你的亲生孩子synchronized并不会比领养的孩子LOCK差。(博主只是打个比方)

那如何教育呢?

在jdk1.6~jdk1.7的时候,也就是synchronized16、7岁的时候,你作为爸爸,你给他优化了,具体优化在哪里呢:

1、线程自旋和适应性自旋

我们知道,java’线程其实是映射在内核之上的,线程的挂起和恢复会极大的影响开销。并且jdk官方人员发现,很多线程在等待锁的时候,在很短的一段时间就获得了锁,所以它们在线程等待的时候,并不需要把线程挂起,而是让他无目的的循环,一般设置10次。这样就避免了线程切换的开销,极大的提升了性能。

而适应性自旋,是赋予了自旋一种学习能力,它并不固定自旋10次一下。他可以根据它前面线程的自旋情况,从而调整它的自旋,甚至是不经过自旋而直接挂起。

2、锁消除

什么叫锁消除呢?就是把不必要的同步在编译阶段进行移除。

那么有的小伙伴又迷糊了,我自己写的代码我会不知道这里要不要加锁?我加了锁就是表示这边会有同步呀?

并不是这样,这里所说的锁消除并不一定指代是你写的代码的锁消除,我打一个比方:

在jdk1.5以前,我们的String字符串拼接操作其实底层是StringBuffer来实现的(这个大家可以用我前面介绍的方法,写一个简单的demo,然后查看class文件中的字节码指令就清楚了),而在jdk1.5之后,那么是用StringBuilder来拼接的。我们考虑前面的情况,比如如下代码:

String str1="qwe";
String str2="asd";
String str3=str1+str2;

底层实现会变成这样:

StringBuffer sb = new StringBuffer();
sb.append("qwe");
sb.append("asd");

我们知道,StringBuffer是一个线程安全的类,也就是说两个append方法都会同步,通过指针逃逸分析(就是变量不会外泄),我们发现在这段代码并不存在线程安全问题,这个时候就会把这个同步锁消除。

3、锁粗化

在用synchronized的时候,我们都讲究为了避免大开销,尽量同步代码块要小。那么为什么还要加粗呢?

我们继续以上面的字符串拼接为例,我们知道在这一段代码中,每一个append都需要同步一次,那么我可以把锁粗化到第一个append和最后一个append(这里不要去纠结前面的锁消除,我只是打个比方)

4、轻量级锁

5、偏向锁

关于最后这两种,我希望留个有缘的读者自己去查找,我不希望我把一件事情描述的那么详细,自己动手得到才是你自己的,博主可以告诉你的是,最后两种并不难。。加油吧,各位。

好啦,今天的分享就到这儿啦,我们下次见啦~



GitHub原创推荐•  尼玛,Github上最邪恶的开源项目了!未满18或者女孩子勿进哦~•  GitHub标星4K+,前字节跳动工程师开源的刷题笔记...•  GitHub上这个仿京东电商项目强势开源,前端,后台,数据库等统统都有!•  GitHub 开发者自制火星车,教程全面开源!网友:这才是大佬!关注「Github爱好者社区」加星标,每天带你逛Github好玩的项目
告别零散脚本:用Playwright+Pytest+Yaml+Allure搭建可维护的UI自动化项目 UI自动化测试是软件质量保障的关键环节,其核心在于模拟用户操作,对Web应用界面进行功能验证。传统的脚本堆砌方式常因代码耦合度高、维护成本大而难以为继。工程化解决方案通过分离关注点,将测试逻辑、数据和配置解耦,从而显著提升项目的可读性、可维护性和可扩展性。其技术价值在于构建可持续运行的自动化资产,而非一次性脚本。典型的应用场景包括Web应用的回归测试、兼容性测试及CI/CD流水线中的质量门禁。本文以Playwright、Pytest、Yaml和Allure为核心技术栈,详细阐述了如何从项目架构、页面对象模型 阅读详情

相关推荐

汽车电缆选型实战:基于ISO 19642-3~12的7类电缆电压/材料/场景对照表

本文详细解析了基于ISO 19642-3~12标准的7类汽车电缆选型实战,涵盖电压等级、导体材料和场景应用的对照表。通过全参数速查表和典型选型陷阱分析,帮助工程师快速掌握从低压信号线到高压动力电缆的选型逻辑,提升新能源汽车与智能驾驶技术的安全性和可靠性。

weixin_29043895的博客 366

synchronized-锁总结

在 JDK1.6 之前,只有传统的锁机制(重量级锁),因此给开发者留下了synchronized关键字相比于其他同步机制性能不好的印象。在 JDK1.6 引入了两种新型的锁机制:偏向锁和轻量级锁,它们的引入是为了解决在没有多线程竞争或基本没有竞争的场景下因使用传统锁机制带来的性能开销问题。

weixin_37607613的博客 1072

SAC安装与相关库文件(.so)的安装

摘要 SAC: Seismic Analysis Code 是用于地震信号处理的一套软件。 本文将介绍SAC的安装,以及安装时遇到的一些问题。主要是一些动态库(lib**.so)找不到的问题。 本文的环境 64位的 Ubuntu 16.04 64位的系统是安装出现问题的主要原因 1. SAC获取与安装 SAC 的安装,只需要解压,然后修改环境变量即可!!!不需要任何编译!!! 1.1. SAC 获取与解压 SAC软件获取地址:http://ds.iris.edu/ds/nodes/dmc/forms/s.

WangCY的博客 4336

【死磕Java并发】-----深入分析synchronized的实现原理

记得刚刚开始学习Java的时候,一遇到多线程情况就是synchronized,相对于当时的我们来说synchronized是这么的神奇而又强大,那个时候我们赋予它一个名字“同步”,也成为了我们解决多线程情况的百试不爽的良药。但是,随着我们学习的进行我们知道synchronized是一个重量级锁,相对于Lock,它会显得那么笨重,以至于我们认为它不是那么的高效而慢慢摒弃它。 诚然,随着Javs SE

chenssy 的技术博客 4万+

JLINK/SWD/STLINK下载选项区别

摘要: 本文对比了JLINK/SWD/STLINK的6种下载模式:Normal(硬件复位)、Hot plug(无复位)、Under reset(持续复位后连接)、Software reset(软件复位)、Hardware reset(全复位)和Core reset(内核复位)。重点分析了各模式的操作逻辑、适用场景及注意事项,其中Under reset模式是解决SWD禁用/程序异常的首选方案。通过对比表归纳了复位范围、NRST操作等核心差异,并给出场景选择建议:排查连接问题优先选Under reset,常规调

亚洲程序员盟主得博客 398

thinkphp6/8 - 实现评论区发表评论、回复评论功能数据库表设计与整个逻辑思路过程分析,tp5 评论盖楼等功能(附带源码稍加改造即可使用)

tp5评论区数据库表设计,tp5发表回复评论功能设计,thinkphp5如何做评论功能,tp5 php评论区实现发表回复删除评论,tp5评论区盖楼源码及数据表设计思路,thinkphp评论功能详细教程,thinkphp实现评论与回复功能,thinkphp实现文章评论和回复评论功能,tp5实现评论回复功能,thinkphp如何实现评论区,tp5网站PC移动端h5怎么做评论区发表留言及回复功能,thinkphp实现评论区插件,thinkphp评论区相互发表回复功能详细教程,thinkphp有没有评论区的组件插件

✅ 精选推荐文章 3160

谈谈对Synchronized关键字,类锁,方法锁,重入锁的理解

先了解相关的锁知识: java的内置锁:每个java对象都可以用做一个实现同步的锁,这些锁成为内置锁。线程进入同步代码块或方法的时候会自动获得该锁,在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法。 java内置锁是一个互斥锁,这就是意味着最多只有一个线程能够获得该锁,当线程A尝试去获得线程B持有的内置锁时,线程A必须等待或者阻塞,知道线程B释放这...

suncat的博客 2307

基于STM32L4XX、HAL库的 ATGM336H GPS定位模块驱动程序设计

/ 转换为km/h。// 定位状态: 0=无效, 1=GPS定位, 2=差分定位。// GPS解析数据。支持GPS/BeiDou/GLONASS/Galileo/QZSS多系统联合定位。// 回调函数(需要在HAL_UART_RxCpltCallback中调用)// 地面速度(km/h)// 海拔高度(m)

zhusl6688的博客 794

72面试常问:对并发熟悉吗?说一下synchronized与Lock的区别与使用

引言: 昨天在学习别人分享的面试经验时,看到Lock的使用。想起自己在上次面试也遇到了synchronized与Lock的区别与使用。 于是,我整理了两者的区别和使用情况,同时,对synchronized的使用过程一些常见问题的总结,最后是参照源码和说明文档,对Lock的使用写了几个简单的Demo。请大家批评指正。 技术点: 1、线程与进程: 在开始之前先把进程与线程进行区分一下,一个程序最少需要一个进程,而一个进程最少需要一个线程。关系是线程–>进程–>程序的大致组成结构。...

AI乔治 236

告别 DEFINE VIEW:CDS View Entity 迁移全景实战(报表迁移 + ADT 向导 + 避坑清单)

CDS迁移的关键要点与策略 CDS DDIC-based View已被标记为废弃,迁移到CDS View Entity成为必要。迁移面临的主要挑战包括激活成本、命名约束和依赖风险。ABAP 7.57及以上版本必须优先处理,否则将积累技术债务。 迁移方式主要有两种: 报表路线:适合渐进式迁移的On-Premise项目 ADT向导:适合云环境批量迁移 关键注意事项: 必须提前检查SQL View依赖关系 金额/数量字段需要显式引用单位/货币字段 建议按使用场景分批迁移 最佳实践是结合报表进行系统盘点,再通过AD

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 209

基于Simulink的光伏-储能-柴油机混合微网仿真

摘要:本文基于Simulink平台构建光伏-储能-柴油机混合微网仿真模型,实现可再生能源与备用电源的协同控制。通过光伏优先、储能调节、柴油机兜底的规则控制策略,在24小时仿真中验证了系统在晴天、阴天和夜间三种典型工况下的运行性能。模型采用PVArray模块模拟光伏发电,Simscape电气库构建储能系统,自定义MATLAB函数实现柴油机启停逻辑和能量管理。仿真结果显示系统功率平衡误差<5%,储能SOC维持在20%-80%,柴油机日均运行时间<4小时,满足设计指标。文章详细说明了建模步骤、参数设置

xiaoheshang_123的博客 70

72. 对并发熟悉吗?说一下synchronized与Lock的区别与使用

对并发熟悉吗?说一下synchronized与Lock的区别与使用

优快云全栈领域优秀博主,阿里云博客专家,工信部权威认证物联网技术开发工程师,曾30分钟高分通过C语言二级,两天手撸代码完成EasyX飞机大战,靠接软件私活一个月换苹果电脑 600

基于 YOLOv26 的陶瓷产品缺陷检测系统:智能视觉质检方案

本文提出了一种基于YOLOv26深度学习模型的陶瓷产品智能缺陷检测系统。该系统针对陶瓷生产中的裂纹、气泡、釉面缺陷等8类常见质量问题,采用YOLOv26目标检测算法实现高精度自动化检测。系统架构包含数据采集、预处理、YOLOv26检测和后处理四个模块,具有多类别分类、实时推理和强鲁棒性等技术优势。文章详细介绍了数据预处理与增强方法,并提供了Python代码实现示例。该方案可显著提升陶瓷产品质量检测效率,替代传统人工检测方式,为陶瓷制造业提供智能化质检解决方案。

一键难忘的博客 794

【72期】面试官:对并发熟悉吗?说一下synchronized与Lock的区别与使用

程序员的成长之路互联网/程序员/技术/资料共享关注阅读本文大概需要 8 分钟。来自:https://blog.youkuaiyun.com/u012403290/引言:昨天在学习别人分享的面试经验...

良月柒 956

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

和catch的区别_面试官:对并发熟悉吗?说一下synchronized与Lock的区别与使用

引言:昨天在学习别人分享的面试经验时,看到Lock的使用。想起自己在上次面试也遇到了synchronized与Lock的区别与使用。于是,我整理了两者的区别和使用情况,同时,对synchronized的使用过程一些常见问题的总结,最后是参照源码和说明文档,对Lock的使用写了几个简单的Demo。请大家批评指正。技术点:1、线程与进程:在开始之前先把进程与线程进行区分一下,一个程序最少需要一个进程,...

weixin_33280675的博客 178

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

阿里面试官必问:对并发熟悉吗?说一下synchronized与Lock的区别与使用?

一个程序最少需要一个进程,而一个进程最少需要一个线程。关系是线程–>进程–>程序的大致组成结构。所以线程是程序执行流的最小单位,而进程是系统进行资源分配和调度的一个独立单位。线程类Thread的几个重要方法看到这里,可能有些人就会问啦,那wait()和notify()呢?要注意,其实wait()与notify()方法是Object的方法,不是Thread的方法!!同时,wait()与notify()会配合使用,分别表示线程挂起和线程恢复。这里还有一个很常见的问题,顺带提一下:wait()与sleep()的区

Java后端架构V 184

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

JUC个人学习笔记1---Lock锁

根据b站UP主狂神说JUC课程所写的个人学习笔记 视频地址:https://www.bilibili.com/video/BV1B7411L7tE?from=search&seid=14761503393031794075 传统Synchronized Lock接口 公平锁十分公平,可以先来后到 非公平锁,可以插队(默认) lock三部曲: 1. new ReentrantLock() 2.lock.lock()加锁 3.finally里解锁,业务代码放..

qq_42038061的博客 232

面试官问:说一下lock和Synchronized有什么区别?

对于这个问题,我们完全可以通过结构化的方式去回答,从功能、特性和性能三个方面来看。一、从功能角度来看,Lock 和 Synchronized 都是 Java 里面用来解决线程安全问题的工具。二、从特性来看Synchronized 是 Java 中的同步关键字,Lock 是 J.U.C 包里面提供的一个接口,这个接口有很多实现类,其中就包括 ReentrantLock 重入锁。其次,Synchronized 可以通过两种方式来控制锁的粒度,如下所示.....

weixin_54828627的博客 147

说一下synchronized 和 Lock 的比较?

1.Lock 是接口,而 synchronized 是 Java 中的关键字,synchronized 是内置的语言实现; 2.synchronized 在发生异常时,会自动释放线程占有的锁,因此不会导致死锁现象发生;而 Lock 在发生异常时,如果没有主动通过 unLock()去释放锁,则很可能造成死锁现象,因此使用 Lock 时需要在 finally 块中释放锁; 3.Lock 可以让等待锁的...

weixin_41980692的博客 239

详解synchronized与Lock的区别与使用

引言: 昨天在学习别人分享的面试经验时,看到Lock的使用。想起自己在上次面试也遇到了synchronized与Lock的区别与使用。于是,我整理了两者的区别和使用情况,同时,对synchronized的使用过程一些常见问题的总结,最后是参照源码和说明文档,对Lock的使用写了几个简单的Demo。请大家批评指正。 技术点: 1、线程与进程: 在开始之前先把进程与线程进行区分一下,一个程序最...

brickworkers的博客 21万+

synchronized 与 Lock 的区别

在Java多线程编程中,`synchronized`和`Lock`都扮演着确保线程安全访问共享资源的重要角色,但它们之间存在一些关键的区别。

✨ 欢迎来到【Seal ^_^ 的优快云博客】!✨ 8690

Java中synchronized与Lock的区别

***//***//***//***//***/}lock():获取锁,如果锁被暂用则一直等待unlock():释放锁tryLock(): 注意返回类型是boolean,如果获取锁的时候锁被占用就返回false,否则返回truetryLock(long time, TimeUnit unit):比起tryLock()就是给了一个时间期限,保证等待参数时间。

Machine Learning with Tutors 1万+

synchronized 和Lock区别

区别如下: 来源: lock是一个接口,而synchronized是java的一个关键字,synchronized是内置的语言实现; 异常是否释放锁: synchronized在发生异常时候会自动释放占有的锁,因此不会出现死锁;而lock发生异常时候,不会主动释放占有的锁,必须手动unlock来释放锁,可能引起死锁的发生。(所以最好将同步代码块用try catch包起来,finall...

洞玄之境的博客 12万+

synchronized与Lock的区别

1、lock是一个接口,而synchronized是java的一个关键字 2、异常是否释放锁: synchronized在发生异常时候会自动释放占有的锁,因此不会出现死锁;而lock发生异常时候,不会主动释放占有的锁,必须手动unlock来释放锁,可能引起死锁的发生。(所以最好将同步代码块用try catch包起来,finally中写入unlock,避免死锁的发生。) 3、是否知道获取锁 Lock...

huxuhang的博客 4730

synchronized和lock的区别和使用

synchronized和lock的区别和使用 1、线程与进程 一个程序至少需要一个线程,一个进程至少需要一个线程 线程->进程->程序 线程是程序执行流的最小单位,进程是系统进行资源分配和调度的一个独立单位。 2.Thread的几个重要方法 ①start()方法:开始执行该线程 ②stop()方法:强制结束该线程 ③join()方法 :等待该线程结束 ④sleep()方法:该线程进...

sqk_IT的博客 1952
上一篇: 35岁奥地利最帅总理辞职!超360万年薪加入硅谷当「码农」
下一篇: 一年暴增1600万程序员!GitHub 2021年度报告发布:中国755万开发者排全球第二
公众号:【GitHub爱好者社区】
博客等级 码龄6年 357粉丝 48原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值