学习很潮很流行的Java以及相关框架.

简介 - Java教程 - 廖雪峰的官方网站

Java基础

Java基础

1. java.lang.*

这是默认导入的包，包含基本类和接口。

• Object：所有类的超类。
• String：不可变字符串类，用于文本处理。
• StringBuilder/StringBuffer：可变字符串类，适用于频繁修改字符串的场景。StringBuffer是线程安全的版本。
• System：提供系统相关的信息和操作，如System.out.println()打印输出。
• Math：提供数学计算的方法，如三角函数、对数等。
• Integer, Double 等包装类：基本类型的对象表示形式，支持自动装箱/拆箱。

2. java.util.*

包含了集合框架、日期时间工具、随机数生成器等实用工具类。

• Collection 接口及其实现类（如ArrayList, LinkedList, HashSet, TreeSet等）：提供了不同类型的集合实现。
• Map 接口及其实现类（如HashMap, TreeMap等）：键值对存储结构。
• Iterator：遍历集合的标准方式。
• Date, Calendar, LocalDate, LocalDateTime（Java 8+）：处理日期和时间。
• Random：生成伪随机数。
• Arrays：提供操作数组的各种静态方法。

函数式编程(function)包提供了一些功能接口

• Function<T, R>：接受一个参数并返回结果。

• Predicate<T>：接受一个输入参数并返回布尔值。方法签名：`boolean test(T t)``

• `BiFunction<T, U, R>：接受两个输入参数并返回结果。方法签名：R apply(T t, U u)

• UnaryOperator<T> ：接受一个参数并返回相同类型的值，是 Function<T, T> 的特化形式。 方法签名：T apply(T t)

• BinaryOperator<T>：接受两个相同类型的参数并返回相同类型的值，是 BiFunction<T, T, T> 的特化形式。 方法签名：`T apply(T t, T u)```

• BiPredicate<T, U>：接受两个输入参数并返回布尔值。方法签名：boolean test(T t, U u),用于需要基于两个输入值进行条件判断的场景

• Supplier<T>：适用于你需要从无到有地“生产”数据的场合。它不接收任何参数，但是可以返回你所需要的类型的实例。这使得它非常适合用于延迟初始化、配置加载等场景。

• BiConsumer<T, U>：当你需要处理或操作一对相关的值，并且这些操作的结果并不重要（即不需要返回值）时非常有用。比如，你可能想要记录一组键值对的日志，或者将两个值合并在一起而不关心最终结果。

3. java.io.*

提供输入输出流的支持，用于读写文件或进行网络通信。

• InputStream/OutputStream：字节流基类。
• Reader/Writer：字符流基类。
• File：文件或目录路径名的抽象表示形式。
• BufferedReader/BufferedWriter, BufferedInputStream/BufferedOutputStream：提高I/O效率的缓冲类。

4. java.nio.*

新的I/O API，提供了更高效的非阻塞I/O操作。

• Path, Paths：用于处理文件系统路径。
• Files：提供对文件的操作方法。
• ByteBuffer及其他缓冲区类型：用于高效地管理字节序列。

5. java.net.*

网络编程相关的API。

• URL, URI：统一资源定位符/标识符。
• URLConnection：与URL建立连接。
• Socket, ServerSocket：TCP/IP套接字编程的基础类。
• DatagramPacket, DatagramSocket：UDP协议的支持。

6. java.text.*

用于格式化和解析文本。

• NumberFormat, DecimalFormat：数字格式化。
• DateFormat, SimpleDateFormat：日期格式化。
• MessageFormat：根据模式格式化消息。

7. java.time.*

Java 8引入的新日期时间API。

• Instant：表示时间线上的一点。
• LocalDate, LocalTime, LocalDateTime：分别表示不带时区的日期、时间和日期时间。
• ZonedDateTime, OffsetDateTime：带有时区信息的日期时间。

8. 并发相关

• Thread：创建和控制线程。
• Runnable：线程执行的目标接口。
• ExecutorService, Executors：更高级别的线程管理。
• Lock, ReentrantLock：比同步块更灵活的锁定机制。
• ConcurrentHashMap：线程安全的哈希表实现。

9. 其他

• Optional（Java 8+）：避免空指针异常的一种设计模式。
• Stream API（Java 8+）：提供了一种高效且易于使用的集合元素处理方式。

内部类

成员内部类,静态内部类,局部内部类,匿名内部类

1
2
3
4
5
6
7
8
9
10
11
12

// 成员内部类
class outerclass {
    private String name;
    private static String age;
    public class innerclass {
        void display() {
            System.out.println("This is an inner class");
            System.out.println(name);
            System.out.println(age);
        }
    }
}

1
2
3
4
5
6
7

public static class innercls {
    void display() {
        System.out.println("This is an inner class");
        System.out.println(innercls.this);
        System.out.println(age);
    }
}

集合Collection与Map

数组和集合的区别：

数组

• 固定大小：数组一旦创建，其大小是固定的，不能动态增加或减少元素。

• 类型安全：数组可以是基本数据类型（如 int[], double[]）或对象类型（如 String[]）。对于对象类型的数组，所有元素都必须是该类的实例或者 null。

• 内存连续：数组中的元素在内存中是连续存储的，这使得访问速度非常快，因为可以通过计算偏移量直接访问任何元素（时间复杂度为 O(1)）。

• 声明方式

  1 2	int[] numbers = new int[5]; // 创建一个包含5个整数的数组 String[] names = {"Alice", "Bob"}; // 初始化时赋值

优点

• 访问速度快，支持随机访问。
• 对于小规模、固定数量的数据集非常适合。

List

定义与特性

• 动态大小：List 接口的主要实现类（如 ArrayList, LinkedList）允许动态添加和删除元素，这意味着你可以根据需要扩展或缩小列表的大小。

• 接口与实现：List 是一个接口，常用的实现包括 ArrayList 和 LinkedList。ArrayList 底层基于数组实现，而 LinkedList 则是一个双向链表。

• 类型安全：List 只能存储对象，不能直接存储基本数据类型（但可以使用自动装箱/拆箱功能处理基本数据类型）。

• 声明方式

  1 2 3

  List<String> names = new ArrayList<>(); names.add("Alice"); names.add("Bob");

优点

• 动态大小，方便添加和删除元素。
• 提供了丰富的操作方法，比如 add(), remove(), get(), indexOf() 等等。
• 更好的抽象层次，代码更加灵活易读。

缺点

• 相比于数组，某些操作可能效率较低，例如在 ArrayList 中插入或删除中间位置的元素会导致其他元素移动；而在 LinkedList 中查找元素则需要从头或尾遍历整个列表。

ArrayList使用数组实现,查询快,增删慢

LinkedList使用双向链表实现,查询慢,增删快,尤其对于首尾操作

Set

HashSet使用哈希表实现,增删改查性能较好

HashSet去重主要依赖于两个关键方法：hashCode() 和 equals()。

1. hashCode() 方法：
   • 当你尝试将一个对象添加到 HashSet 中时，HashSet 会首先调用这个对象的 hashCode() 方法来计算该对象的哈希值。
   • 这个哈希值决定了对象在内部哈希表中的存储位置（即所谓的“桶”）。
2. equals() 方法：
   • 如果两个对象有相同的哈希值（或者它们被分配到了同一个桶中），HashSet 将使用 equals() 方法来进一步检查这两个对象是否真正相等。
   • 如果 equals() 返回 true，则认为这两个对象是重复的，新对象不会被添加到集合中。如果 equals() 返回 false，即使哈希值相同，这两个对象也被认为是不同的，并且都会被添加到集合中。

对于自定义类的对象，如果你希望它们能够正确地在 HashSet 中进行去重，你需要重写 hashCode() 和 equals() 方法，以确保具有相同业务含义的对象返回相同的哈希码并且 equals() 方法也返回 true。

TreeSet底层基于红黑树,可排序,不重复,无索引

Map

Map的遍历方式

使用 for-each 循环和 entrySet()

这是最常用的遍历方式之一，因为它提供了对键和值的访问。

1
2
3

