面试高频:何时用多线程?多线程需要加锁吗?线程数多少最合理?

2025年Java高级工程师面试题精选:30道高频问题深度解析 在Java高级工程师的面试中,技术深度和广度是考察的重点。本文整理了30道高频面试题,涵盖Java基础、JVM、并发编程、集合框架、Spring框架等核心知识点,帮助你在面试中脱颖而出。 阅读详情

推荐阅读:

一、什么时候应该使用多线程?

今天看到一个问题,突然有感而发,想聊下这个话题。

不知道大家有没有想过这个问题,就是什么时候我该使用多线程呢?使用多线程就一定会提升系统性能吗?

1、其实是否应该使用多线程在很大程度上取决于应用程序的类型。

  • 计算密集型(如纯数学运算) 的, 并受CPU 功能的制约, 则只有多CPU(或者多个内核) 机器能够从更多的线程中受益, 单CPU下, 多线程不会带来任何性能上的提升, 反而有可能由于线程切换等额外开销而导致性能下降

  • IO密集型的,当我的应用必须等待缓慢的资源(如网络连接或者数据库连接上返回数据)时,那么多线程会让系统的CPU充分的利用起来,当一个线程阻塞挂起时,另一个线程可以继续使用CPU资源。

  • 其实,就是多线程不会增加CPU的处理能,而是能够更加充分地利用CPU资源。

由于同一进程的多个线程是共享同一片内存资源的,在带来方便的同时也必然会增加其复杂性,如何保证多线程访问数据的一致性问题等。而多线程属于编程中容易翻车的地方。并且多线程编程问题的测试定位也是比较难的。总体来说,好的多线程是写出来,将多线程问题寄希望于测试中发现, 无疑是极度不可靠的。SO,努力的学习吧。

Java API 与多线程息息相关的的几大关键字:volatile、synchronized、 wait、 notify. 理解了这几个关键字,就可以编写多线程的代码了。

二、什么时候需要加锁?

在多线程场合下,最重要的就是保障数据的一致性问题,而保障数据一致性问题,就需要借助于锁了。

其实我们在多线程的场景下应该搞清楚一个问题,就是到底什么需要保护?并不是所有的的数据都需要加锁保护,只有那些涉及到被多线程访问的共享的数据才需要加锁保护。

锁的本质其实就是确保在同一时刻,只有一个线程在访问共享数据,那么此时该共享数据就能得到有效的保护。

举例说明下,比如我们想构造一个多线程下安全的单向链表:

假如现在有两个线程在操作这个链表,一个写线程插入一个新元素7,另一个读线程遍历链表数据,如果不使用任何锁,那就有可能出现下面的执行顺序:

步骤写线程读线程
0修改链表元素2的next指针指向7这个元素… …
1… …遍历链表,到7的时候发现next 为null,遍历结束
2修改元素7的next 指针指向3… …

通过上面的例子我们可以明显看到在多线程下操作这个链表,有可能会导致读线程读到的数据不完整,只有从链表头部到元素7的位置的数据。由此可见,不加入任何保护措施的多线程保护,势必会导致数据的混乱。为了避免数据一致性问题,我们就需要将操作该队列的代码放入同步块内(锁的对象也就是这个链表实例),来确保同一时刻只有一个线程可以访问该链表。

如何加锁?

这里简单的说下,一般我们都是使用synchronized(如果没有特殊需求建议直接使用这个关键字,jdk新版本它真的很快),记住synchronized 锁的就是对象头。

简单的说下,主要有下面几种用法:

  • synchronized 放在方法上,锁的是当前synchronized 方法的对象实例

  • synchronized在static 方法上,锁的是synchronized 方法的class 类对象,注意这里class 其实也是一个对象。

  • synchronized(this)在代码块中,锁的是代码块括号内的对象,这里this指的就是调用这个方法的类实例对象

三、 多线程中易犯的错误

1、锁范围过大

共享资源访问完成后, 后续的代码没有放在synchronized同步代码块之外。 会导致当前线程长期无效的占用该锁, 而其它争用该锁的线程只能等待, 最终导致性能受到极大影响。

 public void test()
 {
 		synchronized(lock){
 		... ... //正在访问共享资源
 		... ... //做其它耗时操作,但这些耗时操作与共享资源无关
 	}
 }

