八股文---JUC(1)

最新推荐文章于 2026-01-06 12:00:34 发布
原创 最新推荐文章于 2026-01-06 12:00:34 发布 · 1k 阅读 · 24 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#八股文 #java #八股 #juc

1.线程和进程的区别？

进程

程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至 CPU，数据加载至内存。在指令运行过程中还需要用到磁盘、网络等设备。进程就是用来加载指令、管理内存、管理 IO 的。

当一个程序被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。

线程

一个进程之内可以分为一到多个线程。

一个线程就是一个指令流，将指令流中的一条条指令以一定的顺序交给 CPU 执行

Java 中，线程作为最小调度单位，进程作为资源分配的最小单位。在 windows 中进程是不活动的，只是作为线程的容器

区别

  • 进程是正在运行程序的实例，进程中包含了线程，每个线程执行不同的任务
  • 不同的进程使用不同的内存空间，在当前进程下的所有线程可以共享内存空间
  • 线程更轻量，线程上下文切换成本一般上要比进程上下文切换低(上下文切换指的是从一个线程切换到另一个线程)

AI回答

线程与进程的区别可以从多个维度进行分析，主要包括资源管理、执行单位、独立性、资源消耗、通信机制及对系统的影响等方面。以下是对这些区别的详细总结：

  1. 资源管理：
    • 进程：拥有独立的内存空间，包括堆、栈和全局变量，资源隔离性强。
    • 线程：共享进程的内存空间，资源消耗较低。
  1. 执行单位：
    • 进程：执行应用程序，可以包含多个线程。
    • 线程：在进程内执行任务，一个进程可有多个线程。
  1. 独立性：
    • 进程：独立运行，崩溃不会影响其他进程。
    • 线程：共享进程资源，崩溃可能导致整个进程终止。
  1. 资源消耗：
    • 进程：创建和切换开销大，资源消耗多。
    • 线程：创建和切换开销小，资源消耗少。
  1. 通信机制：
    • 进程：使用管道、共享内存、消息队列等复杂方式。
    • 线程：使用锁、信号量等同步工具，通信简便。
  1. 调度与管理：
    • 进程：由操作系统调度，管理独立。
    • 线程：由操作系统调度，但在应用层面需管理协调。
  1. 适用场景：
    • 进程：适合处理独立任务，如运行多个程序。
    • 线程：适合在同一任务中执行多个子任务，提升效率。
      总结来说，进程是较大的独立资源单位，适合独立任务；而线程是轻量级的执行单位，适合在同一进程中处理多任务，提升效率。理解这些区别有助于在编程和系统设计中合理选择使用进程和线程，优化程序性能。

⭐️2.并行与并发的区别

并行

并行（parallel）是同一时间动手做（doing）多件事情的能力

并发

并发（concurrent）是同一时间应对（dealing with）多件事情的能力

回答

并行（Parallelism）和并发（Concurrency）的核心区别在于任务执行的方式：

  • 并行是物理上的同时执行，依赖多核/多线程硬件（如同时处理两个任务的CPU核心）。
  • 并发是逻辑上的交替执行，通过任务切换模拟“同时”（如单核CPU分时处理多个任务）。

通俗比喻：

并行是多个收银台同时结账（真正的同时工作）。

并发是一个收银台交替处理多个顾客的扫码和支付（快速切换，看似同时）。

⭐️⭐️3.线程创建的方式

1.继承Thread类


class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread running");
    }
}
// 启动线程
new MyThread().start();
  • 优点：简单直接，适合快速实现。
  • 缺点：Java单继承限制，无法继承其他类。

2.实现runnable

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable running");
    }
}
// 启动线程  
new Thread(new MyRunnable()).start();
  • 优点：解耦任务与线程，可复用类，支持Lambda简化（new Thread(() -> {...})）。
  • 缺点：无返回值，需通过共享变量或回调获取结果

3.实现Callable接口