for (Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

使用迭代器

使用迭代器可以更灵活地控制遍历过程。

1
2
3
4
5

Iterator<Map.Entry<String, Integer>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
    Map.Entry<String, Integer> entry = iterator.next();
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

使用 Java 8 的 Stream API

通过 stream() 方法可以利用 Stream API 来遍历或进行其他操作。

1
2
3

map.entrySet().stream().forEach(entry -> 
    System.out.println(entry.getKey() + ": " + entry.getValue())
);

或者对于某些特定的操作，比如过滤、映射等：

1
2
3

map.entrySet().stream()
   .filter(entry -> entry.getValue() > 1)
   .forEach(entry -> System.out.println(entry.getKey()));

Stream流包括中间方法和最终方法,中间方法使用filter,map,调用完成后会返回新的流

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

List<String> alist = new ArrayList<>();
alist.add("a");
alist.add("b");
List<String> list = alist.stream().map((String a) -> a + "a").toList();
List<Double> blist = new ArrayList<>();
list.stream().filter(s-> !s.isEmpty()).forEach(System.out::println);

list.stream().sorted(Comparator.comparingDouble(String::length).reversed()).forEach(System.out::println);
blist.stream().sorted(Double::compare).forEach(System.out::println);

// 去重 limit只需要一个参数 skip跳过前几个
blist.stream().distinct().skip(1).limit(2).forEach(System.out::println);

// 转换成map
list.stream().collect(Collectors.toMap(Function.identity(), String::length)).forEach((k, v) -> System.out.println(k + ":" + v));

Stream<String> a = Stream.of("a", "b", "c");
Stream<Integer> integerStream = Stream.of(1, 2);
// 合并两个流
Stream.concat(a, integerStream).forEach(System.out::println);

java集合类->实现的数据结构

Collections List Set HashSet LinkedHashSet TreeSet

Map

HashMap LinkedHashMap TreeMap

HashMap

• 底层实现： JDK 8 之前是数组 + 链表；JDK 8 及之后是数组 + 链表/红黑树。当链表长度超过阈值（默认为 8）时，链表会转换为红黑树，以提高查找效率（从 O(N) 优化到 O(log N)）。
• 特点：
  • 非线程安全： 在多线程环境下，如果不进行同步处理，可能出现数据不一致或死循环（早期版本）等问题。
  • 允许键和值为 null： 最多允许一个键为 null，允许多个值为 null。
  • 无序性： 不保证元素的迭代顺序。
  • 性能： 增删查的平均时间复杂度为 O(1)。
• 适用场景： 单线程环境或需要高性能的非线程安全哈希表场景。

Hashtable(线程安全)

Hashtable

• 底层实现： 也是基于数组 + 链表。
• 特点：
  • 线程安全： 所有公共方法都使用了 synchronized 关键字进行同步，因此是线程安全的。
  • 不允许键和值为 null： 如果尝试插入 null 键或 null 值，会抛出 NullPointerException。
  • 性能： 由于同步开销，性能比 HashMap 低。

ArrayList与LinkedList区别

动态数组 连续内存 查询O(1) 增删需要移动元素O(N)

双向链表 查询O(N) 首位增删O(1)

HashMap原理,如何扩容

数组+链表/红黑树 插入元素时进行哈希,使用链地址法解决哈希冲突

当 HashMap 中的元素数量 size 达到 capacity * loadFactor 时，HashMap 就会进行扩容操作。这个过程在 resize() 方法中实现。

扩容流程：

1. 创建新数组：
   • HashMap 会创建一个新的 Node 数组，其容量是原数组的两倍。例如，如果原容量是 16，新容量就是 32。
2. 数据迁移（Rehash）：
   • 这是扩容中最耗时的一步。HashMap 会遍历原数组中的每一个桶。
   • 对于每个桶中的链表或红黑树，会将其中的所有 Node 元素重新计算哈希值和在新数组中的索引位置，然后移动到新数组中对应的桶里。

为什么是两倍扩容？为什么是 2 的幂次方？

• 两倍扩容： 使得 capacity 始终保持为 2 的幂次方，这对于通过位运算 hash & (capacity - 1) 来快速计算索引至关重要。如果 capacity 不是 2 的幂次方，那么 hash % capacity 的性能会降低，并且哈希值分布可能不均匀，增加冲突。
• 计算索引的优化： 当容量从 N 扩容到 2N 时，一个键在旧数组中的索引是 hash & (N - 1)。在新数组中，它的索引是 hash & (2N - 1)。
  • 对于每个 Node，它的新的索引位置要么和旧索引相同，要么是旧索引 + N。
  • 这个判断依据是 (hash & N) 是否为 0。如果为 0，则新索引不变；如果不为 0，则新索引是旧索引 + N。
  • 这种设计避免了对每个元素重新进行复杂的取模运算，显著提高了数据迁移的效率。

在 JDK 8 中，resize 过程也进行了优化，它不再需要重新计算每个元素的哈希值，而是利用了容量是 2 的幂次方的特性。

当容量从 N 变为 2N 时，对于一个节点 e，它的新索引只会有两种情况：e.hash & (N-1) (即原位置) 或者 e.hash & (N-1) + N (即原位置 + N)。 这个判断可以简化为查看 e.hash 的第 N 位（即 (hash & N)）是 0 还是 1。

• 如果 (hash & N) == 0，则节点仍在原索引位置。
• 如果 (hash & N) != 0，则节点会移动到 原索引 + N 的位置。

这样，在扩容时，每个桶的链表（或红黑树）可以被分成两条链表（或红黑树），一条留在原位置，另一条移动到新位置（原位置 + N），从而大大提高了数据迁移的效率，避免了逐个重新哈希。

红黑树 ->B,B+树区别

红黑树是一种自平衡的二叉查找树（Binary Search Tree, BST）。它通过给节点着色（红色或黑色）并遵循一系列规则来保证树的平衡，确保任何路径从根节点到叶子节点的最长路径不会超过最短路径的两倍，从而使所有操作的时间复杂度保持在 O(logN)。

平衡通过颜色和旋转： 通过节点的颜色（红/黑）属性和插入/删除时的旋转（Rotations）和重新着色（Recoloring）操作来维持近似平衡。

所有数据都在节点中： 每个节点都存储着实际的键值对。

高度： 树的高度相对较小，但比 AVL 树（另一种平衡二叉树）可能略高，但其插入和删除的平均性能更好。

B 树 (B-Tree)

• 基本概念： B 树是一种多路平衡查找树。与二叉树不同，B 树的每个节点可以有多个子节点（通常多于两个）。它的设计核心是为了优化磁盘 I/O 操作，因为磁盘读写是块（block）为单位的，B 树通过增加节点的分支数（阶数）来降低树的高度，从而减少磁盘访问次数。
• 核心特性：
  1. 多路（M 阶树）： 每个节点可以有 M 个子节点（M > 2），并包含 M-1 个键。
  2. 节点内有序： 每个节点中的键值是排序的。
  3. 节点内存储数据： 非叶子节点和叶子节点都可以存储实际的键值数据（或指向数据的指针）。
  4. 所有叶子节点在同一层： 这保证了从根到任何叶子节点的查找路径长度相同，因此查找效率稳定。
  5. 为磁盘优化： 节点的大小通常被设计为与磁盘块大小相匹配，一次磁盘 I/O 可以读取更多的键。
• 典型应用场景：
  • 文件系统和数据库索引： B 树被广泛应用于文件系统（如 NTFS, HFS+）和某些数据库系统（如 MongoDB）的索引结构。
  • 数据量大，无法完全加载到内存： 当数据存储在磁盘等外部存储介质上，且需要最小化磁盘 I/O 次数时，B 树是理想选择。

3. B+ 树 (B+ Tree)

• 基本概念： B+ 树是 B 树的一种变体，它对 B 树进行了进一步的优化，使其更适合于数据库索引和文件系统。B+ 树的核心特点是所有的数据都存储在叶子节点，并且叶子节点之间通过链表连接。

• 核心特性：

  1. 多路（M 阶树）： 与 B 树类似，每个节点可以有 M 个子节点。
  2. 非叶子节点只存储键（索引）： 非叶子节点（内部节点）只存储键（或索引），不存储实际的键值数据。这使得每个非叶子节点可以存储更多的键，从而降低树的高度，进一步减少磁盘 I/O。
  3. 所有数据都在叶子节点： 所有的实际键值数据（或指向数据的指针）都存储在叶子节点中。
  4. 叶子节点通过链表连接： 所有叶子节点构成一个有序的链表。
  5. 所有键都在叶子节点出现： 即使是存在于非叶子节点中的键，也会在叶子节点中再次出现。

• 典型应用场景：

  • 关系型数据库索引（如 MySQL 的 InnoDB 存储引擎）： 这是 B+ 树最主要的应用场景。
  • 需要高效的范围查询和全表扫描： 由于叶子节点通过链表连接且包含所有数据，范围查询变得非常高效，只需找到起始叶子节点，然后沿着链表遍历即可。全表扫描也只需遍历叶子节点链表。

  红黑树、B 树、B+ 树的主要区别总结

  | 特性 | 红黑树 (Red-Black Tree) | B 树 (B-Tree) | B+ 树 (B+ Tree) |
  | ——————— | —————————————————————————————— | ———————————————————————- | —————————————————————————————— |
  | 结构类型 | 二叉查找树 (每个节点最多 2 个子节点) | 多路查找树 (每个节点可以有 M 个子节点) | 多路查找树 (B 树的变体，每个节点可以有 M 个子节点) |
  | 平衡方式 | 节点着色 (红/黑) + 旋转 + 重新着色 | 节点分裂/合并 (所有叶子节点在同一层) | 节点分裂/合并 (所有叶子节点在同一层) |
  | 数据存储 | 所有节点都存储键值对 | 非叶子节点和叶子节点都可能存储键值数据 | 只有叶子节点存储键值数据，非叶子节点只存储键（索引） |
  | 查询路径 | 从根到目标节点的路径长度可能不同 (近似平衡) | 从根到任何键的路径长度相同 (所有叶子在同一层) | 所有查找必须达到叶子节点，路径长度相同，查询效率稳定 |
  | 范围查询 | 效率相对较低，需要中序遍历 | 效率一般，需要进行多节点的中序遍历 | 效率高，所有叶子节点通过链表连接，可顺序遍历 |
  | 磁盘 I/O | 针对内存设计，不考虑磁盘 I/O 优化，树高较高，可能导致多次 I/O | 为磁盘优化，降低树高，减少 I/O 次数 | 进一步优化磁盘 I/O，非叶子节点只存索引，可装更多键，树更矮胖，且范围查询更高效 |
  | 典型应用 | 内存中的集合 (TreeMap, std::map) | 文件系统 (部分)、一些 NoSQL 数据库 (如 MongoDB) | 关系型数据库索引 (如 MySQL 的 InnoDB), 文件系统 |
  | 父节点冗余 | 无 | 有 (键可能出现在父节点和其子节点中) | 有 (非叶子节点的键也会出现在其子节点中，最终在叶子节点中) |

如果你主要处理内存中的数据，且需要高效的单点查找、插入和删除（且对范围查询不那么敏感），红黑树通常是更好的选择，因为它实现相对简单，且在内存中性能优异。

如果你处理大量数据，需要存储在磁盘上，并且要最小化磁盘 I/O 次数，B 树是一个好的选择。

如果你处理的是数据库索引或需要频繁进行范围查询的场景，B+ 树无疑是最佳选择，因为它通过将所有数据集中在叶子节点并用链表连接，极大地优化了范围查找和全表扫描的性能。

concurrentHashMap实现 JDK7 分段锁 JDK8+ CAS+synchronized+Node

JDK 8 对 ConcurrentHashMap 进行了彻底的重构，放弃了分段锁的设计，转而采用 CAS（Compare-And-Swap）+ synchronized + 红黑树 的混合策略。

核心思想：

取消 Segment 概念： JDK 8 中不再有 Segment 类。取而代之的是一个由 Node 数组组成的哈希表。

1. 锁的粒度：
   • 读操作： 大部分读操作仍然是无锁的，通过 volatile 和 final 关键字保证可见性。
   • 写操作： 写操作（put、remove）只锁定发生冲突的哈希桶的头节点（Node）。当多个线程操作不同的哈希桶时，它们之间不会互相阻塞，实现了更高的并发度。
   • synchronized 代替 ReentrantLock： JDK 8 使用 synchronized 关键字替代了 ReentrantLock。这是因为 JDK 8 对 synchronized 关键字进行了大量优化，使其性能已经非常接近甚至超越了 ReentrantLock，并且代码实现更为简洁。
2. 链表转红黑树： 与 HashMap 类似，当链表长度超过阈值（默认为 8）时，链表会转换为红黑树，以提高查找效率（从 O(N) 优化到 O(log N)）。这在哈希冲突严重时能有效避免性能下降。
3. CAS 操作： 在进行一些非阻塞操作（如扩容时的迁移、size 统计）时，会利用 CAS 操作来保证原子性。例如，在修改 size 变量时，会使用 CAS 操作。

ConcurrentHashMap 在 JDK 7 中的实现 (分段锁 Segment)

在 JDK 7 中，ConcurrentHashMap 主要通过分段锁（Segment）的机制来实现高并发。

核心思想：

1. 分段（Segmentation）： 整个 ConcurrentHashMap 被分成若干个独立的段（Segment），每个段都是一个独立的 ReentrantLock。默认情况下，通常有 16 个或更多个段，这意味着理论上可以支持 16 个或更多个并发的写入操作。
2. 写操作的并发： 当一个线程需要写入（put、remove）数据时，它只需要锁定数据所在的那个 Segment，而其他线程仍然可以并发地访问（读写）其他 Segment。这大大减少了锁的粒度。
3. 读操作的并发： 大多数读操作（get）是无锁的。它通过 volatile 关键字来保证数据的可见性，允许多个线程同时读取。在某些情况下（如 Segment 的 modCount 发生变化），可能需要进行二次检查以确保数据一致性。
4. 结构：
   • 内部有一个 Segment 数组，Segment 继承自 ReentrantLock。
   • 每个 Segment 内部包含一个 HashEntry 数组（类似于 HashMap 的底层数组）和链表结构。
   • 哈希函数会先确定键属于哪个 Segment，然后再在该 Segment 内部计算哈希值，定位到具体的 HashEntry 数组索引。

多线程安全环境下使用集合,线程安全的集合.

面试题： 如何在多线程环境下使用集合？请列举并解释几种线程安全的集合类。

• Vector 和 Hashtable：
  • 原理： 通过在每个方法上加 synchronized 关键字实现粗粒度同步（锁住整个对象）。
  • 缺点： 性能低下，因为同一时间只有一个线程能访问集合的任何方法，并发度很低。
• Collections.synchronizedList/Set/Map()：
  • 原理： 这是一系列工厂方法，它返回一个由底层非线程安全集合（如 ArrayList, HashMap）包装而成的线程安全版本。同样是通过 synchronized 关键字对所有方法进行同步。
  • 缺点： 与 Vector/Hashtable 类似，也是粗粒度同步，性能瓶颈明显。
• ConcurrentHashMap： (推荐用于并发Map)
  • 原理： 采用分段锁（Segment）（JDK 7）或 CAS + Synchronized + Node（JDK 8）实现更细粒度的并发控制。在 JDK 8 中，取消了 Segment，直接使用 synchronized 锁住哈希桶的头节点，结合 CAS 操作，实现了更高的并发度。
  • 特点： 读操作通常不需要加锁，写操作只锁住受影响的部分，大大提高了并发性能。
  • 适用场景： 高并发场景下对 Map 的读写操作。
• CopyOnWriteArrayList 和 CopyOnWriteArraySet： (推荐用于并发List/Set，写少读多)
  • 原理： 写时复制（Copy-On-Write）。当对集合进行写操作（添加、修改、删除）时，会先复制一份底层数组，在新数组上完成修改，然后将新数组的引用指向集合。读操作则不需要加锁，直接读取旧数组。
  • 特点：
    • 读写分离： 读操作完全是无锁的，性能极高。
    • 写操作开销大： 每次写操作都会复制整个数组，对于数据量大且写操作频繁的场景，性能会很差。
    • 数据一致性： 读到的可能是旧版本的数据（写操作过程中），是最终一致性。
  • 适用场景： 读操作远远多于写操作的并发场景，例如黑名单、白名单、事件监听器列表等。

异常、泛型与集合框架

Java中异常的类继承体系

运行时异常(extends RuntimeException:数组索引越界

编译异常(extends Exception). 编译时异常需要通过try-catch或throw丢出异常进行处理,

运行时异常不需要特别处理

此外异常可以分为业务类和运行逻辑类,一些代码中的异常应该被catch然后向上抛给业务类或者直接处理.

泛型允许编写可以处理不同类型数据的类、接口和方法，而无需在代码中明确指定具体类型。泛型提供了更强的类型检查，并且消除了对类型转换的需求，从而使得代码更加安全和易于维护。

类型参数：在定义泛型类或方法时使用占位符（通常为大写字母如 T, E, K, V 等），代表实际应用中的类型。

• 类型安全：编译器会在编译期进行类型检查，减少运行时出现的 ClassCastException 错误。
• 消除类型转换：由于类型信息在编译时已知，因此不需要显式的类型转换。

使用泛型类

1
2
3
4
5
6
7

Box<Integer> integerBox = new Box<>();
integerBox.set(10);
Integer intValue = integerBox.get();

Box<String> stringBox = new Box<>();
stringBox.set("Hello World");
String strValue = stringBox.get();

泛型方法

你也可以定义泛型方法，即在方法级别上使用泛型。例如：

1
2
3
4
5
6
7
8
9
10
11
12
13

public static <T> void printArray(T[] array) {
    for (T element : array) {
        System.out.println(element);
    }
}

public static void main(String[] args) {
    Integer[] intArray = {1, 2, 3};
    String[] stringArray = {"A", "B", "C"};

    printArray(intArray);
    printArray(stringArray);
}

在这个例子中，<T> 在方法签名前声明了类型参数，这样这个方法就可以接受任意类型的数组作为参数。

泛型接口

类似地，也可以定义泛型接口：

1
2
3
4

public interface Container<T> {
    void add(T item);
    T get(int index);
}

然后实现这个接口：

1
2
3
4
5
6
7
8
9
10
11
12
13

public class StringContainer implements Container<String> {
    private List<String> items = new ArrayList<>();

    @Override
    public void add(String item) {
        items.add(item);
    }

    @Override
    public String get(int index) {
        return items.get(index);
    }
}

Java 泛型是在 Java 5 中引入的，而在此之前已经存在了大量的 Java 代码库。如果直接在 JVM 层面实现泛型支持，那么这些现有的代码可能会因为缺乏泛型信息而不兼容。通过类型擦除，Java 编译器能够在编译时移除泛型类型信息，并将泛型代码转换为非泛型代码，这样就可以确保新旧代码可以无缝地一起工作

通配符

有时可能需要编写能够与多种类型工作的代码，但并不需要知道这些类型的具体细节。这时可以使用通配符 ?：

• 无界通配符：<?> 表示可以是任何类型。
• 有界通配符：<? extends T> 和 <? super T> 分别表示类型必须是 T 或其子类，以及 T 或其父类。

泛型的优点

1. 类型安全：编译器可以在编译时进行更多的类型检查，减少运行时错误。
2. 消除强制类型转换：不再需要手动将对象转换回原始类型。
3. 提高代码重用性：通过泛型，相同的逻辑可以应用于不同的数据类型。

Java集合是一种容器,类似于数组但集合的大小可变.

多线程与线程池

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

package com.sekyoro.tutorThread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * @projectName: workspace
 * @package: com.sekyoro.tutorThread
 * @className: threadDemo
 * @author: proanimer
 * @description:
 * @date: 2025/3/19 16:19
 */
class easyThread extends Thread {
    @Override
    public void run() {
        System.out.println("This is a thread");
    }
}
class miniThread implements Runnable{
    @Override
    public void run() {
        System.out.println("This is a mini thread");
    }
}

class miniCallable implements Callable<Integer> {
    private int n;
    public miniCallable() {
        this.n = 0;
    }
    public miniCallable(int n) {
        this.n = n;
    }

    @Override
    public Integer call() throws Exception {
        System.out.println("Calculating...");
        return 10;
    }

    public int getN() {
        return n;
    }
}
public class threadDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Thread et = new easyThread();
        et.start();
        new Thread(new miniThread()).start();

        Callable<Integer> mc = new miniCallable();
        FutureTask<Integer> ft = new FutureTask<>(mc);
        new Thread(ft).start();
        Integer i = ft.get();
    }
}