面对上面这种写法,会导致此线程长期占有此锁,从而导致其他线程只能等待,下面来讨论下解决方法:

1)单CPU场景下,将不需要同步的耗时操作拿到同步块外面,有的情况可以提升性能,有的却不行。

  • CPU密集型的代码 ,不存在磁盘IO/网络IO等低CPU消耗的代码。 这种情况下, CPU 99%都在执行代码。 因此缩小同步块也不会带来任何性能上的提升, 同时缩小同步块也不会带来性能上的下降。

  • IO密集型的代码,在执行不消耗CPU的代码时,其实CPU属于空闲状态的。如果此时让CPU工作起来就可以带来整体上性能的提升。所以在这种情况下,就可以将不需要同步的耗时操作移到同步块外面了。

2)多CPU场景下,将耗时的CPU操作拿到同步块外面,总是可以提升性能的

  • CPU密集型的代码,不存在IO操作等不消耗CPU的代码片段。因为当前是多CPU,其他CPU也可能是空闲的。所以在缩小同步块的时候,也会让其他线程尽快的执行这段代码从而带来性能上的提升。

  • IO密集型的代码,因为当前PCU都是空闲的状态,所以将耗时的操作放在同步块外面,一定会带来整体上的性能提升。

当然,不管怎么样,缩小锁的同步范围对于系统来说都是百利而无一害的,因此上面的代码应该改为:

 public void test()
 {
 		synchronized(lock){
 		... ... //正在访问共享资源
 	}
 		... ... //做其它耗时操作,但这些耗时操作与共享资源无关
 }

综上所述,一个重点,就是只将访问共享资源的代码放在同步块内,保证快进快出。

2、死锁的问题

死锁要知道的:

  • 死锁,简单地说就是两个线程或多个线程在同时等待被对方持有的锁导致的,死锁会导致线程无法继续执行并被永久挂起。

  • 如果线程发生了死锁,那我们就能从线程堆栈中明显的看到”Found one Java-level deadlock“,并且线程栈还会给出死锁的分析结果。

  • 死锁这种问题如果发生在关键系统上就可能会导致系统瘫痪,如果想要快速恢复系统,临时唯一的方法就是保留线程栈先重启,然后再尽快的恢复。

  • 死锁这种问题有时候测试是很难被立即发现的,很多时候在测试时能否及时发现这类问题,就全看你的运气和你准备的测试用例了。

  • 避免死锁这类问题,唯一的办法就是改代码。但一个可靠的系统是设计出来的,而不是通过改BUG改出来的,当出现这种问题的时候就需要从系统设计角度去分析了。

  • 有人会认为死锁会导致CPU 100%,其实对也不对。 要看使用的什么类型的锁了,比如synchronized导致的死锁,那就不会导致CPU100%,只会挂起线程。但如果是自旋锁这种才可能会消耗CPU。

3、共用一把锁的问题

就是多个共享变量会共用一把锁,特别是在方法级别上使用synchronized,从而人为导致的锁竞争。

上例子,下面是新手容易犯的错误:

1 public class MyTest
2 {
3 Object shared;
4 synchronized void fun1() {...} //访问共享变量shared
5 synchronized void fun2() {...} //访问共享变量shared
6 synchronized void fun3() {...} //不访问共享变量shared
7 synchronized void fun4() {...} //不访问共享变量shared
8 synchronized void fun5() {...} //不访问共享变量shared
9 }

上面的代码每一个方法都被加了synchronized ,明显违背了保护什么锁什么的原则。

三、线程数我们一般设多少比较合理呢?

其实大家都知道,在大多数场合下多线程都是可以提高系统的性能和吞吐量,但一个系统到底多少个线程才是合理的?

总的来说,线程数量太多太少其实都不太好,多了会因为线程频繁切换导致开销增大,有时候反而降低了系统性能。少了又会导致CPU资源不能充分的利用起来,性能没有达到瓶颈。

所以,系统到底使用多少线程合适,是要看系统的线程是否能充分的利用了CPU。其实实际情况,是很多时候不消耗CPU,如:磁盘IO、网络IO等。

磁盘IO、网络IO相比CPU的速度,那简直是相当的慢的,在执行IO的这段时间里CPU其实是空闲的。如果这时其他线程能把这空闲的CPU利用上,就可以达到提示系统性能和吞吐的目的。