class MyCallable implements Callable<String> {
    @Override
    public String call() {
        return "Task result";
    }
}
// 启动线程  
FutureTask<String> futureTask = new FutureTask<>(new MyCallable());  
new Thread(futureTask).start();
String result = futureTask.get(); // 阻塞获取结果
  • 优点：支持返回值，可捕获异常，适合需要结果的异步任务。
  • 缺点：代码稍复杂，需处理Future的阻塞问题。

4.线程池创建线程

ExecutorService executor = Executors.newFixedThreadPool(4);  
executor.submit(() -> {
    System.out.println("Task from thread pool");
});  
executor.shutdown();

优点：资源复用（避免频繁创建/销毁线程）、支持任务队列、可管控线程数量。

缺点：需合理配置参数（如核心线程数、拒绝策略）

回答

Java中线程创建主要有四种方式：继承Thread类、实现Runnable或Callable接口，以及使用线程池。

  1. 继承Thread类简单但耦合性高；
  2. Runnable解耦任务逻辑，支持Lambda；
  3. Callable支持返回值和异常处理；
  4. 线程池是生产环境首选，通过复用线程提升性能并避免资源耗尽。

实际开发中，推荐使用Runnable+线程池，兼顾灵活性和资源管理。

.

4.runnable 和 callable 有什么区别

1.Runable接口run方法没有返回值

2.Callable接口call方法有返回值，是个泛型，和Future，FutureTask配合可以异步获取执行的结果

3.Callable接口的call方法可以抛出异常，而Runable接口的run方法只能内部处理

回答

Runnable和Callable都是定义任务的接口，但Callable支持返回值和抛出异常，通常与Future结合实现异步结果获取。

如果是无需返回值的任务（如日志记录），用Runnable更简单；

若需要异步计算并获取结果（如调用外部API），必须用Callable。

实际开发中，推荐优先使用Callable+线程池，通过Future管理任务生命周期，避免资源泄漏。

5.线程的 run()和 start()有什么区别？

run方法就是普通方法可以随便调用

start方法是用来启动线程只能调用一次

回答

start(): 用来启动线程，通过该线程调用run方法执行run方法中所定义的逻辑代码。start方法只能被调用一次。

run(): 封装了要被线程执行的代码，可以被调用多次

⭐⭐6.线程包括哪些状态，状态之间是如何变化

线程状态

关键状态转换

1.NEW-->RUNABLE

Thread thread = new Thread(() -> {});
System.out.println(thread.getState()); // NEW
thread.start();
System.out.println(thread.getState()); // RUNNABLE

2.RUNABLE-->BLOCKED

synchronized (lock) {
    // 线程A持有锁时，线程B尝试进入同步块 → BLOCKED
}

3.RUNABLE-->WAITING

synchronized (lock) {
    lock.wait(); // 释放锁并进入WAITING状态
}

4.RUNABLE-->TIMED_WAITING

Thread.sleep(1000); // 进入TIMED_WAITING, 1秒后恢复

5.WAITING/TIME_WAITING-->RUNABLE

synchronized (lock) {
    lock.notify(); // 唤醒等待的线程
}

6.RUNABLE-->TERMINATED

thread.start();
thread.join(); // 等待线程结束
System.out.println(thread.getState()); // TERMINATED

回答

在Java中，线程共有6种状态：NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING和TERMINATED。

  • NEW是线程刚创建未启动的状态；
  • RUNNABLE表示线程正在运行或就绪等待CPU时间片；
  • BLOCKED是线程因竞争锁而阻塞；
  • WAITING和TIMED_WAITING是线程主动等待或被挂起，区别在于后者有超时机制；
  • TERMINATED是线程执行结束后的终止状态。

状态转换的关键触发点包括：

  • start()使线程从NEW进入RUNNABLE；
  • 竞争锁失败进入BLOCKED，锁释放后回到RUNNABLE；
  • 调用wait()或join()进入WAITING，需notify()唤醒；
  • sleep()或带超时的wait()进入TIMED_WAITING，超时后自动恢复；
  • 线程执行完毕或异常终止进入TERMINATE

