欢迎光临
我们一直在努力

04、JAVAEE---多线程进阶、文件I/O、网络初识

多线程之八股文🙂


一、锁策略

加黄部分就是 synchronized锁 的性质

1、乐观锁 vs 悲观锁

  • 悲观锁:先锁后操作,适合高冲突场景

  • 乐观锁:先操作后检查,适合低冲突场景

2、重量级锁 vs 轻量级锁

重量级锁是“挂起等待”(让出CPU,省资源但慢),轻量级锁是“自旋”(占着CPU死等,费资源但快)

重量级锁 = 挂起等待,轻量级锁 = 自旋
两组概念讲的是同一件事,只是角度不同:一组强调开销,一组强调行为。


3、挂起等待锁 vs 自旋锁

挂起等待是“睡觉等”,不占CPU但响应慢;自旋是“站着等”,占CPU但响应快

4、公平锁 vs 非公平锁

公平锁 = 排队追女神,先来后到
非公平锁 = 半路截胡,谁抢到是谁的

公平锁严格按等待顺序获取锁(先来后到)

非公平锁允许插队(后请求的线程可能先获得锁)


5、可重入锁 vs 不可重入锁

可重入锁同一线程能反复拿锁,不可重入锁会自己锁自己

6、普通互斥锁 vs 读写锁

互斥锁读写都互斥,读写锁读不互斥、写才互斥


二、JVM 的优化机制

这三个概念是 JVM 对 synchronized 的优化机制,目的是在不影响正确性的前提下,减少锁带来的性能开销

锁升级