其实上面我们也提到过,也就是两种计算特性:

CPU密集型: 因为每个CPU都是高计算负载的情况,如果设置过多的线程反而会产生不必要的上下文切换。所以,一般线程我们会设置 CPU 核数 + 1就可以了,为啥要加1 呢,即使当计算(CPU)密集型的线程偶尔由于页缺失故障或者其他原因而暂停时,这个“额外”的线程也能确保 CPU 的时钟周期不会被浪费,其实就是个备份。

IO密集型:因为大量的IO操作,会导致CPU处于空闲状态,所以这时我们可以多设置些线程。 所以, 线程数 = CPU 核心数 * (1+ IO 耗时/CPU 耗时) 就可以了,希望能给你点启发。

C++多线程面试核心:从原子操作到线程池的实战解析 并发编程是现代软件开发的基石,它允许多个任务同时执行以提升系统吞吐量和响应速度。其核心原理在于对共享资源的安全访问与线程间的高效协作,这直接关系到程序的正确性与性能。在C++中,通过`std::thread`、`std::mutex`等标准库组件实现并发,其技术价值在于充分利用多核CPU的计算能力,构建高性能的后台服务、游戏服务器或实时系统。典型的应用场景包括实现线程安全的单例模式、设计生产者-消费者队列以解耦模块,以及构建线程池来避免频繁创建销毁线程的开销。本文聚焦于**双重检查锁定**和**虚假唤醒** 阅读详情

相关推荐

Java ConcurrentHashMap原理与面试高频考点解析

ConcurrentHashMap是Java并发编程中的核心数据结构,它通过分段锁或CAS+synchronized机制实现线程安全。在JDK7中采用分段锁设计,将哈希表分为多个段以减少锁竞争;JDK8则优化为更细粒度的桶锁,结合CAS无锁算法提升性能。这种并发容器广泛应用于电商秒杀、实时数据处理等高并发场景,其演进过程体现了Java从粗粒度锁到无锁化的技术发展路径。理解ConcurrentHashMap的实现原理,不仅有助于掌握Java并发编程精髓,也是面试中考察候选人并发能力的重要指标。JDK8的改进包

weixin_33978044的博客 299

何时用多线程?多线程需要加锁吗?线程数多少最合理?

爱生活,爱编码,微信搜一搜【架构技术专栏】关注这个喜欢分享的地方。 本文 架构技术专栏 已收录,有各种视频、资料以及技术文章。 一、什么时候应该使用多线程? 今天看到一个问题,突然有感而发,想聊下这个话题。 不知道大家有没有想过这个问题,就是什么时候我该使用多线程呢?使用多线程就一定会提升系统性能吗? 1、其实是否应该使用多线程在很大程度上取决于应用程序的类型。 计算密集型(如纯数学运算) 的, 并受CPU 功能的制约, 则只有多CPU(或者多个内核) 机器能够从更多的线程中受益, 单C.

架构技术专栏 2813

Java面试高频考点:ConcurrentHashMap与Stream API解析

在Java并发编程中,ConcurrentHashMap作为线程安全的哈希表实现,通过分段锁和CAS机制显著提升性能。其核心原理在于减小锁粒度,利用volatile保证可见性,并通过无锁化操作降低竞争开销。类似地,Java 8引入的Stream API通过中间操作与终止操作的分离实现惰性求值,这种设计既能提升数据处理效率,又能支持链式编程风格。这些技术广泛应用于高并发系统、大数据处理等场景,是Java开发者必须掌握的底层机制。理解ConcurrentHashMap的锁优化策略和Stream API的延迟执行

weixin_33994429的博客 443

QT多线程操作同一个变量

一.在不添加互斥锁的情况下,分别在两个线程对a变量进行累加。 1.计算量不是很大的话,最终的计算结果看似是满足预期结果的。 虽然代码顺序是先执行xianCheng_1的,但最终结果的输出顺序有可能是xianCheng_1先输出,也有可能先输出xianCheng_2的结果。 2.加大计算量,最终的计算结果就出现问题了。 出现这样的问题,主要是由于两个线程都是先从内存中取数,再执行累加,累加完之后,再把结果覆写回内存中的。 二.在添加互斥锁的情况下,分别在两个线程对a变量进行累加。 加上互斥锁后,最终的计算结果