线程同步解决线程安全问题

同步代码块

1
2
3

synchronized() {

}

同步方法

1
2
3

synchronized void draw(int m) {
          money -= m;   
  }

Lock锁

1
2
3
4

ReentrantLock lock = new ReentrantLock();
lock.lock();
...
lock.unlock();

显式锁（Explicit Lock）

• ReentrantLock 类提供了比synchronized更灵活的锁操作，例如可中断的锁等待、尝试非阻塞获取锁、超时获取锁等。

  1 2 3 4 5 6 7

  Lock lock = new ReentrantLock(); lock.lock(); // 获取锁 try { // 受保护的代码 } finally { lock.unlock(); // 确保释放锁 }

1. 读写锁（ReadWriteLock）

ReadWriteLock 接口 和 ReentrantReadWriteLock 实现类.允许多个读操作同时进行，但在写操作时排斥所有其他读写操作。适用于读多写少的场景。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

ReadWriteLock rwl = new ReentrantReadWriteLock();
rwl.readLock().lock(); // 获取读锁
try {
    // 读取操作
} finally {
    rwl.readLock().unlock(); // 释放读锁
}

rwl.writeLock().lock(); // 获取写锁
try {
    // 写入操作
} finally {
    rwl.writeLock().unlock(); // 释放写锁
}

1. 条件变量（Condition）

Condition 接口与显式锁配合使用，提供类似

1
2
3
4
5
6
7
8
9
10
11

Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();

lock.lock();
try {
    condition.await(); // 相当于 wait()
    // ...
    condition.signal(); // 相当于 notify()
} finally {
    lock.unlock();
}

1. StampedLock

StampedLock 类是Java 8引入的一种新的锁类型，支持乐观读锁策略，适用于读多写少且大部分读操作不会发生冲突的情况。它提供了三种模式：写锁、悲观读锁和乐观读锁。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

StampedLock stampedLock = new StampedLock();

long stamp = stampedLock.readLock(); // 悲观读锁
try {
    // 读取操作
} finally {
    stampedLock.unlockRead(stamp);
}

stamp = stampedLock.writeLock(); // 写锁
try {
    // 写入操作
} finally {
    stampedLock.unlockWrite(stamp);
}

long optimisticStamp = stampedLock.tryOptimisticRead(); // 乐观读锁
// 验证并使用乐观读锁...
if (!stampedLock.validate(optimisticStamp)) {
    // 如果验证失败，则需要重新获取悲观读锁或写锁
}

线程池

1. ThreadPoolExecutor创建线程池

1
2
3
4
5
6
7
8
9

// 1. 创建线程池
ExecutorService pool = new ThreadPoolExecutor(3, 5, 4, TimeUnit.SECONDS, new ArrayBlockingQueue<>(3), Executors.defaultThreadFactory(), new ThreadPoolExecutor.DiscardOldestPolicy());

// 2. 使用线程池处理任务
Runnable myRunnable = new MyRunnable(3);
pool.execute(new MyRunnable(3)); //提交任务
pool.execute(new MyRunnable(3)); //提交任务
pool.execute(new MyRunnable(3)); //提交任务
pool.execute(new MyRunnable(3)); //提交任务

1. 利用Executors创建线程池

利用ThreadPoolExecutor设置不同参数调用

1
2
3
4
5
6

public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
                              0L, TimeUnit.MILLISECONDS,
                              new LinkedBlockingQueue<Runnable>());
}

反射、注解与动态代理

反射是指在运行时动态地获取类的信息以及操作对象的能力。通常情况下，Java 编译器会在编译期确定所有类型和成员变量的访问权限及调用方式，而反射则允许你在运行时进行这些操作

1
2
3
4
5
6
7
8
9
10
11
12
13

// 方式一: 直接通过类名获取
Class<?> clazz = MyClass.class;

// 方式二: 使用对象的 getClass() 方法
MyClass obj = new MyClass();
clazz = obj.getClass();

// 方式三: 通过全限定类名字符串
try {
    clazz = Class.forName("com.example.MyClass");
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}

得到的class类可以用来创建实例、访问字段、调用方法等

创建实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

try {
    // 假设 MyClass 有一个无参构造函数
    Object obj = clazz.getDeclaredConstructor().newInstance();
} catch (Exception e) {
    e.printStackTrace();
}
try {
    // 获取指定参数类型的构造函数
    Constructor<MyClass> constructor = clazz.getConstructor(paramType.class);
    
    // 创建实例
    MyClass instance = constructor.newInstance(args);
} catch (Exception e) {
    e.printStackTrace();
}

注解（Annotations）是一种元数据形式，它提供了关于程序代码的额外信息，但这些信息并不直接改变程序的运行逻辑。注解自 Java 5 引入以来，已经成为 Java 开发中不可或缺的一部分，用于简化开发流程、提供配置信息、增强代码的功能等

• 定义：注解是接口的一种特殊形式，它通过 @interface 关键字来定义，并可以附加到类、方法、变量、参数、包声明等语言元素上。
• 用途：主要用于编译时检查、运行时处理和生成源代码或文档。

1. 标记注解：没有成员变量，仅作为标记使用，如 @Override。
2. 单值注解：只有一个值，通常省略名称直接指定值，如 @SuppressWarnings("unchecked")。
3. 完整注解：包含多个成员变量，需要明确指定每个成员的值。

元注解是指用来注解其他注解的注解，主要包括以下几个：

• @Retention：定义了注解的存在阶段（SOURCE, CLASS, RUNTIME）。
• @Target：指定了注解可以应用的目标元素类型（TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE 等）。
• @Documented：表明这个注解应该被 javadoc 工具记录。
• @Inherited：允许子类继承父类中的注解。
• @Repeatable：从 Java 8 开始支持，表示相同的注解可以在同一地方多次使用。

注解的解析

检查方法和类等是否包含对应注解,若包含则进行相关调用