7.sleep 和 wait的区别是什么？

回答

共同点

  • wait() ，wait(long) 和 sleep(long) 的效果都是让当前线程暂时放弃 CPU 的使用权，进入阻塞状态

不同点

  • 方法归属不同
    • sleep(long) 是 Thread 的静态方法
    • 而 wait()，wait(long) 都是 Object 的成员方法，每个对象都有
  • 醒来时机不同
    • 执行 sleep(long) 和 wait(long) 的线程都会在等待相应毫秒后醒来
    • wait(long) 和 wait() 还可以被 notify 唤醒，wait() 如果不唤醒就一直等下去
    • 它们都可以被打断唤醒
  • 锁特性不同（重点）
    • wait 方法的调用必须先获取 wait 对象的锁，而 sleep 则无此限制
    • wait 方法执行后会释放对象锁，允许其它线程获得该对象锁（我放弃 cpu，但你们还可以用）
    • 而 sleep 如果在 synchronized 代码块中执行，并不会释放对象锁（我放弃 cpu，你们也用不了）

8.如何停止一个正在运行的线程
 

1. 使用标志位（推荐）

通过共享的volatile变量控制线程退出，确保线程能安全完成收尾工作。

class MyThread extends Thread {
    private volatile boolean stopped = false; // 必须用volatile保证可见性

    @Override
    public void run() {
        while (!stopped) {
            // 执行任务
            System.out.println("Running...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt(); // 恢复中断状态
                break;
            }
        }
        System.out.println("Thread stopped safely");
    }

    public void stopThread() {
        stopped = true;
        this.interrupt(); // 双保险：唤醒可能处于sleep/wait的线程
    }
}

// 使用示例
MyThread thread = new MyThread();
thread.start();
Thread.sleep(3000);
thread.stopThread();

优点：安全可控，允许线程清理资源。

适用场景：循环执行的线程任务

2. 调用interrupt()中断线程

通过中断信号协作，线程需检查中断状态或处理

Thread thread = new Thread(() -> {
    while (!Thread.currentThread().isInterrupted()) {
        try {
            System.out.println("Working...");
            Thread.sleep(1000); // 阻塞方法会响应中断
        } catch (InterruptedException e) {
            System.out.println("Thread interrupted");
            Thread.currentThread().interrupt(); // 重新设置中断标志
            break;
        }
    }
});
thread.start();
Thread.sleep(3000);
thread.interrupt(); // 发送中断信号

关键点：

阻塞方法（如sleep(), wait(), join()）会立即抛出InterruptedException。

非阻塞代码需手动检查isInterrupted()。

适用场景：需要快速响应中断的任务。

3. 通过线程池关闭（ExecutorService）

使用线程池管理时，调用shutdown()或shutdownNow()

ExecutorService executor = Executors.newSingleThreadExecutor();
executor.submit(() -> {
    while (!Thread.currentThread().isInterrupted()) {
        System.out.println("Running...");
    }
});
Thread.sleep(3000);
executor.shutdownNow(); // 发送中断信号并停止所有线程

区别：

shutdown()：等待已提交任务完成。

shutdownNow()：尝试中断所有运行中的线程。

适用场景：使用线程池的并发任务。

4. 使用Future取消任务（带返回值任务）

通过Future.cancel(true)中断正在执行的Callable任务

ExecutorService executor = Executors.newSingleThreadExecutor();
Future<?> future = executor.submit(() -> {
    while (!Thread.currentThread().isInterrupted()) {
        System.out.println("Calculating...");
    }
    return 42;
});
Thread.sleep(1000);
future.cancel(true); // true表示允许中断线程

为什么不推荐用Thread.stop()？

❌ 立即释放所有锁，可能导致对象状态不一致。