exiagd的博客 3079

2024大厂面试必考:多线程并发编程核心原理与实战指南

并发编程是计算机科学的核心基础,旨在解决多任务同时执行时的资源协调与数据一致性问题。其核心原理围绕可见性、原子性与有序性三大挑战展开,根源在于现代计算机的多级缓存架构、线程切换及指令重排序。为解决这些问题,Java内存模型(JMM)定义了happens-before规则,并通过synchronized、volatile等关键字提供保障,其技术价值在于构建高吞吐、低延迟的稳健系统。在应用场景上,从Web服务器处理海量请求到分布式中间件协调,并发技术无处不在。本文聚焦大厂面试高频考点,深入剖析synchroni

weixin_33701294的博客 446

三代测序选型指南:PacBio HiFi vs Nanopore vs Illumina技术对比与适用场景

本文深入对比了三代测序技术PacBio HiFi、Nanopore与Illumina的核心参数、成本模型和应用场景,为生物信息学研究提供选型指南。通过实测数据和技术组合策略分析,帮助实验室根据研究需求选择最适合的测序方案,涵盖基因组组装、表观遗传学等关键应用领域。

fern8的博客 904

多线程的数量设定

最佳线程数目 = ((线程等待时间+线程CPU时间)/线程CPU时间 )* CPU数目 CPU核数为4核,一个任务线程cpu耗时为20ms,线程等待(网络IO、磁盘IO)耗时80ms,那最佳线程数目:( 80 + 20 )/20 * 4 = 20。也就是设置20个线程数最佳。 线程的等待时间越大,线程数就要设置越大 1、CPU密集型:操作内存处理的业务,一般线程数设置为:CPU核数 + 1 或者 ...

fall_hat的博客 2599

别再为跨页读写发愁了!STM32F407模拟I2C驱动24C256/512的避坑指南

本文详细解析了STM32F407模拟I2C驱动24C256/512的跨页写入问题,揭示了24C系列存储器'写满一页不会自动翻页'的关键机制,并提供了经过验证的分页写入算法和优化方案。通过GPIO时序优化、地址计算和错误处理等技巧,帮助开发者解决数据错乱、覆盖等常见问题,实现稳定可靠的EEPROM读写操作。

weixin_42631411的博客 379

多线程高并发场景下为什么需要锁

如果线程A执行完了x=x+1的操作,但还没有来得及将修改后的值写入内存中,此时线程B先执行了x=x-1的操作,那么最终x的值就是原始值,而不是应该的值。4.StampedLock:StampedLock是Java中提供的一种乐观锁,它采用了乐观锁和悲观锁相结合的方式实现同步,可以在保证线程安全的同时提高程序的并发性。虽然锁会引入一定的开销,但是在多线程高并发的情况下,使用锁可以避免线程之间的竞争,从而提高程序的性能和效率。在Java语言中,提供了多种类型的锁,每种锁都有其特定的应用场景和使用方式。

qq_41194023的博客 2790

手把手教你逆向分析某里系bx-ua参数(以225版本为例)

本文详细解析了某里系应用bx-ua参数的逆向工程实战方法,重点拆解其三层加密体系(二进制加密、字符替换和Base64编码)。通过工具链配置和实战案例,帮助开发者掌握逆向分析技巧,适用于合法合规的安全研究和加密技术评估场景。

weixin_33220360的博客 414

psasp和matlab,PSASP与Matlab/SimPowerSystems联合仿真接口方法研究

[1]李亚楼,吴中习.Matlab模型接入PSASP暂态稳定计算模块的方法[J].电网技术,2008,32(19):31-36.Li Yalou,Wu Zhongxi.An Approach to Interface Matlab Model with PSASP Transient Stability Module [J].Power System Technology,2008,32(19):...

weixin_39636245的博客 1083

为什么要使用多线程?创建多少个线程合适?什么是线程池?