1
2
3
4
5
6
7
8
9
10
11
12
13

annotationDemo annotationDemo = new annotationDemo();
 Class<?> aClass = annotationDemo.class;
 Method[] methods = aClass.getMethods();
 for (Method method : methods) {
     if (method.isAnnotationPresent( MyTest.class)) {
         try {
             MyTest declaredAnnotation = method.getDeclaredAnnotation(MyTest.class);
             method.invoke(annotationDemo);
         } catch (IllegalAccessException | InvocationTargetException e) {
             throw new RuntimeException(e);
         }
     }
 }

动态代理

Proxy.newProxyInstance创建代理,参数包括类加载器,需要实现的接口,和代理需要做的事情

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public class ProxyUtils {
    public static StarService createProxy(StarService starService){
        StarService o = (StarService)Proxy.newProxyInstance(ProxyUtils.class.getClassLoader(), starService.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
               String methodName = method.getName();
               if("sing".equals(methodName)) {
                   System.out.println("sing a song: " + args[0]);
               }else{
                     System.out.println("dance a dance");
               }
                if(method.getReturnType().equals(Void.TYPE)) {
                   return null;
               }else{
                       return  method.invoke(starService,args);
               }
            }
        });
        return o;

    }

}

ClassLoader

类加载过程主要包括三个阶段：加载、链接和初始化。

• 加载：通过类的全限定名获取定义此类的二进制字节流，并将其转换为方法区中的运行时数据结构，在内存中生成一个代表该类的 java.lang.Class 对象。
• 链接：包括验证、准备和解析三个步骤。验证确保被加载类的正确性；准备则为类变量分配内存并设置默认初始值；解析是将类、接口、字段和方法的符号引用转为直接引用的过程。
• 初始化：执行类构造器 <clinit>() 方法的过程，对静态变量和静态代码块进行初始化。

Java 类加载器使用双亲委派模型来搜索类或资源。当一个类加载器收到类加载请求时，它首先不会自己去尝试加载这个类，而是把这个请求委派给父类加载器完成，每一层的类加载器都是如此，因此所有的类加载请求最终都会传送到顶层的启动类加载器。只有当父类加载器无法加载该类时，子类加载器才会尝试自己加载

Java 提供了三种内置的类加载器：

• Bootstrap ClassLoader：这是最顶层的类加载器，由本地代码实现，通常用于加载核心 JDK 类库（如 rt.jar）。 无法直接访问,显示为null
• Extension ClassLoader：扩展类加载器，用来加载位于 $JAVA_HOME/jre/lib/ext 目录下的 JAR 包。 (目前使用PlatformClassLoader,加载 JDK 提供的平台模块中的类，例如 java.sql, java.xml, javax.* 等模块化的平台类。)
• Application ClassLoader：应用程序类加载器，负责加载用户类路径（ClassPath）上指定的类库

Java 提供了一些常用的方法来操作类加载器：

(1) loadClass(String name)

加载指定名称的类或接口。如果已经加载过，则直接返回对应的 Class 对象；如果没有，则按照双亲委派机制尝试加载。

1
2
3
4
5

try {
    Class<?> clazz = ClassLoader.getSystemClassLoader().loadClass("com.example.MyClass");
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}

(2) findClass(String name)

查找指定名称的类。默认实现会抛出 ClassNotFoundException 异常，通常需要自定义类加载器覆盖此方法以提供具体的类查找逻辑。

(3) defineClass(byte[] b, int off, int len)

将一个字节数组转换成一个类的 Class 对象。一般不直接调用，主要用于自定义类加载器。

(4) getResource(String name) 和 getResourceAsStream(String name)

用于查找资源文件。前者返回资源的 URL，后者返回资源的输入流。

1
2

URL resourceUrl = getClass().getClassLoader().getResource("config.properties");
InputStream inputStream = getClass().getClassLoader().getResourceAsStream("config.properties");

(5) getParent()

返回该类加载器的父类加载器。注意，Bootstrap ClassLoader 没有父类加载器，所以对于 Bootstrap ClassLoader 调用 getParent() 将返回 null。

4. 自定义类加载器

有时我们需要根据特定的需求来自定义类加载器。可以通过继承 java.lang.ClassLoader 并重写 findClass 方法来实现。

1
2
3
4
5
6
7
8
9
10
11
12

public class MyClassLoader extends ClassLoader {
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        byte[] classData = loadClassData(name); // 实现类数据加载逻辑
        return defineClass(name, classData, 0, classData.length);
    }

    private byte[] loadClassData(String className) {
        // 加载类数据的逻辑
        return new byte[0];
    }
}

以下是实现自定义类加载器的基本步骤：

1. 继承 ClassLoader

   • 创建一个类并继承 ClassLoader。

2. 重写 findClass() 方法(遵从双亲委派机制)

   • 实现自定义的类加载逻辑。