❌ 不执行finally块，容易引发资源泄漏。

❌ 已被官方标记为@Deprecated。

避免使用以下已废弃方法：

Thread.stop()：暴力终止，可能导致状态不一致。

Thread.suspend()/resume()：易导致死锁。

⭐⭐9.synchronized关键字的底层原理

1. 基本概念

synchronized 是 Java 中实现线程同步的核心机制，通过内置锁（监视器锁，Monitor Lock）确保多线程环境下对共享资源的互斥访问。其底层实现涉及 对象头、锁状态升级、JVM 指令 等关键机制。

2. 对象头与 Monitor

对象头结构：

Java 对象在内存中分为三部分：

  • 对象头（Header）
  • 实例数据（Instance Data）
  • 对齐填充（Padding）。

对象头中的锁信息：存储锁标志位（Lock Flag）、偏向线程ID、轻量级锁指针、重量级锁指针等。

锁标志位（Mark Word）：标识当前对象的锁状态（无锁、偏向锁、轻量级锁、重量级锁）。

Monitor 机制：

每个 Java 对象都与一个 Monitor 关联。

线程执行 synchronized 代码块时，需先通过 monitorenter 指令获取对象的 Monitor。

执行完毕时，通过 monitorexit 指令释放 Monitor。

Monitor内部具体的存储结构：

  • Owner：存储当前获取锁的线程的，只能有一个线程可以获取
  • EntryList：关联没有抢到锁的线程，处于Blocked状态的线程
  • WaitSet：关联调用了wait方法的线程，处于Waiting状态的线程

具体的流程：

  • 代码进入synchorized代码块，先让lock（对象锁）关联的monitor，然后判断Owner是否有线程持有
  • 如果没有线程持有，则让当前线程持有，表示该线程获取锁成功
  • 如果有线程持有，则让当前线程进入entryList进行阻塞，如果Owner持有的线程已经释放了锁，在EntryList中的线程去竞争锁的持有权（非公平）
  • 如果代码块中调用了wait()方法，则会进去WaitSet中进行等待

3.回答

synchronized 底层使用的JVM级别中的Monitor 来决定当前线程是否获得了锁，如果某一个线程获得了锁，在没有释放锁之前，其他线程是不能或得到锁的。synchronized 属于悲观锁。synchronized 因为需要依赖于JVM级别的Monitor ，相对性能也比较低。

monitor对象存在于每个Java对象的对象头中，synchronized 锁便是通过这种方式获取锁的，也是为什么Java中任意对象可以作为锁的原因
monitor内部维护了三个变量

  • WaitSet：保存处于Waiting状态的线程
  • EntryList：保存处于Blocked状态的线程
  • Owner：持有锁的线程

只有一个线程获取到的标志就是在monitor中设置成功了Owner，一个monitor中只能有一个Owner
在上锁的过程中，如果有其他线程也来抢锁，则进入EntryList 进行阻塞，当获得锁的线程执行完了，释放了锁，就会唤醒EntryList 中等待的线程竞争锁，竞争的时候是非公平的

10.syncronized锁升级的过程讲一下

无锁：这是没有开启偏向锁的时候的状态，在JDK1.6之后偏向锁的默认开启的，但是有一个偏向延迟，需要在JVM启动之后的多少秒之后才能开启，这个可以通过JVM参数进行设置，同时是否开启偏向锁也可以通过JVM参数设置。

偏向锁：这个是在偏向锁开启之后的锁的状态，如果还没有一个线程拿到这个锁的话，这个状态叫做匿名偏向，当一个线程拿到偏向锁的时候，下次想要竞争锁只需要拿线程ID跟MarkWord当中存储的线程ID进行比较，如果线程ID相同则直接获取锁（相当于锁偏向于这个线程），不需要进行CAS操作和将线程挂起的操作。