多线程应用 多线程 1、什么是线程? 1.1、任务调度的基本概念 1.2、进程和线程的基本联系 1.3、多线程与多核的基本关系 2、为什么使用多线程? 2.1、并发场景的应用 2.1.1、I/O密集型(I/O bound) 2.1.1.1、单核型应用 2.1.2、CPU (计算)密集型程序((CPU-bound) 2.1.2.1、单核型 2.1.2.2、多核型(并行) ..

木牛的博客 2811

【Hyper-V】虚拟机网络配置全解析:从端口映射到固定IP实战

本文全面解析Hyper-V虚拟机网络配置,从理解虚拟交换机三种模式(外部、内部、专用)的底层逻辑入手,指导用户创建稳定的内部/NAT网络,并详细演示如何在Linux与Windows虚拟机中配置固定IP。文章进一步深入讲解端口映射原理与netsh命令实战,以及双网卡配置和PowerShell自动化脚本等高级技巧,帮助用户彻底解决虚拟机网络“失联”问题,实现灵活可控的网络环境。

weixin_29290947的博客 269

【面试:】Java高频面试题1(多线程)

高频面试题 文章目录高频面试题1.volatile1.1定义:1.2 特性:1.2.1 保证可见性:JMM(java内存模型)代码验证:1.2.2 不保证原子性:1.2.3 禁止指令重排:1.3你在哪个地方见过 volatile ?(单例模式) 1.volatile 1.1定义: volatile是java虚拟机提供的轻量级的同步机制 1.2 特性: 1.2.1 保证可见性: JMM(java内存模型) ​ JMM本身是一种抽象的概念并不真实存在,它描述的是一组规则或者是规范,通过这组规范定义了程序中的各个

qq_46096321的博客 1496

直播间人气协议算法:从批量操作到数据接口的自动化实现

本文深入解析直播间人气协议算法的实现原理与技术细节,涵盖批量账号管理、IP代理方案、用户行为模拟算法及平台数据接口调用策略。通过逆向工程分析通信协议,结合算法设计实现自动化流量提升,同时探讨风控规避与系统性能优化方案,为开发者提供合规的技术实践参考。

weixin_30505225的博客 520

手把手教你模拟登录豆瓣并爬取个人书影音数据:从Cookie解析到反爬攻防实战

在开始写代码之前,先明确我们需要的工具。:建议用3.10以上版本,方便使用一些新特性(如match语句)httpx:比requests更现代,支持HTTP/2,异步性能强,连接池复用好:解析HTML,语法简单,容错性强selenium:仅用于处理登录时的滑块验证(模拟真人)pandas:最终数据清洗和导出Excel/CSVretrying:自动重试机制,应对临时封禁:随机UA,降低特征lxml:作为BeautifulSoup的解析器,速度快为什么不只用requests?

2201_76125261的博客 579

Java高频场景题解析与实践

Java高频场景题涵盖了语言特性、集合框架、多线程、JVM、Spring框架等多个方面。掌握这些场景题不仅有助于面试准备,更能提升实际开发能力。建议读者:深入理解每个场景背后的原理动手实践代码示例思考不同解决方案的优缺点关注新技术对传统解决方案的影响通过不断学习和实践,开发者可以建立完整的知识体系,在面对各种Java开发场景时能够游刃有余。

2501_91715693的博客 1216

全能媒体工具深度测评(下篇一):AI图文生成+全能解压+图片去文字,一键搞定素材精修

解压50多种格式,文生图,图生图

cs821984831的博客 42

Java面试核心:HashMap、多线程与SpringBoot自动配置详解

Java集合框架中的HashMap是面试高频考点,其JDK1.8实现的数组+链表+红黑树结构在时间与空间效率间取得平衡。多线程编程中,线程池参数配置与volatile关键字的内存语义是并发控制的核心技术。SpringBoot通过@Conditional条件注解与spring.factories文件实现自动配置,大幅简化了框架集成工作。这些技术广泛应用于高并发系统设计、分布式缓存等场景,理解其底层原理对性能优化和问题排查至关重要。本文以互联网大厂真实面试题为切入点,深入解析Java核心技术要点。

weixin_34245082的博客 297

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

多线程面试3天突击:从背题到构建认知框架的实战路线

多线程是Java并发编程的核心基础,也是面试中考察候选人工程理解力的高频考点。从synchronized与ReentrantLock的取舍,到volatile的可见性边界,再到线程池参数与死锁排查,面试官真正关注的不是结论,而是候选人能否基于JMM、AQS等原理,用分层思维拆解问题。并发编程的价值在于它连接了操作系统、内存模型与业务系统,在秒杀、异步任务编排、接口聚合等典型场景中,线程池、锁和CAS的正确运用决定了系统的稳定性与吞吐量。本文以认知框架为主线,提供一套3天的复习路线,将高频知识点串联成可复用的

aofan9566的博客 461

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

Java最新面试题(全网最全、最细、附答案)

《2025-2026年Java后端面试全攻略》摘要:本文整理了2025-2026年大厂Java后端高频面试题,涵盖Java基础、集合、多线程、JVM、Spring全家桶、MySQL、Redis及分布式等核心内容。重点包括:JDK 21-23新特性(虚拟线程、记录类)、HashMap/ConcurrentHashMap优化、线程池配置、JVM调优(分代ZGC)、Spring自动配置原理,以及秒杀系统设计等实战场景题。特别强调虚拟线程应用和JDK新特性考察趋势,建议按模块分阶段学习背诵,并提供扩展学习链接。适合

likuoelie的博客 1999

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

Java多线程面试核心考点与实战解析

多线程编程是Java并发体系的核心技术,其核心在于解决共享资源访问的线程安全问题。从JMM内存模型到happens-before规则,从synchronized锁优化到CAS无锁编程,现代并发编程通过内存屏障、锁升级等机制保证可见性与有序性。在工程实践中,线程池参数调优、ConcurrentHashMap分段策略、CompletableFuture异步编排等技术大幅提升了系统吞吐量。针对高频面试场景,需要重点掌握线程生命周期、volatile原理、ThreadLocal内存泄漏等12个核心维度,并能够手写生

weixin_34184158的博客 373

Java面试高频考点:JVM原理与集合框架详解

Java作为主流编程语言,其核心机制JVM通过字节码和即时编译实现跨平台特性,内存模型中的堆栈结构和GC算法直接影响系统性能。集合框架中HashMap采用数组+链表+红黑树结构,其扩容机制和线程安全方案是工程实践的关键。面向对象特性如封装继承多态,需要结合防御性拷贝和设计模式等实际编码经验来理解。在多线程场景下,synchronized锁升级和volatile可见性机制保障线程安全,而JUC工具包提供更高效的并发解决方案。掌握这些基础原理和技术实践,能够有效应对Java开发中的性能优化和系统设计挑战。

weixin_33924770的博客 387

大厂高频面试题复习JAVA学习笔记-JUC多线程及高并发(下)

0 JUC基础概念wait/sleep的区别并发与并行的区别线程的六个状态JUC结构 ​编辑1 请谈谈你对volatile的理解JMM(java内存模型)可见性不保证原子性有序性​编辑指令重排双端检查机制DLC2 CAS你知道吗?3 原子类AtomicInteger的ABA问题谈谈?原子更新引用知道吗?原子引用4 我们知道ArrayList是线程不安全,请编码写一个不安全的案例并给出解决方案。list​编辑setmap参数传递​编辑5 公平锁/非公平锁/可重入锁/递归锁/自旋锁谈谈你的理解?

qq_51586702的博客 1488

互联网大厂面试奇遇记:严肃面试官VS搞笑水货程序员王大炮

某互联网大厂资深技术专家,严肃认真,技术功底深厚:王大炮,自称"三年Java开发经验",实际技术一知半解,擅长搞笑回答:Java高级开发工程师:技术面,三轮提问。

小智博客 602

Java多线程面试高频题全解析:从JMM原理到线程池实战排查

并发编程是Java后端开发的核心技能,多线程环境下如何保证数据一致性、原子性与可见性,是每一位开发者必须掌握的底层逻辑。Java内存模型(JMM)定义了主内存与工作内存的交互规则,而synchronized、volatile、CAS等机制则从不同层面解决了并发问题。理解这些原理,不仅有助于应对面试中的高频考点,更能指导工程实践。线程池作为资源管理的核心工具,其参数配置、任务执行流程和拒绝策略直接影响系统稳定性;ThreadLocal的合理使用与内存泄漏防范、死锁排查与jstack分析等实战技能,同样是衡量工

weixin_32612263的博客 350
上一篇: 三年渣本靠两个文档拿下了三个一线名企的offer:杭州阿里+北京京东+北京百度
下一篇: 火爆全网:SpringBoot+Vue+JPA后台管理系统源码分享(项目部署+前后端手册+运维)
「已注销」
博客等级 码龄6年 36粉丝 149原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值