3. 调用 defineClass() 方法

   • 将字节码转换为 Class 对象。

   class对象相同需要classloader相同,相同的classloader进行loadclass相同的类得到的class相同

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class CustomClassLoader extends ClassLoader {

    // 加载类的根路径
    private String classPath;

    public CustomClassLoader(String classPath) {
        this.classPath = classPath;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        // 读取类的字节码
        byte[] classData = loadClassData(name);
        if (classData == null) {
            throw new ClassNotFoundException("Class not found: " + name);
        }
        // 解密字节码
        byte[] decryptedClassData = decrypt(classData);

        // 定义类
        return defineClass(name, decryptedClassData, 0, decryptedClassData.length);
    }

    // 加载类的字节码
    private byte[] loadClassData(String className) {
        String path = classPath + className.replace('.', '/') + ".class";
        try (FileInputStream fis = new FileInputStream(path);
             ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
            int buffer;
            while ((buffer = fis.read()) != -1) {
                baos.write(buffer);
            }
            return baos.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }

    // 模拟解密过程
    private byte[] decrypt(byte[] data) {
        // 简单的异或解密
        for (int i = 0; i < data.length; i++) {
            data[i] = (byte) (data[i] ^ 0xFF);
        }
        return data;
    }

    public static void main(String[] args) throws Exception {
        // 自定义类加载器
        CustomClassLoader customClassLoader = new CustomClassLoader("path/to/classes/");

        // 使用自定义类加载器加载类
        Class<?> clazz = customClassLoader.loadClass("com.example.MyClass");
        System.out.println("Loaded class: " + clazz.getName());

        // 创建实例并调用方法
        Object instance = clazz.getDeclaredConstructor().newInstance();
        clazz.getMethod("sayHello").invoke(instance);
    }
}

线程上下文加载器

线程上下文类加载器（Thread Context ClassLoader）是 Java 提供的一种机制，允许开发者在线程中设置和获取类加载器。这种机制主要用于解决某些特定场景下类加载的问题，尤其是在复杂的类层次结构或模块化系统中。

线程上下文类加载器的作用

1. 解决类加载器隔离问题：
   • 在 Java 应用程序中，不同的类加载器可能会形成类加载器树，这导致了类加载器之间的隔离性。
   • 例如，在 Web 容器或 OSGi 等环境中，不同应用或模块可能使用不同的类加载器来加载各自的类。在这种情况下，如果一个类需要加载另一个类加载器负责加载的类，则会遇到问题。
   • 线程上下文类加载器提供了一种绕过双亲委派模型的方式，允许当前线程使用指定的类加载器来加载类。
2. 支持框架和库的开发：
   • 许多框架和库（如 JNDI、JDBC 驱动等）依赖于线程上下文类加载器来加载必要的类。
   • 这些框架通常不知道具体的类加载器，因此它们可以利用线程上下文类加载器来动态地加载所需的类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

public class ThreadContextClassLoaderExample {

    public static void main(String[] args) {
        try {
            // 获取默认的上下文类加载器
            ClassLoader defaultClassLoader = Thread.currentThread().getContextClassLoader();
            System.out.println("默认的上下文类加载器: " + defaultClassLoader);

            // 创建一个新的类加载器（例如自定义类加载器）
            ClassLoader customClassLoader = new CustomClassLoader();

            // 设置新的上下文类加载器
            Thread.currentThread().setContextClassLoader(customClassLoader);
            System.out.println("设置后的上下文类加载器: " + Thread.currentThread().getContextClassLoader());

            // 使用上下文类加载器加载类
            Class<?> clazz = Thread.currentThread().getContextClassLoader().loadClass("com.example.MyClass");
            System.out.println("加载的类: " + clazz.getName());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

class CustomClassLoader extends ClassLoader {
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        // 实现类的查找逻辑
        byte[] classData = loadClassData(name);
        if (classData == null) {
            throw new ClassNotFoundException();
        } else {
            return defineClass(name, classData, 0, classData.length);
        }
    }

    private byte[] loadClassData(String className) {
        // 模拟从文件或其他来源读取类数据的逻辑
        return null;
    }
}

JVM

程序计数器: 线程私有

垃圾回收

判断对象可以回收

引用计数法

工作原理

1. 初始化：每当创建一个新的对象时，该对象的引用计数器被初始化为1。
2. 增加引用：每当有新的引用指向这个对象时（例如，将对象赋值给另一个变量），该对象的引用计数加1。
3. 减少引用：每当某个引用不再指向该对象时（例如，变量超出作用域或重新赋值），该对象的引用计数减1。
4. 回收内存：当一个对象的引用计数降为0时，表示没有其他引用指向该对象，这时就可以立即回收该对象所占用的内存。

缺点:

无法处理循环引用：如果两个或多个对象相互引用形成环状结构，则即使这些对象实际上已经不可达，它们的引用计数也不会变为0，导致内存泄漏。为了克服这个问题，一些语言引入了弱引用（weak references）或专门的循环检测机制。

多线程环境下的复杂性：在多线程环境下，对引用计数的修改需要同步操作，以防止竞态条件（race condition），这也增加了实现的复杂性和运行时的开销

可达性分析算法

可达性分析的基本思想是从一组被称为“根节点”（root set）的对象开始，遍历所有可以通过这些根节点直接或间接引用到的对象，并将它们标记为存活。未被标记的对象则被认为是不可达的，可以被安全地回收。

在命令行中输入 jps 可以列出所有由当前用户启动的 Java 进程的基本信息

-q：仅输出 JVM 的进程 ID，不输出类名、jar 名等信息

-l：输出主类的完整包名；如果进程执行的是 jar 文件，则输出 jar 文件的完整路径

1

jmap -dump:[live,]format=b,file=<filename>.hprof <pid>

• live：如果指定了这个选项，则只转储存活的对象；如果不指定，则转储所有对象。
• format=b：表示输出格式为二进制，默认就是二进制格式，所以通常省略不写。
• <filename>.hprof：指定生成的堆转储文件的名字。
• <pid>：目标Java进程的进程ID。

引用

强引用 软引用 弱引用

软引用:垃圾回收时且内存不足时会被回收掉

虚引用 引用队列

终结器引用

• 强引用：日常编程中最常用的引用类型，几乎所有对象都是通过强引用创建的。
• 软引用：适用于缓存场景，当内存不足时，允许GC回收缓存数据。
• 弱引用：适合于需要自动清理的资源管理场景，例如监听器或回调函数列表中的对象。
• 虚引用：主要用于了解对象何时被垃圾回收，常用于做一些清理工作，比如清除本地内存、关闭文件等

回收算法

标记-清除

• 这是最基本的垃圾回收算法，分为两个阶段：标记和清除。在标记阶段，GC从根集合（GC Roots）开始遍历所有可达对象，并标记它们为存活对象；在清除阶段，未被标记的对象即被视为垃圾对象并被回收
• 优点是实现简单，适用于任何对象的内存管理；缺点是会产生内存碎片，因为删除了不可达对象后留下的空闲内存可能是不连续的，这可能导致后续大对象分配失败。

复制（Copying）算法：

• 复制算法将堆内存划分为两部分，每次只使用其中一部分。当这部分内存用完时，GC会暂停应用，将存活对象复制到另一部分内存中，并清空原内存区域
• 此算法避免了内存碎片问题，但代价是只能使用一半的内存空间，且对于存活率较高的对象效率较低。

复制算法将可用内存分为两部分，通常称为From Space和To Space。

程序只使用其中一部分（From Space），当这部分内存满后，GC会遍历From Space中的所有对象，将存活的对象复制到To Space，并且更新这些对象的引用指向新的位置。

清理完From Space后，它变为可用空间，而To Space则成为下次分配新对象的空间

这个过程有效地避免了内存碎片化的问题，因为每次清理后的内存区域都是连续的

标记-整理（Mark-Compact）算法：

• 标记-整理算法结合了标记-清除和复制的优点，在标记阶段与标记-清除类似，但在清除阶段，它会将存活的对象移动到内存的一端，然后清理掉端边界以外的空间
• 它解决了内存碎片问题，但需要移动存活对象，增加了回收的开销。

标记整理算法首先执行标记阶段，这与标记清除算法相同，即通过可达性分析找到所有存活的对象并进行标记。

接下来是整理阶段，在这个阶段，所有的存活对象会被移动到内存的一端，这样可以确保所有的空闲空间都在另一端，形成一个连续的块。

最后一步是对剩余的未被标记的部分进行清理，释放出连续的内存块

分代收集（Generational Collection）算法：

• 分代收集是一种基于对象生命周期特征优化的策略，将堆内存划分为年轻代（Young Generation）和老年代（Old Generation）。年轻代通常采用复制算法，而老年代则采用标记-清除或标记-整理算法
• 这种方法利用了大多数对象“朝生夕死”的特点，提高了垃圾回收的效率。

1. 堆内存分区

在分代垃圾回收中，堆内存通常被划分为三个主要区域：

• 年轻代（Young Generation）：
  • 主要用于存放新创建的对象。
  • 进一步细分为一个 Eden 区和两个 Survivor 区（From 和 To）。
• 老年代（Old Generation）：
  • 存放的是经过多次垃圾回收后仍然存活的对象，这些对象被认为具有较长的生命期。
• 永久代/元空间（Permanent Generation/Metaspace）：
  • 在 Java 8 之前称为永久代，之后改为元空间，主要用于存储类的元数据、方法描述等信息，并不属于堆的一部分。

2. 分代垃圾回收过程

年轻代垃圾回收（Minor GC）

• Eden 区与 Survivor 区：当一个新的对象被创建时，它首先被分配到 Eden 区。如果 Eden 区满了，就会触发一次 Minor GC。
• 复制算法：Minor GC 使用这种算法来清理垃圾对象。在这个过程中，存活的对象会被复制到其中一个 Survivor 区（假设为 From），同时清除 Eden 区。
• Survivor 区交换：下一次 Minor GC 发生时，Eden 区和当前的 From Survivor 区中的存活对象会被复制到另一个 Survivor 区（To）。然后这两个角色会互换（即原来的 From 变成 To，反之亦然）。
• 晋升至老年代：当某个对象经历了若干次 Minor GC 后仍然存活（默认情况下是 15 次），它将被移动到老年代。

老年代垃圾回收（Major GC / Full GC）

• Full GC：当老年代也满时，将会触发 Full GC，这会同时清理年轻代和老年代。由于老年代中的对象通常是长期存活的，所以 Full GC 的频率远低于 Minor GC，但其执行成本更高。
• 标记-清除或标记-整理算法：对于老年代，可能会使用这两种算法之一。标记-清除算法简单地标识并删除不再使用的对象，但会导致内存碎片化；标记-整理算法则会在清理的同时压缩内存，减少碎片。

一些常用的 JVM 参数，用于调整分代垃圾回收行为：

• 年轻代相关参数：
  • -Xmn<size>：设置年轻代大小。
  • -XX:SurvivorRatio=<ratio>：设置 Eden 区与 Survivor 区的比例（默认为 8:1）。
  • -XX:MaxTenuringThreshold=<n>：设置对象晋升到老年代的最大年龄（默认为 15）。
• 老年代相关参数：
  • -Xms<size>：设置堆内存初始大小。
  • -Xmx<size>：设置堆内存最大大小。
• 垃圾回收器选择：
  • -XX:+UseSerialGC：启用 Serial 收集器。
  • -XX:+UseParallelGC：启用 Parallel 收集器。
  • -XX:+UseConcMarkSweepGC：启用 CMS 收集器。
  • -XX:+UseG1GC：启用 G1 收集器。
  • -XX:+UseZGC：启用 ZGC 收集器。
  • -XX:+UseShenandoahGC：启用 Shenandoah 收集器

(1) 基本 GC 日志

• -XX:+PrintGCDetails：打印详细的垃圾回收日志。
• -XX:+PrintGC 或 -verbose:gc：打印简单的垃圾回收日志（仅显示每次 GC 的时间和类型）。

示例：

1

java -XX:+PrintGCDetails -XX:+PrintGC MyApplication

输出示例：

1

[GC (Allocation Failure) [PSYoungGen: 1024K->512K(2048K)] 1024K->768K(6144K), 0.0023456 secs] [Times: user=0.01 sys=0.00, real=0.00 secs]

(2) 打印时间戳

• -XX:+PrintGCTimeStamps：在每条 GC 日志前添加时间戳（从 JVM 启动开始的时间）。
• -XX:+PrintGCDateStamps：在每条 GC 日志前添加实际日期和时间。

示例：

1

java -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:+PrintGCDateStamps MyApplication

输出示例：

1

2023-03-29T12:00:00.000+0000: 1.234: [GC (Allocation Failure) ...]

(3) 将 GC 日志写入文件

• -Xloggc:<file>：将 GC 日志写入指定文件。
• 结合其他参数可以生成更详细的日志文件。

示例：

1

java -XX:+PrintGCDetails -Xloggc:gc.log MyApplication

2. 调整堆内存大小

• -Xms<size>：设置 JVM 堆内存的初始大小。例如 -Xms512m 表示初始堆大小为 512MB。
• -Xmx<size>：设置 JVM 堆内存的最大大小。例如 -Xmx2g 表示最大堆大小为 2GB。

1

java -Xms512m -Xmx2g MyApplication

3. 调整年轻代和老年代比例

• -XX:NewRatio=<ratio>：设置老年代与年轻代的比例。例如 -XX:NewRatio=3 表示老年代与年轻代的比例为 3:1。
• -XX:SurvivorRatio=<ratio>：设置 Eden 区与 Survivor 区的比例。例如 -XX:SurvivorRatio=8 表示 Eden 区与每个 Survivor 区的比例为 8:1。

1

java -XX:NewRatio=3 -XX:SurvivorRatio=8 MyApplication

4. 设置元空间大小

• -XX:MetaspaceSize=<size>：设置元空间的初始大小。
• -XX:MaxMetaspaceSize=<size>：设置元空间的最大大小。

示例：

1

java -XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=256m MyApplication

5. 设置线程栈大小

• -Xss<size>：设置每个线程的栈大小。例如 -Xss512k 表示每个线程的栈大小为 512KB。

1

java -Xss512k MyApplication

6. 启用特定垃圾回收器

• -XX:+UseSerialGC：启用 Serial 收集器（单线程）。
• -XX:+UseParallelGC：启用 Parallel 收集器（多线程，关注吞吐量）。
• -XX:+UseConcMarkSweepGC：启用 CMS 收集器（低延迟，适合 Web 应用）。
• -XX:+UseG1GC：启用 G1 收集器（适合大内存应用）。
• -XX:+UseZGC：启用 ZGC 收集器（超低延迟，适合大内存）。
• -XX:+UseShenandoahGC：启用 Shenandoah 收集器（超低延迟）。

示例：

1

java -XX:+UseG1GC MyApplication

7. 设置 GC 暂停时间目标

• -XX:MaxGCPauseMillis=<time>：设置 GC 的最大暂停时间目标（单位为毫秒）。只对 G1 和 ZGC 有效。
• -XX:GCTimeRatio=<ratio>：设置 GC 时间与应用程序运行时间的比例。例如 -XX:GCTimeRatio=19 表示 GC 时间占总时间的 1/20。

1

java -XX:+UseG1GC -XX:MaxGCPauseMillis=200 MyApplication

8. 监控 JVM 性能

• -XX:+HeapDumpOnOutOfMemoryError：当发生 OutOfMemoryError 时自动生成堆转储文件。
• -XX:HeapDumpPath=<path>：指定堆转储文件的路径。
• -XX:+PrintCommandLineFlags：打印 JVM 启动时的所有命令行参数。
• -XX:+PrintFlagsFinal：打印所有 JVM 参数及其最终值。

1

java -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=./heapdump.hprof MyApplication

9. 其他常用参数

• -D<property>=<value>：设置系统属性。例如 -Dfile.encoding=UTF-8。
• -server：启用服务器模式（默认情况下大多数 JVM 都会自动启用此模式）。
• -XX:+DisableExplicitGC：禁用通过 System.gc() 显式触发的垃圾回收。

1

java -Dfile.encoding=UTF-8 -server -XX:+DisableExplicitGC MyApplication

垃圾回收器

1. Serial 收集器

• 工作模式：单线程运行，适用于单核处理器或客户端应用。
• 应用场景：适合内存较小的应用程序，特别是那些对响应时间要求不高且资源有限的环境。
• 优点：实现简单，对于小型应用程序非常有效。
• 缺点：由于是单线程执行，在进行垃圾回收时会暂停所有其他的工作线程（Stop-The-World, STW），这会导致较长时间的停顿。

启用参数：

1

-XX:+UseSerialGC

2. Parallel 收集器（也称为 Throughput Collector）

• 工作模式：多线程并行执行，适用于多核处理器环境下的服务器端应用。
• 关注点：提高吞吐量，即减少垃圾回收时间占总运行时间的比例。
• 年轻代：使用标记-复制算法。
• 老年代：使用标记-整理算法。
• 优点：通过并行处理提高了垃圾回收效率，减少了总的停顿时间。
• 缺点：仍然会有较长的停顿时间，特别是在老年代垃圾回收期间。

启用参数：

1

-XX:+UseParallelGC

为了优化老年代的收集性能，可以加上 -XX:+UseParallelOldGC 来启用老年代的并行压缩。

3. CMS（Concurrent Mark Sweep）收集器

• 工作模式：专注于减少停顿时间，尽可能地与应用程序并发执行大部分垃圾回收工作。

• 主要阶段

  ：

  • 初始标记（Initial Mark）
  • 并发标记（Concurrent Mark）
  • 再标记（Remark）
  • 并发清除（Concurrent Sweep）

• 优点：尽量减少了应用程序的停顿时间。

• 缺点：虽然减少了停顿时间，但增加了总体的CPU占用率；无法压缩内存，可能导致内存碎片化问题；在某些情况下可能会导致“Concurrent Mode Failure”。

启用参数：

1

-XX:+UseConcMarkSweepGC

4. G1（Garbage First）收集器

• 设计理念：旨在提供可预测的停顿时间和高吞吐量。G1 将堆划分为多个区域（Region），优先回收垃圾最多的区域。

• 主要特性

  ：

  • 可以设置最大停顿时间目标。
  • 支持大堆内存管理，并能有效避免内存碎片。
  • 在进行垃圾回收时，尝试同时清理年轻代和老年代。

• 优点：相比 CMS，G1 提供了更好的停顿时间控制，并减少了内存碎片的问题。

• 缺点：配置相对复杂，可能需要更多的调优才能达到最佳效果。

启用参数：

1

-XX:+UseG1GC

CAS与原子类

CAS（Compare-And-Swap，比较并交换）是一种重要的原子操作机制，广泛应用于多线程并发控制中。它允许在不使用锁的情况下实现对共享数据的同步访问，从而避免了传统锁机制可能带来的性能瓶颈和死锁问题。CAS操作包含三个参数：内存位置V、预期原值A和新值B。只有当内存位置V的值等于预期原值A时，才会将内存位置V的值更新为新值B，并返回操作是否成功的布尔值；否则，不做任何操作

在 Java 中，java.util.concurrent.atomic 包提供了基于 CAS 的原子类，例如 AtomicInteger、AtomicLong 等。这些类内部使用了 Unsafe 类提供的底层 CAS 操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

import java.util.concurrent.atomic.AtomicInteger;

public class CASCounter {
    private AtomicInteger value = new AtomicInteger(0); // 使用 AtomicInteger 实现 CAS

    // 增加计数器的值
    public void increment() {
        int current, next;
        do {
            current = value.get(); // 获取当前值
            next = current + 1;    // 计算下一个值
        } while (!value.compareAndSet(current, next)); // 尝试 CAS 更新
    }

    // 获取当前计数器的值
    public int getValue() {
        return value.get();
    }

    public static void main(String[] args) throws InterruptedException {
        CASCounter counter = new CASCounter();

        // 创建多个线程并发增加计数器
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        // 启动线程
        t1.start();
        t2.start();

        // 等待线程完成
        t1.join();
        t2.join();

        // 输出最终计数器的值
        System.out.println("Final counter value: " + counter.getValue());
    }
}

乐观锁和悲观锁

乐观锁（Optimistic Locking）和悲观锁（Pessimistic Locking）是两种处理并发控制的策略，它们在如何管理数据冲突方面采取了不同的方法。

乐观锁则假设不会发生并发冲突，因此不会主动加锁。它允许所有事务同时读取并尝试修改数据，但在提交更改前检查是否有其他事务已经修改了相同的数据。如果有，则拒绝此次修改或根据具体业务逻辑进行重试或其他处理。

悲观锁假设会发生并发冲突，因此在操作数据时会直接加锁，防止其他事务对该数据进行修改直到当前事务完成。

使用悲观锁的方式可能是这样的：在处理订单时首先锁定库存记录，然后检查库存是否足够，若足够则扣减库存并提交事务释放锁；否则回滚事务并告知用户库存不足。

使用乐观锁的方式则是：在开始处理订单时不加锁，而是记录下当前库存记录的版本号或时间戳。在准备扣减库存时再次检查版本号或时间戳是否未变，若未变则扣减库存并更新版本号/时间戳；若有变化则表明期间有其他订单已修改了库存，此时可以选择重试或通知用户稍后再试。

原子操作类

1. CAS 操作

CAS（Compare-And-Swap）是实现原子操作的核心机制。它是一个低级别的、硬件提供的原子指令，通常用于无锁算法中。一个典型的 CAS 操作包含三个参数：

• 内存位置 V：要更新的数据在内存中的地址。
• 预期值 A：期望在内存位置 V 处找到的值。
• 新值 B：如果内存位置 V 的当前值等于预期值 A，则将该位置的值更新为新值 B。

CAS 操作会检查内存位置 V 的当前值是否与预期值 A 相等。如果相等，则将内存位置 V 更新为新值 B，并返回成功；如果不相等，则不进行任何修改，并返回失败。这个过程是原子性的，意味着在同一时刻只能有一个线程成功执行 CAS 操作。

传统的 AtomicLong (以及AtomicInteger等)使用 CAS（Compare-And-Swap）操作来保证线程安全，但在高并发情况下，多个线程同时竞争同一个值时，CAS 操作可能会频繁失败并重试，导致性能下降。

LongAdder 的设计目标是解决这个问题。它通过分段锁的思想将数据分散到多个变量中，减少了线程间的竞争，从而提高了性能。最终结果可以通过这些变量汇总得到。

1. Java 内存模型 (JMM)

Java 内存模型定义了多线程环境下变量的可见性和顺序性规则。为了保证线程间共享变量的一致性，Java 提供了 volatile 关键字和同步块 (synchronized) 来确保变量的可见性。原子类内部使用了类似的技术来确保线程间的可见性，即使它们自身并不总是需要显式的同步块。

1. Unsafe 类

Java 的原子类内部通常使用 sun.misc.Unsafe 类提供的本地方法来直接调用底层的 CAS 操作。虽然 Unsafe 类并不是官方推荐的 API，但它被广泛应用于高性能并发库中，如 java.util.concurrent 包内的实现。通过 Unsafe，开发者可以绕过 Java 的安全检查直接与操作系统交互，这使得它可以非常高效地执行 CAS 操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicIntegerExample {
    public static void main(String[] args) {
        AtomicInteger atomicInt = new AtomicInteger(0);

        // 原子递增
        System.out.println("Initial value: " + atomicInt.get());
        atomicInt.incrementAndGet(); // 自增1
        System.out.println("After increment: " + atomicInt.get());

        // 原子更新
        atomicInt.updateAndGet(x -> x * 2); // 使用函数式更新
        System.out.println("After update: " + atomicInt.get());
    }
}

synchronized优化

偏向锁

偏向锁的设计初衷是为了消除无竞争情况下的同步原语，进一步提高程序的运行性能。当一个线程访问同步块并获取锁时,会在对象头中记录当前线程的ID，表示该线程占有了这个对象的锁。

当大多数情况下锁不仅不存在多线程竞争，而且总是由同一线程多次获得时，使用偏向锁可以减少不必要的同步操作。

特性：当没有其他线程尝试获取同一个锁时，持有偏向锁的线程不需要进行同步操作。

如果有其他线程尝试获取偏向锁，则会发生偏向锁撤销，锁可能会升级为轻量级锁。

轻量级锁

Java 轻量级锁是 JVM 提供的一种优化机制，旨在减少多线程环境下获取锁的开销。它主要通过使用 CAS（Compare-And-Swap）操作来避免传统锁带来的性能损耗，适用于线程竞争较少的情况。轻量级锁是 Java 锁机制的一部分，它可以动态升级为重量级锁以应对更高的竞争情况。

• 在线程交替执行同步块且存在轻微的竞争时，轻量级锁能够通过CAS（Compare-and-Swap）操作来避免线程阻塞和上下文切换。
• 特性
  • 每个线程都有自己的栈帧，其中包含用于存储锁的记录空间（Lock Record）。当线程试图获取轻量级锁时，会将对象头中的Mark Word复制到该线程的锁记录中，并尝试通过CAS操作将对象头指向该线程的锁记录。
  • 若多个线程同时请求轻量级锁且自旋一定次数后仍未成功获取锁，则锁将膨胀为重量级锁。

轻量级锁的工作原理

1. 加锁过程
   • 当一个线程尝试获取锁时，如果对象没有被锁定（锁标志位为“01”），JVM 会在当前线程的栈帧中创建一个称为 Lock Record 的空间，并将对象头中的 Mark Word 复制到这个 Lock Record 中。
   • 然后，线程会尝试用 CAS 操作将对象头中的 Mark Word 更新为指向该线程 Lock Record 的指针。如果成功，则该线程获得了锁。
   • 如果 CAS 操作失败，意味着另一个线程已经持有了锁，这时当前线程会自旋（忙等）一段时间，尝试重新获取锁。
2. 解锁过程
   • 当线程退出同步块时，会使用 CAS 操作尝试将对象头中的 Mark Word 恢复为其原始值（即从 Lock Record 中拷贝回来的 Displaced Mark Word）。
   • 如果 CAS 操作成功，则表示没有其他线程尝试获取该锁，锁被成功释放。
   • 如果 CAS 操作失败，说明有其他线程尝试获取过该锁，此时轻量级锁将会膨胀为重量级锁。
3. 锁的升级
   • 轻量级锁在遇到高竞争（即多个线程频繁尝试获取同一把锁）的情况下，可能会膨胀为重量级锁。这是因为持续的自旋等待会消耗大量的 CPU 资源。
   • 一旦锁升级为重量级锁，后续试图获取锁的线程将进入阻塞状态，直到锁被释放。
4. 适用场景
   • 轻量级锁适用于线程竞争不激烈、锁占用时间较短的情况。在这种情况下，轻量级锁能够通过 CAS 操作和自旋来避免线程的阻塞和上下文切换，从而提高程序的并发性能。
   • 对于锁竞争较为激烈的场景，建议使用 ReentrantLock 或者其他的高级同步机制，因为这些机制提供了更灵活的锁管理和更好的性能表现。

重量锁

重量级锁通过操作系统提供的互斥量（mutex）来实现线程间的同步，这种锁会让线程调用者进入阻塞状态，并被操作系统挂起。

在高竞争环境下，即多个线程频繁争夺同一资源时，重量级锁能够确保数据的一致性和完整性。

特性

• 锁住的线程会被挂起直到锁被释放，此时其他等待的线程才有可能获取锁。
• 由于涉及用户态到内核态的切换以及线程的挂起和唤醒，重量级锁的开销较大。

锁膨胀

锁膨胀（Lock Escalation）在Java中通常指的是synchronized关键字背后的锁机制随着竞争条件的变化而动态升级的过程。具体来说，在Java虚拟机（JVM）中，锁的状态可以经历从无锁状态到偏向锁、轻量级锁，最后到重量级锁的转变过程。这个过程称为锁膨胀或锁升级，并且它是一个单向的过程，即锁只能从低级别向高级别升级，不能降级。

锁膨胀的具体过程：

1. 无锁状态：当对象刚创建时，没有线程尝试获取该对象上的锁，此时处于无锁状态。
2. 偏向锁状态：当第一个线程尝试获取对象上的锁时，JVM会将锁设置为偏向锁，并记录下持有偏向锁的线程ID。如果之后还是同一个线程访问，则不需要再次进行加锁操作，直接进入同步块执行代码。偏向锁的目标是减少无实际竞争情况下的锁获取成本。
3. 轻量级锁状态：如果有第二个线程尝试获取已经被偏向锁持有的对象的锁时，偏向锁会升级为轻量级锁。轻量级锁使用CAS（Compare and Swap）操作来尝试获取锁，以减少锁的竞争和系统的开销。轻量级锁适用于多个线程交替执行同步块的情况。
4. 重量级锁状态：当多个线程长时间竞争同一个对象的锁时，轻量级锁会升级为重量级锁。重量级锁采用操作系统的互斥量（Mutex）来实现，确保线程的安全性。在这种状态下，JVM会创建一个等待队列，将等待获取锁的线程挂起在队列中。重量级锁会导致较大的性能开销，因为它涉及到用户态与内核态之间的切换。

锁膨胀的设计目的是为了优化多线程环境下的性能。通过这种方式，JVM可以根据不同的并发场景自动调整锁的状态，从而减少不必要的性能损耗。例如，在几乎没有竞争的情况下，偏向锁可以提供很好的性能；而在有少量竞争的情况下，轻量级锁可以通过自旋避免阻塞，提高效率；只有在高竞争的情况下，才会升级为重量级锁。这种机制使得synchronized在大多数情况下都能够高效运行。

其他优化

1. 减少上锁时间
2. 减少锁的颗粒度 使用concurrentHashMap
3. 锁粗化 多次循环进入同步块不如在同步块内进行循环
4. 锁消除
5. 读写分离

JUC

创建线程

1. 继承 Thread 类

(1) 基本原理

通过继承 Thread 类并重写 run() 方法，调用 start() 方法启动线程。

(2) 示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread running: " + Thread.currentThread().getName());
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();

        thread1.start(); // 启动线程
        thread2.start(); // 启动线程
    }
}

(3) 优点

• 简单直观，易于理解。

(4) 缺点

• Java 不支持多重继承，如果一个类已经继承了其他类，则无法再继承 Thread。

  2. 实现 Runnable 接口

(1) 基本原理

通过实现 Runnable 接口并实现 run() 方法，将 Runnable 对象传递给 Thread 构造器来启动线程。

(2) 示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable running: " + Thread.currentThread().getName());
    }
}

