高频八股总结1
线程池的原理，核心线程与非核心线程的区别？
线程池是一种多线程处理形式，其核心思想是预先创建一定数量的线程，这些线程存放在一个“池”里，当有任务提交时，就从池中选取一个空闲线程来执行任务。执行完毕后，线程并不会销毁，而是回到池中等待下一次的任务。线程池的好处在于减少在创建和销毁线程上所花的时间和资源消耗，提高了程序响应速度和并发量。
线程池的原理
- 任务提交：当有任务提交到线程池时，线程池会首先检查核心线程是否都在执行任务。如果核心线程有空闲，则直接使用核心线程执行任务；如果核心线程都在忙，则将任务放入任务队列中等待。
- 任务队列：如果任务队列未满，任务会被放入队列中等待执行；如果任务队列已满，线程池会检查当前线程数是否小于最大线程数。如果小于，则创建非核心线程执行任务；如果已达到最大线程数，则根据拒绝策略处理任务。
- 线程复用：线程执行完任务后，会继续从任务队列中获取新的任务执行，而不是销毁。这样可以避免频繁创建和销毁线程的开销。
- 线程回收：非核心线程在空闲超过一定时间（
keepAliveTime）后会被回收，而核心线程默认会一直存活，除非设置了allowCoreThreadTimeOut为true，此时核心线程也会在空闲超过keepAliveTime后被回收。
核心线程与非核心线程的区别
- 生命周期：
• 核心线程：默认情况下，核心线程会一直存活，即使空闲也不会被回收，除非设置了allowCoreThreadTimeOut为true。
• 非核心线程：非核心线程在空闲超过keepAliveTime后会被回收，以节省资源。 - 创建时机：
• 核心线程：在线程池初始化时或任务提交时创建，数量不超过corePoolSize。
• 非核心线程：当任务队列已满且当前线程数小于maximumPoolSize时创建，用于处理突发任务。 - 数量限制：
• 核心线程：数量由corePoolSize决定，是线程池的基础线程数。
• 非核心线程：数量由maximumPoolSize - corePoolSize决定，用于应对任务高峰。
总结
线程池通过核心线程和非核心线程的配合，实现了线程的复用和资源的合理利用。核心线程是线程池的基础，用于处理常规任务；非核心线程则用于应对突发任务，空闲时会被回收以节省资源。
非核心线程池销毁的具体实现过程？
非核心线程池的销毁过程主要依赖于线程池的配置和任务队列的状态。以下是具体的实现过程：
任务获取与超时机制：
• 非核心线程通过getTask()方法从任务队列中获取任务。如果线程池配置了allowCoreThreadTimeOut为true，则核心线程也会参与超时机制。
• 在getTask()方法中，非核心线程会调用workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS)，这是一个超时等待的方法。如果在keepAliveTime时间内没有获取到任务，poll()方法会返回null。线程回收条件：
• 当getTask()返回null时，表示当前线程已经空闲超过keepAliveTime时间，且没有新任务需要处理。
• 线程池会通过compareAndDecrementWorkerCount(c)方法减少工作线程数。如果成功，当前线程会被标记为可回收。线程销毁：
• 在runWorker()方法中，当getTask()返回null时，线程会退出while循环，并进入processWorkerExit(w, completedAbruptly)方法。
•processWorkerExit()方法会从线程池的workers集合中移除当前线程，并调用Thread.interrupt()方法中断线程，最终线程会被JVM回收。特殊情况处理：
• 如果线程池调用了shutdown()方法，所有空闲线程（包括非核心线程）都会收到中断信号，并在getTask()中捕获中断异常，最终进入processWorkerExit()方法被销毁。
• 如果线程池状态为STOP、TIDYING或TERMINATED，所有线程（无论是否空闲）都会被强制销毁。
总结
非核心线程的销毁过程主要包括：
- 通过
getTask()方法检测线程是否空闲超时。 - 如果超时，减少工作线程数并标记线程为可回收。
- 在
processWorkerExit()方法中移除线程并中断其执行，最终由JVM回收。
这一过程确保了线程池在任务量减少时能够动态回收多余的线程，避免资源浪费。
在创建线程池时，你不仅负责指定核心线程池的大小，还需要明确如何管理非核心线程。具体来说，线程池的管理包括核心线程和非核心线程的创建、销毁以及任务调度等。以下是关键点：
核心线程与非核心线程的区别：
• 核心线程：默认情况下，核心线程会一直存活，即使没有任务执行，除非设置了allowCoreThreadTimeOut为true，此时核心线程在空闲超过keepAliveTime后也会被销毁。
• 非核心线程：当任务队列已满且当前线程数小于最大线程数时，线程池会创建非核心线程来处理任务。非核心线程在空闲超过keepAliveTime后会被销毁。创建线程池时的参数：
• **corePoolSize**：指定核心线程的数量。
• **maximumPoolSize**：指定线程池中允许的最大线程数（包括核心线程和非核心线程）。
• **keepAliveTime**：指定非核心线程空闲时的存活时间。
• **unit**：keepAliveTime的时间单位。
• **workQueue**：任务队列，用于存放待执行的任务。
• **threadFactory**：用于创建新线程的工厂。
• **handler**：当任务队列已满且线程数达到最大线程数时，用于处理新提交任务的拒绝策略。非核心线程的管理：
• 非核心线程的创建和销毁由线程池自动管理。当任务队列已满且当前线程数小于maximumPoolSize时，线程池会创建非核心线程；当非核心线程空闲超过keepAliveTime时，线程池会销毁这些线程。
• 你不需要手动管理非核心线程的生命周期，线程池会根据配置自动处理。总结：
• 你负责指定核心线程池的大小（corePoolSize）和最大线程数（maximumPoolSize），并设置非核心线程的存活时间（keepAliveTime）。
• 线程池会自动管理非核心线程的创建和销毁，你无需手动干预。
因此，创建线程池时，你不仅负责核心线程池的配置，还需要通过参数明确非核心线程的管理方式。
如何保证线程安全？
保证线程安全是多线程编程中的核心问题，目的是确保多个线程并发访问共享资源时，程序能够正确执行，不会出现数据竞争或不一致的情况。以下是实现线程安全的常用方法：
1. 使用同步机制
• synchronized关键字：通过修饰方法或代码块，确保同一时间只有一个线程可以访问共享资源。
public class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
}
• 同步块：只锁定需要同步的部分，提高效率。
public class Counter {
private int count = 0;
public void increment() {
synchronized (this) {
count++;
}
}
}
2. 使用锁
• **ReentrantLock**：显式锁，提供更灵活的锁定机制。
import java.util.concurrent.locks.ReentrantLock;
public class Counter {
private int count = 0;
private final ReentrantLock lock = new ReentrantLock();
public void increment() {
lock.lock();
try {
count++;
} finally {
lock.unlock();
}
}
}
3. 使用原子变量
• AtomicInteger等原子类：通过CAS（Compare-And-Swap）操作实现无锁线程安全。
import java.util.concurrent.atomic.AtomicInteger;
public class Counter {
private AtomicInteger count = new AtomicInteger(0);
public void increment() {
count.incrementAndGet();
}
}
4. 使用线程安全的数据结构
• ConcurrentHashMap、CopyOnWriteArrayList等：这些数据结构内部已经实现了线程安全，无需额外同步。
import java.util.concurrent.ConcurrentHashMap;
public class Example {
private ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
public void add(String key, int value) {
map.put(key, value);
}
}
5. 避免共享状态
• 使用局部变量：局部变量是线程私有的，不会引发线程安全问题。
public class Example {
public void process() {
int localVar = 0; // 线程安全
localVar++;
}
}
6. 使用不可变对象
• 不可变对象：如String、Integer等，它们的状态无法被修改，因此是线程安全的。
public class Example {
private final String immutableString = "Hello"; // 线程安全
}
7. 使用volatile关键字
• **volatile**：保证变量的可见性，但不保证原子性。适用于状态标志等场景。
public class Example {
private volatile boolean flag = false; // 线程安全
}
8. 使用线程安全的库或框架
• java.util.concurrent包：提供了丰富的线程安全工具，如CountDownLatch、Semaphore等。
总结
实现线程安全的核心在于控制对共享资源的访问，确保多个线程不会同时修改同一数据。具体方法包括同步机制、锁、原子变量、线程安全的数据结构等。选择合适的方法需要根据具体场景和性能需求进行权衡。
synchronized实现的逻辑？
synchronized (this) 是 Java 中用于实现线程同步的一种机制，它的作用是获取当前对象（this）的锁，确保在同一时间内只有一个线程可以执行被 synchronized (this) 修饰的代码块或方法。以下是它的具体含义和作用：
锁定当前对象：
•synchronized (this)中的this指的是当前实例对象。当一个线程进入synchronized (this)代码块时，它会尝试获取当前对象的锁。如果锁被其他线程持有，当前线程会阻塞，直到锁被释放。线程互斥：
• 如果多个线程同时访问同一个对象的synchronized (this)代码块，只有一个线程可以执行，其他线程必须等待当前线程执行完毕并释放锁后才能继续执行。这确保了线程间的互斥访问，避免了数据竞争和不一致的问题。作用范围：
•synchronized (this)只锁定当前对象的同步代码块，其他非synchronized代码块或方法仍然可以被其他线程并发访问。锁的释放：
• 当线程执行完synchronized (this)代码块后，会自动释放锁，其他等待的线程可以获取锁并执行代码。
示例代码：
public class Example { |
在这个例子中，Thread-1 和 Thread-2 会竞争 synchronized (this) 锁，同一时间只有一个线程可以执行 method() 中的代码块。
总结：
synchronized (this) 是一种简单而有效的线程同步机制，它通过锁定当前对象来确保线程安全。适用于多线程环境下对共享资源的互斥访问。
volatile关键字有什么功能
volatile 是 Java 中的一个关键字，用于修饰变量，主要功能是保证变量的可见性和禁止指令重排序，但它不保证原子性。以下是 volatile 关键字的具体功能：
1. 保证可见性
• 在多线程环境下，如果一个线程修改了 volatile 变量的值，这个新值会立即被写回到主内存，而不是仅仅保存在线程的本地缓存中。其他线程在读取这个变量时，会直接从主内存中获取最新的值，而不是使用本地缓存中的旧值。这样可以避免线程间的数据不一致问题。
2. 禁止指令重排序
• 编译器和处理器为了提高性能，可能会对指令进行重排序。volatile 关键字通过插入内存屏障（Memory Barrier）来禁止指令重排序，确保代码的执行顺序符合预期。例如，在 volatile 写操作前后会插入 StoreStore 和 StoreLoad 屏障，而在 volatile 读操作后会插入 LoadLoad 和 LoadStore 屏障。
3. 不保证原子性
• volatile 只能保证单个读/写操作的原子性，但不能保证复合操作（如 i++）的原子性。例如，count++ 操作实际上分为读取、修改、写入三个步骤，volatile 无法保证这三个步骤的原子性。如果需要原子性操作，可以使用 synchronized 或 java.util.concurrent.atomic 包中的原子类（如 AtomicInteger）。
4. 适用场景
• 状态标志：用于标记某个状态（如任务是否完成），确保多个线程能够及时感知状态的变化。
• 双重检查锁定（Double-Checked Locking）：在单例模式中，使用 volatile 修饰单例实例变量，避免指令重排序导致的问题。
• 轻量级同步机制：在不需要复杂同步逻辑的场景下，volatile 比 synchronized 更轻量。
5. 不适用场景
• 复合操作：如 i++、i = i + 1 等操作，volatile 无法保证原子性。
• 依赖当前值的写入操作：如果变量的写入操作依赖于当前值（如 count = count + 1），volatile 无法保证线程安全。
示例代码
public class VolatileExample { |
在这个例子中，flag 被声明为 volatile，确保了 monitorTask() 方法能够及时感知到 flag 的变化，从而正确退出循环。
总结
volatile 关键字是一种轻量级的同步机制，适用于确保变量的可见性和禁止指令重排序的场景，但不适用于需要原子性操作的场景。在多线程编程中，合理使用 volatile 可以提高程序的正确性和性能。
如果这里没使用volatile会发生什么
如果没有使用 volatile 关键字，可能会导致以下问题：
可见性问题：
• 在多线程环境下，线程可能会从自己的本地缓存中读取变量的值，而不是从主内存中获取最新的值。即使一个线程修改了变量的值，其他线程可能无法立即看到这个修改，导致数据不一致的问题。指令重排序问题：
• 编译器和处理器可能会对指令进行重排序以优化性能。如果没有volatile关键字，这种重排序可能会导致程序的行为与预期不符。例如，在双重检查锁定（DCL）的单例模式中，如果没有volatile，可能会导致其他线程获取到一个未完全初始化的对象。原子性问题：
•volatile只能保证单个读/写操作的原子性，但不能保证复合操作（如i++）的原子性。如果没有volatile，复合操作可能会被其他线程打断，导致数据不一致。
示例场景
在双重检查锁定的单例模式中，如果没有使用 volatile，可能会出现以下情况：
public class Singleton { |
在这个例子中，instance = new Singleton(); 这行代码可能会被重排序，导致其他线程获取到一个未完全初始化的 Singleton 对象。使用 volatile 可以禁止这种重排序，确保对象的完整初始化。
总结
如果没有使用 volatile，可能会导致可见性问题、指令重排序问题和原子性问题。在多线程环境下，合理使用 volatile 可以避免这些问题，确保程序的正确性和一致性。
介绍mysql的事务隔离级别
MySQL 的事务隔离级别定义了事务在并发执行时，如何控制数据的可见性和一致性。MySQL 支持四种标准的事务隔离级别，从低到高分别是：读未提交（Read Uncommitted）、读已提交（Read Committed）、可重复读（Repeatable Read） 和 串行化（Serializable）。以下是每种隔离级别的详细介绍：
1. 读未提交（Read Uncommitted）
• 特点：允许事务读取其他事务未提交的数据。
• 问题：可能导致脏读（Dirty Read），即读取到未提交的数据，如果该事务回滚，读取的数据就是无效的。
• 适用场景：对数据一致性要求极低的场景，如临时统计或缓存预热。
• 设置方式：
SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
2. 读已提交（Read Committed）
• 特点：只允许读取已提交的数据，避免了脏读。
• 问题：可能导致不可重复读（Non-Repeatable Read），即同一事务内多次读取同一数据，结果可能不一致。
• 适用场景：大多数业务场景，如电商订单查询。
• 设置方式：
SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;
3. 可重复读（Repeatable Read）
• 特点：确保同一事务内多次读取同一数据的结果一致，避免了脏读和不可重复读。
• 问题：可能导致幻读（Phantom Read），即同一事务内多次查询同一范围的数据，结果集数量可能变化（如新增或删除记录）。
• 适用场景：对数据一致性要求较高的场景，如金融账户余额或库存扣减。
• 默认隔离级别：MySQL 的默认隔离级别。
• 设置方式：
SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ;
4. 串行化（Serializable）
• 特点：最高的隔离级别，强制事务串行执行，避免了脏读、不可重复读和幻读。
• 问题：性能最差，因为事务需要排队执行，可能导致大量的锁等待和死锁。
• 适用场景：对数据一致性要求极高的场景，如金融系统。
• 设置方式：
SET SESSION TRANSACTION ISOLATION LEVEL SERIALIZABLE;
总结
• 隔离级别越高，数据一致性越强，但并发性能越低。
• 隔离级别越低，并发性能越高，但数据一致性越弱。
• MySQL 默认的隔离级别是 可重复读（Repeatable Read），因为它在数据一致性和性能之间提供了较好的平衡。
开发者可以根据业务需求选择合适的隔离级别，以在数据一致性和系统性能之间找到最佳平衡点。
可重复读实现的原理？
MySQL 的 可重复读（Repeatable Read） 隔离级别是通过 多版本并发控制（MVCC, Multi-Version Concurrency Control） 和 锁定机制 来实现的。以下是其实现原理的详细说明：
1. 多版本并发控制（MVCC）
MVCC 是 MySQL 实现可重复读的核心机制。它的核心思想是：
• 为每条记录维护多个版本，每个版本都有一个创建时间（事务 ID）和删除时间（事务 ID）。
• 在事务执行期间，只能看到在该事务开始之前已经提交的数据版本，而看不到其他事务未提交或之后提交的数据。
具体实现：
• Read View：每个事务在开始时都会创建一个 Read View，记录当前活跃事务的 ID 列表。通过 Read View，事务可以判断哪些数据版本是可见的。
• Undo Log：MySQL 使用 Undo Log 来存储旧版本的数据。当事务需要读取数据时，如果当前版本不可见，MySQL 会通过 Undo Log 找到适合的旧版本。
• 版本链：每条记录都有一个指针，指向其历史版本（通过 Undo Log 实现）。事务通过遍历版本链找到符合自己 Read View 的版本。
示例：
假设事务 A 开始时，Read View 记录活跃事务为 [2, 3]。
• 如果事务 2 修改了某条记录，事务 A 会通过 Undo Log 找到事务 2 修改之前的版本。
• 如果事务 4 在事务 A 开始后修改了记录，事务 A 会忽略事务 4 的修改，因为事务 4 不在其 Read View 中。
2. 锁定机制
虽然 MVCC 可以实现读操作的并发控制，但写操作仍然需要锁定机制来避免冲突。
具体实现：
• 行锁：在可重复读隔离级别下，MySQL 会对修改的行加 排他锁（X Lock），防止其他事务同时修改同一行。
• 间隙锁（Gap Lock）：为了防止幻读，MySQL 会对查询范围内的间隙加锁。例如，如果查询 WHERE id BETWEEN 10 AND 20，MySQL 会对 10 到 20 之间的间隙加锁，防止其他事务插入新数据。
• Next-Key Lock：MySQL 结合行锁和间隙锁，形成 Next-Key Lock，锁定行和其前后的间隙，进一步防止幻读。
3. 可重复读的特点
• 避免脏读：事务只能读取已提交的数据版本。
• 避免不可重复读：事务在开始时创建一个 Read View，后续读取的数据版本不会改变。
• 部分避免幻读：通过间隙锁和 Next-Key Lock，MySQL 可以在大多数情况下防止幻读，但在某些特殊场景下（如全表扫描）仍可能出现幻读。
4. 示例
假设有以下数据表 users：
| id | name |
|---|---|
| 1 | Alice |
| 2 | Bob |
场景：
- 事务 A 开始，读取
id = 1的记录，得到name = Alice。 - 事务 B 开始，将
id = 1的name修改为Carol并提交。 - 事务 A 再次读取
id = 1的记录，仍然得到name = Alice，因为事务 A 只能看到事务开始时的数据版本。
5. 总结
• MVCC 是可重复读的核心机制，通过 Read View 和 Undo Log 实现数据版本的可见性控制。
• 锁定机制（行锁、间隙锁、Next-Key Lock）用于保证写操作的正确性，防止数据冲突和幻读。
• 可重复读隔离级别在大多数场景下可以保证事务的一致性和隔离性，但在极端情况下（如全表扫描）仍可能出现幻读。
通过 MVCC 和锁定机制的结合，MySQL 实现了高效且一致的可重复读隔离级别。
B+树有什么特点和好处？
B+树 是一种常用的平衡树数据结构，广泛应用于数据库和文件系统中，用于高效地存储和检索数据。它的设计目标是优化磁盘 I/O 操作，适合处理大规模数据。以下是 B+树的特点和好处：
特点
多路平衡树：
• B+树是一种多路平衡树，每个节点可以有多个子节点（通常远大于 2），从而减少树的高度。
• 树的高度越低，查找路径越短，检索效率越高。内部节点与叶子节点分离：
• 内部节点：只存储键值（key），用于导航。
• 叶子节点：存储键值和实际数据（或指向数据的指针），并且所有叶子节点通过链表连接，支持范围查询。所有数据存储在叶子节点：
• 数据只存储在叶子节点中，内部节点仅用于索引，这使得 B+树的查找路径长度一致，查找效率稳定。叶子节点链表：
• 所有叶子节点通过双向链表连接，支持高效的范围查询和顺序访问。平衡性：
• B+树通过分裂和合并操作保持平衡，确保树的高度始终维持在较低水平。
好处
高效的查找性能：
• 由于 B+树是多路平衡树，树的高度较低，查找时间复杂度为 (O(\log n))，适合处理大规模数据。
• 所有查找操作最终都会到达叶子节点，路径长度一致，性能稳定。适合磁盘存储：
• B+树的节点大小通常与磁盘块大小匹配，减少磁盘 I/O 次数。
• 一次磁盘读取可以加载一个节点（包含多个键值），提高数据访问效率。支持高效的范围查询：
• 叶子节点通过链表连接，支持高效的范围查询（如WHERE id BETWEEN 10 AND 20）。
• 顺序访问性能优异，适合遍历操作。支持高效的插入和删除：
• B+树通过分裂和合并操作保持平衡，插入和删除的时间复杂度为 (O(\log n))。
• 分裂和合并操作通常只影响局部节点，对整体性能影响较小。空间利用率高：
• B+树的节点可以存储多个键值，空间利用率较高，适合存储大规模数据。广泛的应用场景：
• 数据库索引（如 MySQL 的 InnoDB 引擎使用 B+树作为索引结构）。
• 文件系统（如 NTFS、ReiserFS 等）。
• 键值存储系统（如 LevelDB、RocksDB 等）。
B+树 vs B树
| 特性 | B+树 | B树 |
|---|---|---|
| 数据存储位置 | 仅叶子节点存储数据 | 所有节点都可以存储数据 |
| 叶子节点链表 | 支持，适合范围查询 | 不支持 |
| 查找性能 | 稳定，路径长度一致 | 不稳定，路径长度可能不一致 |
| 适合场景 | 数据库索引、文件系统 | 较少使用 |
总结
B+树的特点和好处使其成为数据库和文件系统中广泛使用的数据结构。它通过多路平衡、叶子节点链表、高效的范围查询和适合磁盘存储的设计，提供了高效的查找、插入、删除和范围查询性能，特别适合处理大规模数据和高并发场景。
聚簇索引和非聚簇索引区别？
聚簇索引（Clustered Index） 和 非聚簇索引（Non-Clustered Index） 是数据库中两种常见的索引类型，它们在存储方式和查询性能上有显著区别。以下是它们的详细对比：
1. 定义
• 聚簇索引：
• 聚簇索引决定了表中数据的物理存储顺序。一张表只能有一个聚簇索引，因为数据只能按照一种方式物理排序。
• 在聚簇索引中，索引的叶子节点直接存储数据行。
• 非聚簇索引：
• 非聚簇索引是独立于数据存储的索引结构，它的叶子节点存储的是指向数据行的指针（或主键值）。
• 一张表可以有多个非聚簇索引。
2. 存储方式
• 聚簇索引：
• 数据行按照聚簇索引的键值顺序存储。
• 索引的叶子节点就是数据页，存储实际的数据行。
• 非聚簇索引：
• 数据行的存储顺序与索引无关。
• 索引的叶子节点存储的是指向数据行的指针（或主键值），而不是数据本身。
3. 性能
• 聚簇索引：
• 优点：
◦ 范围查询性能高，因为数据物理上连续存储。
◦ 对于主键查询，性能非常高，因为数据直接存储在索引的叶子节点。
• 缺点：
◦ 插入、更新、删除操作可能导致数据重新排序，性能开销较大。
• 非聚簇索引：
• 优点：
◦ 适合频繁更新的列，因为数据行的物理存储顺序不受影响。
◦ 一张表可以有多个非聚簇索引，适合多条件查询。
• 缺点：
◦ 查询时需要先查找索引，再通过指针访问数据行，增加了 I/O 操作。
◦ 范围查询性能不如聚簇索引。
4. 适用场景
• 聚簇索引：
• 适合用于主键或唯一性约束的列。
• 适合范围查询（如 WHERE id BETWEEN 10 AND 20）。
• 适合数据相对静态的场景（如日志表、历史数据表）。
• 非聚簇索引：
• 适合用于经常查询但更新较少的列。
• 适合多条件查询（如 WHERE name = 'Alice' AND age = 30）。
• 适合需要多个索引的场景。
5. 示例
假设有一张表 users，结构如下：
| id | name | age |
|---|---|---|
| 1 | Alice | 25 |
| 2 | Bob | 30 |
| 3 | Carol | 28 |
聚簇索引：
• 如果 id 是聚簇索引，数据会按照 id 的顺序物理存储：
数据页 1: (1, Alice, 25)
数据页 2: (2, Bob, 30)
数据页 3: (3, Carol, 28)
非聚簇索引：
• 如果 name 是非聚簇索引，索引的叶子节点存储的是指向数据行的指针：
索引页: (Alice -> 数据页 1)
(Bob -> 数据页 2)
(Carol -> 数据页 3)
6. 总结
| 特性 | 聚簇索引 | 非聚簇索引 |
|---|---|---|
| 数据存储顺序 | 按索引键值顺序存储 | 数据存储顺序与索引无关 |
| 叶子节点存储内容 | 实际数据行 | 指向数据行的指针（或主键值） |
| 索引数量 | 一张表只能有一个 | 一张表可以有多个 |
| 范围查询性能 | 高 | 低 |
| 插入/更新/删除性能 | 低（可能导致数据重排序） | 高（不影响数据物理存储顺序） |
| 适用场景 | 主键、范围查询、静态数据 | 多条件查询、频繁更新的列 |
聚簇索引和非聚簇索引各有优缺点，应根据具体场景选择合适的索引类型。通常情况下，主键使用聚簇索引，其他列使用非聚簇索引。
char占几个字节(基本数据类型和包装类)
在 Java 中，基本数据类型（Primitive Data Types） 和 包装类（Wrapper Classes） 是两种不同的数据类型，它们在存储方式、使用场景和功能上有显著区别。以下是它们的详细对比：
1. 基本数据类型
基本数据类型是 Java 中最基础的数据类型，它们是原始值，直接存储在栈内存中。Java 提供了 8 种基本数据类型：
| 数据类型 | 大小（字节） | 默认值 | 取值范围 |
|---|---|---|---|
byte |
1 | 0 | -128 到 127 |
short |
2 | 0 | -32,768 到 32,767 |
int |
4 | 0 | -2^31 到 2^31-1 |
long |
8 | 0L | -2^63 到 2^63-1 |
float |
4 | 0.0f | 单精度浮点数 |
double |
8 | 0.0d | 双精度浮点数 |
char |
2 | ‘\u0000’ | 0 到 65,535（Unicode 字符） |
boolean |
1 | false | true 或 false |
特点：
• 存储方式：直接存储在栈内存中，效率高。
• 性能：由于是原始值，操作速度快，内存占用少。
• 功能限制：不支持面向对象的特性（如方法调用、继承等）。
2. 包装类
包装类是对基本数据类型的封装，它们是类，存储在堆内存中。每个基本数据类型都有对应的包装类：
| 基本数据类型 | 包装类 |
|---|---|
byte |
Byte |
short |
Short |
int |
Integer |
long |
Long |
float |
Float |
double |
Double |
char |
Character |
boolean |
Boolean |
特点：
• 存储方式：作为对象存储在堆内存中，栈内存中存储对象的引用。
• 功能：支持面向对象的特性（如方法调用、继承等），并提供了一些实用方法（如 Integer.parseInt()）。
• 自动装箱与拆箱：Java 支持自动装箱（将基本数据类型转换为包装类）和自动拆箱（将包装类转换为基本数据类型）。
Integer num = 10; // 自动装箱
int value = num; // 自动拆箱
• 性能：由于是对象，操作速度较慢，内存占用较多。
3. 对比
| 特性 | 基本数据类型 | 包装类 |
|---|---|---|
| 存储方式 | 栈内存 | 堆内存 |
| 内存占用 | 较少 | 较多 |
| 性能 | 高 | 低 |
| 默认值 | 有默认值（如 int 默认是 0） |
默认是 null |
| 功能 | 不支持面向对象特性 | 支持面向对象特性，提供实用方法 |
| 适用场景 | 性能要求高的场景 | 需要面向对象特性或集合类的场景 |
4. 使用场景
• 基本数据类型：
• 适合性能要求高的场景，如循环、计算等。
• 适合存储简单的数值或布尔值。
• 包装类：
• 适合需要面向对象特性的场景，如集合类（List、Set、Map 等）只能存储对象。
• 适合需要实用方法的场景，如字符串转换、类型检查等。
5. 示例
// 基本数据类型 |
6. 总结
• 基本数据类型：效率高，适合性能要求高的场景。
• 包装类：功能丰富，适合需要面向对象特性或集合类的场景。
• 在 Java 5 之后，自动装箱和拆箱机制使得基本数据类型和包装类之间的转换更加方便。开发者应根据具体需求选择合适的数据类型。
java内存结构
Java 内存结构是 Java 虚拟机（JVM）在运行 Java 程序时管理内存的方式。它主要分为以下几个部分：
1. 程序计数器（Program Counter Register）
• 作用：记录当前线程正在执行的字节码指令的地址。
• 特点：
• 每个线程独立拥有一个程序计数器。
• 如果执行的是 Java 方法，计数器记录的是字节码指令地址；如果执行的是本地方法（Native Method），计数器值为空（Undefined）。
• 生命周期：与线程的生命周期一致。
2. Java 虚拟机栈（Java Virtual Machine Stack）
• 作用：用于存储方法调用的栈帧（Stack Frame），包括局部变量表、操作数栈、动态链接和方法返回地址。
• 特点：
• 每个线程独立拥有一个栈。
• 栈帧是方法调用的基本单位，每个方法调用都会创建一个栈帧。
• 栈的大小可以通过 JVM 参数 -Xss 设置。
• 常见异常：
• StackOverflowError：栈深度超出限制（如递归调用过深）。
• OutOfMemoryError：栈无法分配更多内存。
3. 本地方法栈（Native Method Stack）
• 作用：用于支持本地方法（Native Method）的执行。
• 特点：
• 与 Java 虚拟机栈类似，但服务于本地方法。
• 本地方法是用其他语言（如 C/C++）编写的方法。
• 常见异常：与 Java 虚拟机栈相同。
4. Java 堆（Java Heap）
• 作用：用于存储对象实例和数组，是垃圾回收的主要区域。
• 特点：
• 所有线程共享 Java 堆。
• 堆的大小可以通过 JVM 参数 -Xms（初始大小）和 -Xmx（最大大小）设置。
• 堆可以进一步划分为新生代（Young Generation）和老年代（Old Generation），新生代又分为 Eden 区、Survivor 区（From 和 To）。
• 常见异常：
• OutOfMemoryError：堆内存不足，无法分配更多对象。
5. 方法区（Method Area）
• 作用：用于存储类信息、常量、静态变量、即时编译器编译后的代码等。
• 特点：
• 所有线程共享方法区。
• 方法区是堆的逻辑部分，但在某些 JVM 实现中（如 HotSpot），方法区被称为“永久代”（PermGen）或“元空间”（Metaspace）。
• 元空间的大小可以通过 JVM 参数 -XX:MetaspaceSize 和 -XX:MaxMetaspaceSize 设置。
• 常见异常：
• OutOfMemoryError：方法区内存不足，无法加载更多类。
6. 运行时常量池（Runtime Constant Pool）
• 作用：用于存储类文件中的常量池信息，包括字符串常量、类和接口的全限定名、字段和方法的名称和描述符等。
• 特点：
• 运行时常量池是方法区的一部分。
• 在类加载后，常量池中的符号引用会被解析为直接引用。
• 常见异常：
• OutOfMemoryError：常量池内存不足。
7. 直接内存（Direct Memory）
• 作用：用于支持 NIO（New I/O）操作，直接分配在堆外内存中。
• 特点：
• 直接内存不受 Java 堆大小限制，但受操作系统内存限制。
• 直接内存的分配和释放通过 ByteBuffer.allocateDirect() 和 Unsafe 类实现。
• 常见异常：
• OutOfMemoryError：直接内存不足。
总结
Java 内存结构是 JVM 管理内存的核心部分，主要包括以下区域：
- 程序计数器：记录线程执行位置。
- Java 虚拟机栈：存储方法调用的栈帧。
- 本地方法栈：支持本地方法执行。
- Java 堆：存储对象实例和数组。
- 方法区：存储类信息、常量、静态变量等。
- 运行时常量池：存储类文件中的常量池信息。
- 直接内存：支持 NIO 操作，分配在堆外内存。
每个区域都有其特定的作用和生命周期，理解这些区域有助于优化 Java 程序的性能和内存使用。
mysql中having关键字的用法（类似关键字）
在 MySQL 中，HAVING 关键字用于对分组后的结果进行过滤，通常与 GROUP BY 一起使用。它的作用类似于 WHERE，但 WHERE 是在分组前过滤数据，而 HAVING 是在分组后过滤数据。
HAVING 关键字的用法
语法：
SELECT column1, column2, aggregate_function(column3) |
示例：
假设有一张 orders 表，记录订单信息：
| order_id | customer_id | amount |
|---|---|---|
| 1 | 101 | 100 |
| 2 | 102 | 200 |
| 3 | 101 | 150 |
| 4 | 103 | 300 |
| 5 | 102 | 250 |
查询每个客户的总消费金额，并筛选出总金额大于 200 的客户：
SELECT customer_id, SUM(amount) AS total_amount |
结果：
| customer_id | total_amount |
|---|---|
| 102 | 450 |
| 103 | 300 |
HAVING 和 WHERE 的区别
| 关键字 | 作用阶段 | 适用对象 | 能否使用聚合函数 |
|---|---|---|---|
WHERE |
分组前过滤数据 | 单行数据 | 不能 |
HAVING |
分组后过滤数据 | 分组后的结果集 | 能 |
示例：
查询订单金额大于 150 的客户，并统计其总消费金额：
SELECT customer_id, SUM(amount) AS total_amount |
其他类似关键字
WHERE：
• 用于在查询中过滤行数据。
• 示例：SELECT * FROM orders WHERE amount > 150;
GROUP BY：
• 用于将数据按指定列分组，通常与聚合函数（如SUM、COUNT、AVG等）一起使用。
• 示例：SELECT customer_id, SUM(amount) AS total_amount
FROM orders
GROUP BY customer_id;ORDER BY：
• 用于对查询结果进行排序。
• 示例：SELECT * FROM orders ORDER BY amount DESC;
LIMIT：
• 用于限制查询结果的行数。
• 示例：SELECT * FROM orders LIMIT 5;
DISTINCT：
• 用于去除查询结果中的重复行。
• 示例：SELECT DISTINCT customer_id FROM orders;
综合示例
查询每个客户的总消费金额，筛选出总金额大于 200 的客户，并按总金额降序排序：
SELECT customer_id, SUM(amount) AS total_amount |
总结
• HAVING 用于对分组后的结果进行过滤，通常与 GROUP BY 和聚合函数一起使用。
• HAVING 和 WHERE 的区别在于作用阶段和适用对象。
• 其他类似关键字包括 WHERE、GROUP BY、ORDER BY、LIMIT 和 DISTINCT，它们分别用于过滤、分组、排序、限制行数和去重。
线程同步有哪些实现方式
线程同步是多线程编程中确保多个线程安全访问共享资源的关键技术。以下是常见的线程同步实现方式：
1. synchronized 关键字
• 作用：通过锁定对象或方法，确保同一时间只有一个线程可以访问共享资源。
• 实现方式：
• 修饰实例方法：锁定当前实例对象。
public synchronized void method() {
// 线程安全代码
}
• 修饰静态方法：锁定当前类的 Class 对象。
public static synchronized void method() {
// 线程安全代码
}
• 修饰代码块：锁定指定对象。
public void method() {
synchronized (this) {
// 线程安全代码
}
}
2. ReentrantLock
• 作用：显式锁，提供比 synchronized 更灵活的锁定机制。
• 实现方式：
import java.util.concurrent.locks.ReentrantLock;
public class Example {
private final ReentrantLock lock = new ReentrantLock();
public void method() {
lock.lock(); // 加锁
try {
// 线程安全代码
} finally {
lock.unlock(); // 释放锁
}
}
}
3. volatile 关键字
• 作用：确保变量的可见性，但不保证原子性。
• 实现方式：
public class Example {
private volatile boolean flag = false;
public void setFlag() {
flag = true;
}
public boolean getFlag() {
return flag;
}
}
4. 原子类（java.util.concurrent.atomic 包）
• 作用：通过 CAS（Compare-And-Swap）操作实现无锁线程安全。
• 实现方式：
import java.util.concurrent.atomic.AtomicInteger;
public class Example {
private AtomicInteger counter = new AtomicInteger(0);
public void increment() {
counter.incrementAndGet();
}
}
5. CountDownLatch
• 作用：允许一个或多个线程等待其他线程完成操作。
• 实现方式：
import java.util.concurrent.CountDownLatch;
public class Example {
public static void main(String[] args) throws InterruptedException {
CountDownLatch latch = new CountDownLatch(3);
for (int i = 0; i < 3; i++) {
new Thread(() -> {
// 执行任务
latch.countDown();
}).start();
}
latch.await(); // 等待所有线程完成任务
System.out.println("All tasks completed.");
}
}
6. CyclicBarrier
• 作用：让一组线程互相等待，直到所有线程都到达某个屏障点。
• 实现方式：
import java.util.concurrent.CyclicBarrier;
public class Example {
public static void main(String[] args) {
CyclicBarrier barrier = new CyclicBarrier(3, () -> {
System.out.println("All threads reached the barrier.");
});
for (int i = 0; i < 3; i++) {
new Thread(() -> {
try {
// 执行任务
barrier.await();
} catch (Exception e) {
e.printStackTrace();
}
}).start();
}
}
}
7. Semaphore
• 作用：控制同时访问某个资源的线程数量。
• 实现方式：
import java.util.concurrent.Semaphore;
public class Example {
private final Semaphore semaphore = new Semaphore(3); // 允许最多 3 个线程同时访问
public void method() throws InterruptedException {
semaphore.acquire(); // 获取许可
try {
// 线程安全代码
} finally {
semaphore.release(); // 释放许可
}
}
}
8. BlockingQueue
• 作用：实现生产者-消费者模型，线程安全地管理任务队列。
• 实现方式：
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
public class Example {
public static void main(String[] args) {
BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(10);
// 生产者线程
new Thread(() -> {
try {
queue.put(1); // 添加任务
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
// 消费者线程
new Thread(() -> {
try {
int task = queue.take(); // 获取任务
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
}
9. ThreadLocal
• 作用：为每个线程提供独立的变量副本，避免线程间共享变量。
• 实现方式：
public class Example {
private static final ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 0);
public void method() {
threadLocal.set(threadLocal.get() + 1); // 修改线程局部变量
System.out.println(threadLocal.get());
}
}
总结
线程同步的实现方式包括：
- **
synchronized**：内置锁，简单易用。 - **
ReentrantLock**：显式锁，功能更强大。 - **
volatile**：保证可见性，不保证原子性。 - 原子类：无锁线程安全，适合简单操作。
- **
CountDownLatch**：等待多个线程完成任务。 - **
CyclicBarrier**：线程互相等待，到达屏障点。 - **
Semaphore**：控制并发访问数量。 - **
BlockingQueue**：实现生产者-消费者模型。 - **
ThreadLocal**：为每个线程提供独立变量副本。
根据具体场景选择合适的同步方式，可以有效解决多线程并发问题。