轻量级锁：在这个状态下线程主要是通过CAS操作实现的。将对象的MarkWord存储到线程的虚拟机栈上，然后通过CAS将对象的MarkWord的内容设置为指向Displaced Mark Word的指针，如果设置成功则获取锁。在线程出临界区的时候，也需要使用CAS，如果使用CAS替换成功则同步成功，如果失败表示有其他线程在获取锁，那么就需要在释放锁之后将被挂起的线程唤醒。

重量级锁：当有两个以上的线程获取锁的时候轻量级锁就会升级为重量级锁，因为CAS如果没有成功的话始终都在自旋，进行while循环操作，这是非常消耗CPU的，但是在升级为重量级锁之后，线程会被操作系统调度然后挂起，这可以节约CPU资源。

线程A进入 synchronized 开始抢锁，JVM 会判断当前是否是偏向锁的状态，如果是就会根据 Mark Word 中存储的线程 ID 来判断，当前线程A是否就是持有偏向锁的线程。如果是，则忽略 check，线程A直接执行临界区内的代码。 但如果 Mark Word 里的线程不是线程 A，就会通过自旋尝试获取锁，如果获取到了，就将 Mark Word 中的线程 ID 改为自己的;如果竞争失败，就会立马撤销偏向锁，膨胀为轻量级锁。 后续的竞争线程都会通过自旋来尝试获取锁，如果自旋成功那么锁的状态仍然是轻量级锁。然而如果竞争失败，锁会膨胀为重量级锁，后续等待的竞争的线程都会被阻塞。

11.CAS 你知道吗？

CAS全称：Compare And Swap（比较在交换），体现的一种乐观锁的思想，在没有锁的情况保证了线程操作共享数据的原子性。

一个当前内存值V、旧的预期值A、即将更新的值B，当且仅当旧的预期值A和内存值V相同时，将内存值修改为B并返回true，否则什么都不做，并返回false。如果CAS操作失败，通过自旋的方式等待并再次尝试，直到成功