public class Main {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new MyRunnable());
        Thread thread2 = new Thread(new MyRunnable());

        thread1.start(); // 启动线程
        thread2.start(); // 启动线程
    }
}

(3) 优点

• 更灵活：可以避免因为继承 Thread 而导致的多重继承问题。
• 适合资源共享（多个线程共享同一个 Runnable 实例）。

(4) 缺点

• 需要显式地将 Runnable 对象传递给 Thread。

3. 使用 Callable 和 FutureTask

(1) 基本原理

Callable 接口类似于 Runnable，但它可以返回结果，并且可以抛出异常。FutureTask 是一个包装类，用于管理 Callable 的执行结果。

(2) 示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("Callable running: " + Thread.currentThread().getName());
        return 42; // 返回计算结果
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        FutureTask<Integer> futureTask1 = new FutureTask<>(new MyCallable());
        FutureTask<Integer> futureTask2 = new FutureTask<>(new MyCallable());

        Thread thread1 = new Thread(futureTask1);
        Thread thread2 = new Thread(futureTask2);

        thread1.start();
        thread2.start();

        // 获取线程执行结果
        System.out.println("Result from thread1: " + futureTask1.get());
        System.out.println("Result from thread2: " + futureTask2.get());
    }
}

(3) 优点

• 可以返回结果。
• 可以捕获线程中的异常。
• 适合需要获取线程执行结果的场景。