锁只能升级不能降级:无锁 → 偏向锁 → 轻量级锁 → 重量级锁

  • 锁升级:竞争越激烈,锁越重

  • 锁消除:单线程用的锁,直接去掉

  • 锁粗化:反复开关太费事,合并成一次

  • 三、CAS操作

    CAS 是 CPU 级别的原子操作,比较并交换,成功就改,失败就重试

    优点:

    不挂起线程(指让一个正在运行的线程主动或被动地放弃 CPU 使用权,进入“等待”状态)、

    快

    缺点:

    ABA 问题、自旋耗 CPU

    一个值从 A 变成 B 又变回 A,CAS 会认为没变过,解决方法是加版本号


    四、Runnable 与 Callable

    “Runnable 和 Callable 都是任务接口,主要区别有两点:

  • 返回值:Callable 有泛型返回值,Runnable 是 void;

  • 异常:Callable 可以抛出受检异常,Runnable 只能在内部处理。

  • FutureTask 是两者的桥梁,因为它既实现了 Runnable(可被 Thread 或线程池执行),又实现了 Future(可保存结果)

    使用时,把 Callable 包装进 FutureTask,交给线程执行,最后调用 futureTask.get() 获取结果

    五、synchronized 与 ReentrantLock

    • synchronized 是 JVM 层面的关键字,用法简单,自动加锁解锁,但只能非公平、死等

    • ReentrantLock 是 Java 类库提供的,需要手动 lock/unlock,优点是支持 tryLock(可以超时或立即返回),支持公平锁,还能用 Condition 实现多个等待队列(比如"生产者-消费者场景用两个 Condition 分别控制满和空")

    • ReentrantLock 不会自动释放锁,必须手动调用 unlock(),而 finally 能保证无论是否发生异常,锁都能被释放

    总结:两者都是可重入锁

    简单场景用 synchronized,需要公平锁或超时等待时用 ReentrantLock


    六、Semaphore

    Semaphore 是信号量,用于控制同时访问资源的线程数。它的 acquire() 在拿不到许可时会让线程阻塞(挂起),release() 用于归还许可并唤醒等待线程。两者与 ReentrantLock 的 lock()/unlock() 类似,都是基于 AQS 实现的。

    和 synchronized 不同的是,Semaphore 没有 JVM 层面的偏向锁、自旋锁优化,它是直接通过 AQS 进行阻塞唤醒。

    不过在实际开发中,大部分简单同步场景用 synchronized 就够了,代码简洁且 JVM 会自动优化。除非需要限流(比如数据库连接池控制并发数),才会用 Semaphore

    七、CountDownLatch

    "CountDownLatch 是 JUC 包下的同步工具,让一个或多个线程等待,直到一组操作完成。

    核心方法是 await() 和 countDown():

    • await():线程在这里挂起(阻塞),直到计数器归零

    • countDown():计数器减 1,归零时唤醒所有等待的线程

    常见用法有两个:

  • 主线程等待子任务:主线程 await(),每个子线程做完调用 countDown()

  • 多个线程同时启动:所有线程先 await(),由另一个线程一次性 countDown() 触发

  • 和 join() 的区别:join() 只能等一个线程死掉,CountDownLatch 可以等一组操作(不一定是线程结束,只要调了 countDown() 就行)

    八、Hashtable 和 ConcurrentHashMap

    Hashtable(铺垫痛点):

    Hashtable 是一把大锁锁整个 Map,用 synchronized 修饰方法,同一时间只有一个线程操作,性能很差

    ConcurrentHashMap 的并发优化:

  • 给每个链表都安排一把锁 —— 不同链表的操作互不影响,可以并发执行。JDK 1.7 是分段锁(16个 Segment,相当于 16 把锁),JDK 1.8 之后进一步细化为锁单个桶(链表头或红黑树根),并发度更高。

  • size 使用 CAS 进行更新 —— 不需要加锁就能原子更新计数器,减少锁竞争。

  • 扩容化整为零 —— 不是一次性迁移所有数据,而是把整个扩容任务拆分成多个小任务,每次迁移一部分,允许其他线程边读边写边帮忙扩容,避免卡顿。


  • 九、文件三面试题

    1、遍历目录(基础版)

    package javaee;

    import java.io.File;

    //基础版遍历目录
    public class Demo23 {
    public static void main(String[] args) {

    //绝对路径
    File dir = new File("E:/my-first-web");
    //先判断是不是目录
    if(!dir.isDirectory()){
    System.out.println("目录不存在或不是文件夹:" + dir.getAbsolutePath());
    return;
    }

    //1、当前目录下所有文件和目录的名字
    String[] names = dir.list();
    System.out.println("=====所有文件和目录名字=====");
    for(String name : names){
    System.out.println(name);
    }

    //2、当前目录下所有文件和目录的 File 对象
    File[] files = dir.listFiles();
    System.out.println("=====所有对象=====");
    for (File file : files){
    if(file.isFile()){
    System.out.println("[文件]" + file.getName());
    }
    if (file.isDirectory()){
    System.out.println("[目录]" + file.getName());
    }
    }
    }

    }

    这是一个基础版本的文件遍历,若想更装杯,可以使用递归来写😎


    2、复制文件

    package javaee;

    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.util.Scanner;

    public class Demo24 {

    public static void main(String[] args) throws IOException {
    Scanner scanner = new Scanner(System.in);

    System.out.print("请输入要复制的文件(绝对路径 OR 相对路径):");
    String sourcePath = scanner.next();
    //创建原文件对象
    File sourceFile = new File(sourcePath);
    if (!sourceFile.exists()) {
    System.out.println("文件不存在,请确认路径是否正确");
    return;
    }
    if (!sourceFile.isFile()) {
    System.out.println("文件不是普通文件,请确认路径是否正确");
    return;
    }

    System.out.print("请输入要复制的目标路径(绝对路径 OR 相对路径):");
    String destPath = scanner.next();
    //创建复制完成的文件对象
    File destFile = new File(destPath);
    if (destFile.exists()) {
    if (destFile.isDirectory()) {
    System.out.println("目标路径已经存在,并且是一个目录,请确认路径是否正确");
    return;
    }
    if (destFile.isFile()) {
    System.out.print("目标文件已经存在,是否要进行覆盖?(y/n):");
    String ans = scanner.next();
    if (ans.equals("y")) {
    System.out.println("开始覆盖复制…");
    } else {
    System.out.println("停止复制");
    return;
    }
    }
    }

    // ========== 真正的复制代码 ==========
    try (FileInputStream fis = new FileInputStream(sourceFile);
    FileOutputStream fos = new FileOutputStream(destFile)) {
    byte[] buffer = new byte[8192];
    int len;
    while ((len = fis.read(buffer)) != -1) {
    fos.write(buffer, 0, len);
    }
    }
    System.out.println("复制完成!目标文件位置:" + destFile.getAbsolutePath());
    }

    }


    3、复制整个目录

    package javaee;

    import java.io.*;
    import java.util.*;

    public class Demo25 {

    public static void main(String[] args) throws IOException {
    Scanner scanner = new Scanner(System.in);

    System.out.print("请输入要复制的源目录:");
    String srcPath = scanner.next();
    File srcDir = new File(srcPath);

    if (!srcDir.isDirectory()) {
    System.out.println("源目录不存在或不是文件夹");
    return;
    }

    System.out.print("请输入目标目录:");
    String destPath = scanner.next();
    File destDir = new File(destPath);

    // 调用复制目录的方法(遍历 + 复制)
    copyDirectory(srcDir, destDir);
    System.out.println("目录复制完成!");
    }

    // 复制目录(结合了遍历 + 复制)
    public static void copyDirectory(File srcDir, File destDir) throws IOException {
    // 1. 创建目标目录(遍历的第一步)
    if (!destDir.exists()) {
    destDir.mkdirs();
    }

    // 2. 遍历源目录(来自 Demo23 的思想)
    File[] children = srcDir.listFiles();
    if (children != null) {
    for (File child : children) {
    File destChild = new File(destDir, child.getName());

    if (child.isFile()) {
    // 3. 复制文件(来自 Demo24 的核心代码)
    copyFile(child, destChild);
    } else if (child.isDirectory()) {
    // 4. 遇到子目录,递归调用自己(继续遍历 + 复制)
    copyDirectory(child, destChild);
    }
    }
    }
    }

    // 复制单个文件(来自 Demo24 的核心代码)
    private static void copyFile(File src, File dest) throws IOException {
    try (FileInputStream fis = new FileInputStream(src);
    FileOutputStream fos = new FileOutputStream(dest)) {
    byte[] buffer = new byte[8192];
    int len;
    while ((len = fis.read(buffer)) != -1) {
    fos.write(buffer, 0, len);
    }
    }
    System.out.println("复制文件:" + src.getName());
    }
    }

    相当于前两者的结合


    十、网络基本盘

    1、OSI 七层 / TCP/IP 四层

    网络一般看 TCP/IP 四层模型:应用层、传输层、网络层、网络接口层。数据发送时从上往下封装(每层加报头),接收时从下往上分用(每层拆报头)

    2、Socket编程

    Socket 是应用层与传输层之间的"桥梁",让你不用关心下面两层(网络层、网络接口层)的细节

    TCP/IP 四层

    负责什么

    Socket 的角色

    应用层

    你的程序(浏览器、微信等)

    你写代码的地方

    ↑↑↑↑↑↑↑↑↑↑↑↑↑

    Socket 接口在这里

    ↑↑↑↑↑↑↑↑↑↑↑↑↑

    传输层

    TCP/UDP(端口)

    Socket 帮你调用

    网络层

    IP(路由)

    Socket 帮你调用

    网络接口层

    MAC、网卡(物理传输)

    Socket 帮你调用


    3、TCP 和 UDP 有什么区别?

    主要有三点区别:

  • 连接:TCP 有连接,通信前要先保存对方的 IP 和端口(三次握手);UDP 无连接,不保存对方信息,直接发

  • 可靠性:TCP 可靠传输(牺牲效率),有确认和重传;UDP 不可靠,丢了不管

  • 数据方式:TCP 面向字节流,没有边界;UDP 面向数据报,有边界

  • 另外两者都是全双工(可以同时收发,即同一时刻双向通信)


    4、TCP 和 UDP 在“数据传输方式”上的解释

    TCP(面向字节流)

    想发送 100 个字节,可以 1 次全发,也可以分 10 次每次发 10 字节,还可以分 100 次每次发 1 字节

    本质: TCP 不关心你分几次发,只关心你发了多少字节。接收方也按字节流读,不知道你原来分了几次

    类比: 像水管里的水,你倒一桶水进去,出来也是一桶水,但中间是不分“块”的

    UDP(面向数据报)

    一次必须是发送/接收一个完整的 UDP 数据报,不能是半个

    本质: UDP 有边界,发的时候是一个完整的包,收的时候也必须一个完整的包收

    类比: 像寄快递,你发一个包裹,对方收到一个包裹,不会收到半个


    5、TCP和UDP的Socket实现区别

    代码实现对比

    维度

    TCP Socket

    UDP Socket

    核心类

    ServerSocket / Socket

    DatagramSocket

    数据传输

    基于流(Stream),数据无边界

    基于数据报(Datagram),每个包独立

    连接方式

    需要 accept() 建立连接(阻塞)

    无需连接,直接发

    收发方法

    getInputStream() / getOutputStream()

    send(DatagramPacket) / receive(DatagramPacket)

    丢包处理

    底层自动重传,保证到达

    不保证,可能丢包/乱序

    服务端标识

    每个客户端有独立Socket

    只有一个DatagramSocket,靠包内地址区分


    追问1:那TCP服务端怎么同时处理多个客户端?

    ①多线程

    优点:简单直观,每个客户端逻辑独立

    缺点:

    • 1个客户端 = 1个线程,1000个客户端 = 1000个线程

    • 线程切换开销大,内存占用高(每个线程约1MB栈空间)

    • C10K问题(1万并发就扛不住了)

    再问:线程池能解决吗?

    能缓解,但不能根治。线程池限制了最大线程数,超出就得排队或拒绝,本质还是"一个连接一个线程"的模式

    ②IO多路复用

    优点:

    • 一个线程能管理成千上万个连接

    • 没有线程切换开销

    • 内存占用低

    一个线程同时监控多个socket,哪个有数据就读哪个


    追问2:epoll的ET vs LT?(边缘触发 vs 水平触发)

    模式

    一句话解释

    行为

    LT(水平触发)

    有数据就一直通知你

    缓冲区有数据,每次调用epoll_wait都会通知

    ET(边缘触发)

    新数据来了只通知一次

    只在状态从"无数据→有数据"时通知一次

    回答:

    LT是默认模式,更安全,但可能重复通知;ET性能更高,但要求用户一次性把数据读完,否则数据会丢。Redis、Nginx用ET追求极致性能


    本章完

    赞(0)
    未经允许不得转载:171主机测评 » 04、JAVAEE---多线程进阶、文件I/O、网络初识
    分享到: 更多 (0)

    评论 抢沙发

    • 昵称 (必填)
    • 邮箱 (必填)
    • 网址