详细剖析多线程4----锁策略（八股文/面试常考）
m0_74299308的博客
04-21 1239
多线程编程中的锁策略对于确保数据一致性和线程安全至关重要。本文将介绍悲观锁、乐观锁以及轻量级锁等常见锁策略内容~synchronized具有自适应能力。如果当前锁冲突的激烈程度不大，就处于乐观锁/轻量级锁/自旋锁；如果当前锁冲突很大,就处于悲观锁/重量级锁/挂起等待锁。一般来说，无脑使用synchronized不会有问题，并且很高效。
八股文--JUC(2)
cjpabc的博客
05-16 1287
ReentrantLock翻译过来是可重入锁，相对于synchronized它具备以下特点：可中断（可以主动放弃）可以设置超时时间可以设置公平锁支持多个条件变量与synchronized一样，都支持重入。
八股文-多线程、并发
py1215的博客
09-20 968
八股文-多线程、并发
八股文系列-JUC
xizhouxiang的博客
10-14 497
八股文系列-JUCjava并发类库提供的线程池有哪些，分别有什么特点？HashMap和ConcurrentHashMap区别？高并发HashMap的环是如何产生的？线程数量该设置多少？如果批量的执行异步任务？Java虚拟机是如何实现Synchronized的？说一说对JMM内存模型的理解？volatile作用？Atomic类如何保证原子性？ReentrantLock实现原理是什么？聊一聊AQS？synchronized和lock/ReentrantLock区别是什么？ThreadLocal的实现和原理是什么
黑马八股文-多线程篇
weixin_43777222的博客
11-11 1150
黑马八股文-多线程
Java-面试八股文-Java高级篇
2302_81048526的博客
08-25 969
区域线程共享作用程序计数器❌ 私有记录字节码执行行号JVM 栈❌ 私有方法调用、局部变量、操作数栈本地方法栈❌ 私有本地方法调用支持堆 (Heap)✅ 共享存放对象和数组，GC 管理的主要区域方法区 (Metaspace)✅ 共享存放类元数据、常量池、静态变量方法/算法特点优缺点应用场景引用计数法计数为 0 即回收无法解决循环引用Java 不用标记-清除标记存活再清除内存碎片老年代（早期）复制算法存活对象复制到另一块空间浪费新生代标记-整理。
八股文-Java并发
zhaohuodian的博客
09-02 176
每当一个线程执行完毕后，调用countDown方法，计数器的值就减1，当计数器的值为0时，表示所有线程都执行完毕，然后在等待的线程就可以恢复工作了。工作内存中保存被该线程使用的变量的主内存副本，线程对变量的所有操作都必须在工作空间进行，不能直接读写主内存数据。CAS 算法是基于值来做比较的，如果当前有两个线程，一个线程将变量值从 A 改为 B ，再由 B 改回为 A ，当前线程开始执行 CAS 算法时，就很容易认为值没有变化，误认为读取数据到执行 CAS 算法的期间，没有线程修改过数据。
八股学习-JUC java并发编程
qq_55198752的博客
03-19 937
可以把 JMM 看作是 Java 定义的并发编程相关的一组规范，除了抽象了线程和主内存之间的关系之外，其还规定了从 Java 源代码到 CPU 可执行指令的这个转化过程要遵守哪些和并发相关的原则和规范，其主要目的是为了简化多线程编程，增强程序可移植性的。说白了就是定义了一些规范来解决这些问题，开发者可以利用这些规范更方便地开发多线程程序。对于 Java 开发者说，你不需要了解底层原理，直接使用并发相关的一些关键字和类（比如volatile、各种Lock）即可开发出并发安全的程序。
【面试八股文】- 多线程进阶
qq_45792749的博客
05-07 1722
目录一、常见锁策略1.读写锁 VS 普通的互斥锁2.悲观锁 VS 乐观锁3.轻量级锁 VS 重量级锁4.挂起等待锁 VS 自旋锁5.公平锁 VS 非公平锁 一、常见锁策略 1.读写锁 VS 普通的互斥锁 普通的互斥锁： 只要两个线程针对同一个对象加锁，就会产生互斥 读写锁： 加读锁: 如果代码只进行读操作，就加读锁 加写锁: 如果代码进行了写操作，就加写锁 将读写锁分开，那么 读锁和读锁之间是不互斥的 ，只有读锁和写锁，写锁和写锁之间才互斥。 2.悲观锁 VS 乐观锁 悲观锁：预期锁冲突的概
Java八股文 - 核心技术卷Ⅰ
Tony_tony08的博客
08-13 598
JDK1.8:采用CAS+Synchronized保证线程安全，每次插入数据时判断在当前数组下标是否是第一次插入，是就通过CAS方式插入，然后判断f.hash是否=-1，是的话就说明其他线程正在进行扩容，当前线程也会参与扩容；ArratList的底层使用动态数组，默认容量为10，当元素数量到达容量时，生成一个新的数组，大小为前一次的1.5倍，然后将原来的数组copy过来；JDK1.7:使用分段锁，将一个Map分为了16个段，每个段都是一个小的hashmap，每次操作只对其中一个段加锁。
java八股文之JUC.zip
05-08
本篇将深入探讨Java八股文中涉及的JUC相关知识点，帮助你在面试中表现出扎实的并发编程基础。 1. **线程安全**：在多线程环境中，为了保证数据的一致性和完整性，我们需要关注线程安全问题。Java中的`synchronized`...
动力节点【Java八股文】.pdf
10-16
"动力节点【Java八股文】.pdf" 本资源摘要信息涵盖了 Java 编程语言的基本概念、面向对象编程、JavaSE、数据库基础知识、Java Web 开发、框架和工具等多方面的知识点。 Java 基础知识 1. 面向对象编程（OOP）：...
Java八股文面试题精讲与实战代码解析
12-11
在Java面试过程中，面试官经常会问到一系列标准化的题目，这些题目被程序员们戏称为“Java八股文”。掌握这些面试题对于通过面试、展示自己的技术实力具有非常重要的意义。 本书《Java八股文面试题精讲与实战代码...
【线程池 + Socket 服务器】
2401_86718044的博客
01-01 1360
通过线程池 + Socket 的组合，我们可以轻松构建高并发、可扩展的网络服务器。Flush 机制看似小细节，却直接影响数据是否及时、正确到达客户端。掌握自动与手动两种方式，就能应对从简单聊天到文件上传的各种场景。这两个示例代码都已经过完整测试，直接复制运行即可。欢迎在评论区分享你的实践经验，或者提出想看的进阶话题（如 NIO、非阻塞、HTTP 协议解析）
01.05.01 Java 基础系列｜深入理解 BIO：从核心 API 到实战设计
u010105645的专栏
01-03 646
摘要：本文深入解析Java BIO（阻塞式I/O）编程，从核心API到生产级实现。BIO作为Java网络编程基础，采用同步阻塞模型，通过ServerSocket监听连接、Socket进行数据传输。文章演示了BIO的三个演进阶段：单线程模型（性能低下）、多线程模型（易资源耗尽）到最终的线程池伪异步模型（生产级方案）。重点讲解了线程池配置、资源管理、异常处理等实战技巧，并提供了完整的线程池BIO服务器实现代码，帮助开发者理解传统IO模型的核心原理及其适用场景。
阿里Java面试被问：单元测试的最佳实践
2501_94505843的博客
01-04 883
本文系统介绍了软件测试的最佳实践，主要包含以下内容：1. 测试金字塔原则，推荐70%单元测试+20%集成测试+10%端到端测试的比例；2. 测试代码质量标准，包括命名规范、AAA模式等；3. Mock与Stub的使用场景和区别；4. 测试数据管理策略；5. 断言最佳实践；6. 测试隔离与可重复性；7. 测试性能与维护建议；8. 边界条件测试方法；9. 有意义的测试覆盖率目标；10. TDD开发流程。文章提供了大量代码示例，并总结了单元测试检查清单和测试金字塔指导原则，强调应重点关注业务逻辑、复杂算法和边界条
面向微服务事件驱动与异步消息可靠处理的互联网系统高可用设计与多语言工程实践分享
2501_94180531的博客
01-05 421
事件驱动解耦服务，提高吞吐可靠投递与幂等消费保证消息一致性监控、重试与顺序控制是稳定性的关键微服务事件驱动与异步消息可靠处理，使系统在高并发和复杂业务场景下保持稳定与可控。通过在多语言系统中统一幂等语义、结合可靠投递、顺序控制和监控策略，互联网系统能够在异步流程中实现高可用和长期可维护性。这篇关于事件驱动与异步消息可靠处理的工程实践分享，希望为你在微服务高可用设计中提供可落地、长期有效的参考思路。
TDengine JAVA 语言连接器入门指南
TDengine(老段）专注时序数据库领域
01-04 1712
JAVA 语言连接器
windows下的守护进程|nssm
最新发布
slongzhang的博客
01-06 893
NSSM（Non-Sucking Service Manager）是Windows系统中将普通程序封装为系统服务的工具。使用步骤包括：下载解压NSSM，以管理员身份运行CMD/PowerShell；通过图形界面或命令行安装服务，配置可执行文件路径、参数等；使用start/stop/restart命令管理服务；支持通过edit命令修改配置或remove删除服务；建议配置日志功能方便排查问题。核心功能是实现进程守护，确保程序异常退出后自动重启。
掌握Java八股文，提升面试技巧，争取10K-20K高薪
资源摘要信息: "Java 八股文 面试常用 参考薪资10K-20K" Java是一种广泛应用于企业级开发的编程语言，它以其跨平台性、面向对象特性、稳定性和丰富的生态而备受开发者的青睐。在IT行业，Java开发者的需求量巨大，...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值