(4) 缺点

• 相比 Runnable，代码稍微复杂一些。

4. 使用线程池（推荐）

(1) 基本原理

Java 提供了 ExecutorService 接口和 Executors 工厂类，用于管理和复用线程，避免频繁创建和销毁线程带来的开销。

(2) 示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class Task implements Runnable {
    private String name;

    public Task(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        System.out.println("Executing task: " + name + " in thread: " + Thread.currentThread().getName());
    }
}

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3); // 创建固定大小的线程池

        for (int i = 0; i < 5; i++) {
            executor.submit(new Task("Task-" + i));
        }

        executor.shutdown(); // 关闭线程池
    }
}

(3) 优点

• 高效：线程池可以复用线程，减少线程创建和销毁的开销。
• 灵活：可以设置线程池大小、任务队列等。
• 易于管理：提供更高级的任务调度和生命周期管理功能。

(4) 缺点

• 初学者可能觉得使用线程池的 API 比较复杂。

5. 使用 Lambda 表达式（简化代码）

从 Java 8 开始，可以使用 Lambda 表达式进一步简化线程的创建和使用。

(1) 示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public class Main {
    public static void main(String[] args) {
        // 使用 Lambda 表达式实现 Runnable
        Thread thread1 = new Thread(() -> 
            System.out.println("Lambda thread running: " + Thread.currentThread().getName())
        );

        // 使用 Lambda 表达式提交任务到线程池
        ExecutorService executor = Executors.newSingleThreadExecutor();
        executor.submit(() -> 
            System.out.println("Lambda task running: " + Thread.currentThread().getName())
        );

        thread1.start();
        executor.shutdown();
    }
}

(2) 优点

• 简洁：减少了样板代码。
• 易读：代码更加紧凑。

6. 总结与选择建议

Syncronized优化原理

synchronized 的底层实现依赖于 JVM 提供的监视器锁（Monitor）\机制，而监视器锁最终映射到操作系统提供的*互斥锁（Mutex Lock）*。具体来说，synchronized 的工作原理分为以下几个阶段：

(1) Monitor（监视器）

• 每个 Java 对象都有一个与之关联的监视器（Monitor），也称为“内置锁”或“监视器锁”。
• 监视器的作用是确保同一时刻只有一个线程能够持有该锁并执行同步代码。

(2) 对象头中的 Mark Word

• 在 HotSpot 虚拟机中，每个 Java 对象都有一个对象头（Object Header），其中包含一个 Mark Word。
• Mark Word 用来存储对象的元信息，例如哈希码、GC 分代年龄、锁状态等。
• 当线程尝试获取锁时，Mark Word 的内容会动态变化，表示锁的状态（无锁、偏向锁、轻量级锁、重量级锁）。

(3) 锁的升级机制

为了优化性能，synchronized 实现了锁的升级机制，从低开销的锁逐步升级到高开销的锁。锁的升级过程如下：

1. 无锁状态：
   • 初始状态下，对象没有被任何线程锁定。
2. 偏向锁（Biased Locking）：
   • 如果某个线程多次进入同步代码块，JVM 会将锁偏向于该线程。
   • 偏向锁通过在 Mark Word 中记录线程 ID 来实现，避免每次加锁和解锁都需要 CAS（Compare-And-Swap）操作。
   • 偏向锁适用于单线程访问同步代码块的场景。
3. 轻量级锁（Lightweight Locking）：
   • 当有多个线程竞争同一个锁时，偏向锁会升级为轻量级锁。
   • 轻量级锁使用自旋的方式尝试获取锁，减少线程上下文切换的开销。
   • 如果自旋成功，则直接获取锁；如果自旋失败，则升级为重量级锁。
4. 重量级锁（Heavyweight Locking）：
   • 当竞争激烈时，轻量级锁会升级为重量级锁。
   • 重量级锁依赖于操作系统的互斥锁（Mutex Lock），会导致线程阻塞和唤醒，开销较大。

(4) 锁的释放

• 当线程退出同步代码块时，会释放锁。
• JVM 会根据锁的状态（偏向锁、轻量级锁、重量级锁）进行相应的处理，恢复对象头的 Mark Word 状态。

ReentrantLock

ReentrantLock 是 Java 提供的一种可重入的互斥锁，它位于 java.util.concurrent.locks 包中，是 Lock 接口的一个实现类。相比于 synchronized 关键字，ReentrantLock 提供了更灵活、更强大的锁机制，适用于复杂的并发场景。

可重入锁（Reentrant Lock） 指的是一个线程可以多次获取同一个锁而不被自己阻塞。这意味着如果一个线程已经持有了某个锁，并尝试再次获取该锁，则该操作会成功，而不是导致死锁。每次获取锁时，锁内部的计数器会增加；每次释放锁时，计数器会减少；只有当计数器归零时，锁才会真正被释放，允许其他线程获取。

可重入

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {
    private final ReentrantLock lock = new ReentrantLock();

    public void firstMethod() {
        lock.lock();
        try {
            // 执行一些操作
            secondMethod();
        } finally {
            lock.unlock();
        }
    }

    public void secondMethod() {
        lock.lock();
        try {
            // 执行更多操作
        } finally {
            lock.unlock();
        }
    }
}

可打断

“可打断”（Interruptible）指的是线程在等待某种资源或处于阻塞状态时,是否能够响应中断请求并进行相应的处理.当一个线程处于不可打断的状态下（如通过某些同步机制等待获取锁）,它将不会响应中断信号；而在可打断状态下,线程可以捕获到中断请求,并根据应用逻辑决定如何处理这个中断.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

import java.util.concurrent.locks.ReentrantLock;

public class InterruptibleLockExample {
    private final ReentrantLock lock = new ReentrantLock();

    public void performTask() throws InterruptedException {
        try {
            System.out.println(Thread.currentThread().getName() + " is trying to acquire the lock.");
            // 尝试获取锁，但是可以响应中断
            lock.lockInterruptibly();
            try {
                System.out.println(Thread.currentThread().getName() + " has acquired the lock.");
                // 模拟任务处理
                Thread.sleep(5000);
            } finally {
                lock.unlock();
            }
        } catch (InterruptedException e) {
            System.out.println(Thread.currentThread().getName() + " was interrupted while waiting for the lock.");
            // 处理中断，通常这里需要做一些清理工作
            Thread.currentThread().interrupt(); // 重新设置中断标志
        }
    }

    public static void main(String[] args) throws InterruptedException {
        InterruptibleLockExample example = new InterruptibleLockExample();

        Thread t1 = new Thread(() -> {
            try {
                example.performTask();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "Worker-1");

        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(1000); // 让 t1 先开始尝试获取锁
                example.performTask();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "Worker-2");

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

        Thread.sleep(2000); // 主线程等待一段时间后中断 t2
        t2.interrupt();
    }
}

尝试获取锁

• boolean tryLock()
  • 尝试获取锁。如果锁可用，则立即获取并返回 true；否则返回 false。
• boolean tryLock(long timeout, TimeUnit unit)
  • 尝试在指定时间内获取锁。如果在超时前获取到锁，则返回 true；否则返回 false。

公平锁

ReentrantLock 默认是非公平锁。也就是说，当多个线程竞争锁时，默认情况下新来的线程可能会直接插队获取锁，而不需要严格按照线程等待的顺序（FIFO 队列）来分配锁。

公平锁与非公平锁的区别

1. 公平锁（Fair Lock）
   • 公平锁会按照线程请求锁的顺序（即 FIFO 队列）来分配锁。
   • 这种方式可以避免线程饥饿问题，但可能会导致性能下降，因为线程切换的开销较高。
2. 非公平锁（Non-Fair Lock）
   • 非公平锁允许插队，即新来的线程可以直接尝试获取锁，而不需要排队。
   • 这种方式减少了线程上下文切换的开销，提高了吞吐量，但在高并发场景下可能导致某些线程长时间无法获取锁（饥饿问题）。

与条件变量

在并发编程中，条件变量是一种用于线程间协调的机制。它允许一个或多个线程等待某个条件变为真，而不是忙等（busy-waiting）。在Java中，Condition 接口由 ReentrantLock 类提供支持，每个 ReentrantLock 可以创建多个 Condition 实例，从而实现更加灵活的线程控制。

Condition 接口的主要方法

• await()：使当前线程等待，并释放锁。直到其他线程调用 signal() 或 signalAll() 方法唤醒它。
• signal()：唤醒一个等待该条件的线程。如果有多个线程在等待，则选择其中的一个。
• signalAll()：唤醒所有等待该条件的线程。
• awaitUninterruptibly()：类似于 await()，但是不会响应中断。
• awaitNanos(long nanosTimeout)、awaitUntil(Date deadline)：带超时的等待方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

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

public class ProducerConsumerExample {
    private final Lock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();

    private final int[] buffer;
    private int count = 0;

    public ProducerConsumerExample(int size) {
        this.buffer = new int[size];
    }

    public void produce(int value) throws InterruptedException {
        lock.lock();
        try {
            while (count == buffer.length) { // Buffer is full
                notFull.await(); // Wait until buffer is not full
            }
            buffer[count] = value;
            count++;
            notEmpty.signal(); // Signal that buffer is not empty now
        } finally {
            lock.unlock();
        }
    }

    public int consume() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0) { // Buffer is empty
                notEmpty.await(); // Wait until buffer is not empty
            }
            count--;
            int value = buffer[count];
            notFull.signal(); // Signal that buffer is not full now
            return value;
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        ProducerConsumerExample example = new ProducerConsumerExample(5);

        Runnable producerTask = () -> {
            for (int i = 0; i < 10; i++) {
                try {
                    example.produce(i);
                    System.out.println("Produced: " + i);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        };

        Runnable consumerTask = () -> {
            for (int i = 0; i < 10; i++) {
                try {
                    int value = example.consume();
                    System.out.println("Consumed: " + value);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        };

        new Thread(producerTask).start();
        new Thread(consumerTask).start();
    }
}

volatile原理

volatile 是 Java 中的一个关键字，用于修饰变量，它提供了一种比锁更轻量级的同步机制。尽管 volatile 并不能替代 synchronized 关键字所提供的所有功能，但在某些特定场景下，它可以有效地保证线程间的可见性和有序性。

工作原理

1. 可见性：当一个线程对一个 volatile 变量进行写操作时，会将该变量立即刷新到主内存中。而当其他线程读取这个 volatile 变量时，它们会被强制从主内存中重新读取这个变量的最新值，而不是使用自己工作内存中的缓存副本。这就确保了所有线程都能看到最新的变量值。
2. 禁止指令重排序优化：Java 编译器和处理器可以对指令进行重排序以提高执行效率。然而，这种重排序可能会导致多线程环境下的程序出现意料之外的行为。volatile 变量可以防止编译器对涉及该变量的操作进行指令重排序，从而保持代码的预期执行顺序。

虽然 volatile 和原子类（如 AtomicInteger）都提供了线程安全的操作，但它们之间存在一些关键差异：

• 原子性：volatile 只能保证变量的可见性和有序性，不能保证复合操作（比如增加、减少）的原子性。而原子类通过使用 CAS（比较并交换）等硬件级别的原子操作来保证操作的原子性。
• 性能：由于 volatile 不需要像锁那样复杂的开销，因此在只涉及简单状态更新的情况下，它的性能通常优于基于锁的解决方案。但是，在需要进行复杂的状态转换或需要保证原子性的场景下，原子类可能是更好的选择。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

public class FlagExample {
    private static volatile boolean flag = false;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            System.out.println("Thread is waiting for the flag to be set.");
            while (!flag) {
                // 等待直到flag被设置为true
            }
            System.out.println("Flag has been set, thread is proceeding.");
        });

        t1.start();

        // 主线程暂停一段时间
        Thread.sleep(1000);

        // 设置标志位
        flag = true;
        System.out.println("Flag has been set by main thread.");
    }
}

volatile 适用于以下场景：

• 变量的写入不依赖于其当前值。
• 变量不需要与其他状态变量共同参与不变约束。
• 对变量的访问都是原子操作（例如，简单的布尔标志）。

自定义线程池

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

class ThreadPool {
    private BlockingQueue<Runnable> taskQueue;
    private HashSet<Worker> workers = new HashSet<>();
    private int coreSize; // 核心线程数
    private long timeout;
    private TimeUnit timeoutUnit;
    public ThreadPool(int coreSize, long timeout, TimeUnit timeoutUnit) {
        this.coreSize = coreSize;
        this.timeout = timeout;
        this.timeoutUnit = timeoutUnit;
    }
    public void execute(Runnable task) {
        synchronized (workers) {
            if(workers.size()<coreSize) {
                Worker worker = new Worker(task);
                workers.add(worker);
                worker.start();
            }else{
                taskQueue.put(task);
            }
        }

    }

    class Worker extends Thread {
        private Runnable task;
        public Worker(Runnable task) {
            this.task = task;
        }
        @Override
        public void run() {
            //1) task不为空
            while (this.task != null ||(task = taskQueue.take()) != null) {
                try {
                    task.run();
                }catch (Exception e) {
                    e.printStackTrace();
                }finally {
                    task = null;
                }
            }
            synchronized (workers) {
                workers.remove(this);
            }

        }

    }
}
class BlockingQueue<T> {
    private Deque<T> queue = new ArrayDeque<>();
    private ReentrantLock lock = new ReentrantLock();

    private Condition notEmptyWaitSet = lock.newCondition();
    private Condition emptyWaitSet = lock.newCondition();
    private int capacity;

    public T take() {
        lock.lock();
        try {
            while (queue.isEmpty()) {
                notEmptyWaitSet.await();
            }
            T t = queue.removeFirst();
            emptyWaitSet.signal();
            return t;
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            lock.unlock();
        }
    }

    public void put(T t) {
        lock.lock();
        try {
            while (queue.size() == capacity) {
                try {
                    emptyWaitSet.await();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            queue.addLast(t);
            notEmptyWaitSet.signal();
        } finally {
            lock.unlock();
        }
    }

    public T poll(long timeout, TimeUnit unit) {
        lock.lock();
       try {
           long nanos = unit.toNanos(timeout);
           while(queue.isEmpty()) {
               try {
                   if (nanos <= 0) {
                       return null;
                   }
                   nanos = notEmptyWaitSet.awaitNanos(nanos);
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
           }
           T t = queue.removeFirst();
              emptyWaitSet.signal();
              return t;
       }finally {
           lock.unlock();
       }
    }
}

使用JDK提供的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

import java.util.concurrent.*;

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 核心线程数
        int corePoolSize = 2;
        // 最大线程数
        int maximumPoolSize = 4;
        // 空闲线程存活时间
        long keepAliveTime = 10;
        // 时间单位
        TimeUnit unit = TimeUnit.SECONDS;
        // 任务队列
        BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(2);
        // 线程工厂
        ThreadFactory threadFactory = Executors.defaultThreadFactory();
        // 拒绝策略
        RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();

        // 创建线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            corePoolSize,
            maximumPoolSize,
            keepAliveTime,
            unit,
            workQueue,
            threadFactory,
            handler
        );

        // 提交任务
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executor.submit(() -> {
                System.out.println("Task " + taskId + " is running on thread " + Thread.currentThread().getName());
                try {
                    Thread.sleep(2000); // 模拟任务执行
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }

        // 关闭线程池
        executor.shutdown();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12

ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS,
               new LinkedBlockingQueue<Runnable>(), new ThreadPoolExecutor.DiscardPolicy());
       for (int i = 0; i < 10; i++) {
           Future<Integer> submit = threadPoolExecutor.submit(new MyCallable());
           try {
               System.out.println(submit.get());
           } catch (InterruptedException e) {
               throw new RuntimeException(e);
           } catch (ExecutionException e) {
               throw new RuntimeException(e);
           }
       }

1. corePoolSize：
   • 核心线程数，即线程池中始终保持的最小线程数量。
   • 即使这些线程处于空闲状态，也不会被销毁（除非设置了 allowCoreThreadTimeOut）。
2. maximumPoolSize：
   • 线程池允许的最大线程数。
   • 当任务队列已满且当前线程数小于 maximumPoolSize 时，线程池会创建新线程来处理任务。
3. keepAliveTime：
   • 空闲线程的存活时间。
   • 如果线程数超过 corePoolSize，多余的空闲线程会在空闲一段时间后被回收。
4. unit：
   • keepAliveTime 的时间单位，例如 TimeUnit.SECONDS。
5. workQueue：
   • 任务队列，用于保存等待执行的任务。
   • 常见实现包括：
     • ArrayBlockingQueue：有界队列。
     • LinkedBlockingQueue：无界队列。
     • SynchronousQueue：不存储任务，直接交给线程执行。
6. threadFactory：
   • 创建线程的工厂，用于自定义线程的名称、优先级等属性。
   • 默认使用 Executors.defaultThreadFactory()。
7. handler：
   • 拒绝策略，当线程池无法处理新任务时（例如线程池已满且任务队列已满），会调用此策略。
   • 常见实现包括：
     • AbortPolicy：抛出 RejectedExecutionException 异常。
     • CallerRunsPolicy：由调用线程（提交任务的线程）执行该任务。
     • DiscardPolicy：直接丢弃任务。
     • DiscardOldestPolicy：丢弃队列中最旧的任务，然后尝试重新提交新任务。

3. 线程池的工作原理

1. 任务提交：
   • 当一个任务被提交到线程池时，线程池会根据当前线程数和任务队列的状态决定如何处理任务。
2. 任务分配逻辑：
   • 如果当前线程数小于 corePoolSize，即使有空闲线程，也会创建新线程来执行任务。
   • 如果当前线程数等于或大于 corePoolSize，任务会被放入任务队列中等待。
   • 如果任务队列已满且当前线程数小于 maximumPoolSize，线程池会创建新线程来执行任务。
   • 如果任务队列已满且当前线程数等于 maximumPoolSize，则触发拒绝策略。
3. 线程回收：
   • 如果线程数超过 corePoolSize，多余的空闲线程会在空闲一段时间（keepAliveTime）后被回收

Executors

1. 创建固定大小的线程池 - newFixedThreadPool

该方法返回一个固定大小的线程池，适用于需要限制并发线程数的场景。

示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class FixedThreadPoolExample {
    public static void main(String[] args) {
        // 创建一个固定大小为3的线程池
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);

        for (int i = 0; i < 5; i++) {
            int taskId = i;
            fixedThreadPool.submit(() -> {
                System.out.println("Task " + taskId + " is running on thread " + Thread.currentThread().getName());
                try {
                    Thread.sleep(2000); // 模拟任务执行时间
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }

        // 关闭线程池
        fixedThreadPool.shutdown();
    }
}

• 线程池中的线程数量是固定的。
• 如果所有线程都在忙，新的任务将等待直到有空闲线程可用。

1. 创建单线程化的线程池 - newSingleThreadExecutor

该方法返回一个只有一个工作线程的线程池，适用于需要保证顺序执行任务的场景。

示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SingleThreadExecutorExample {
    public static void main(String[] args) {
        // 创建一个单线程化的线程池
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

        for (int i = 0; i < 5; i++) {
            int taskId = i;
            singleThreadExecutor.submit(() -> {
                System.out.println("Task " + taskId + " is running on thread " + Thread.currentThread().getName());
                try {
                    Thread.sleep(2000); // 模拟任务执行时间
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }

        // 关闭线程池
        singleThreadExecutor.shutdown();
    }
}

• 所有提交的任务按照提交顺序依次执行。
• 即使发生故障，也会重新创建一个线程来替代原来的线程继续处理后续任务。

1. 创建一个会根据需要创建新线程的线程池 - newCachedThreadPool

该方法返回一个可根据需要创建新线程的线程池，适用于执行大量短期异步任务的场景。

示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CachedThreadPoolExample {
    public static void main(String[] args) {
        // 创建一个缓存线程池
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

        for (int i = 0; i < 5; i++) {
            final int taskId = i;
            cachedThreadPool.submit(() -> {
                System.out.println("Task " + taskId + " is running on thread " + Thread.currentThread().getName());
                try {
                    Thread.sleep(2000); // 模拟任务执行时间
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }

        // 关闭线程池
        cachedThreadPool.shutdown();
    }
}

• 线程池可以根据需要创建新线程，并在空闲60秒后回收未使用的线程。
• 适合执行大量短期异步任务的应用程序。

1. 创建支持定时及周期性任务执行的线程池 - newScheduledThreadPool

该方法返回一个支持定时和周期性任务执行的线程池。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23