Advanced Features⚓︎

Exception Handling and Assertions⚓︎

Exception⚓︎

异常(exception) 是程序运行过程中出现的非正常情况，以对象的形式包装错误信息，通过抛出和捕获机制让开发者能够优雅地处理程序故障。

• 异常类型：

  

  • Java 的所有异常继承自 Throwable 具体类，该类提供了以下方法：

    • String getMessage();
    • String toString();
    • void printStackTrace();
    • void printStackTrace(PrintStream);

  • Exception 类表示异常，描述由程序和外部条件导致的错误，可以在程序中被捕获和处理

    • RuntimeException 类表示运行时异常，由程序错误导致，需要修改代码才能修复
      • 比如不良的转型、访问越界数组、数值错误等

  • Error 类表示系统错误(system errors)

    • JVM 发生了不可恢复的故障，例如内存溢出
    • 这种错误很少发生，若发生，只能通知用户，并尝试优雅地终止程序

• 异常还可以分为：

  • 未检查型（或非受检）异常(unchecked exception)：包括 RuntimeException、Error 以及它们的子类，在多数情况下反映了程序中不可恢复的逻辑错误
    • NullPointerException：在给引用变量分配对象之前通过该引用变量访问对象时抛出
    • IndexOutOfBoundsException：访问数组中超出数组边界的元素时抛出
    • 为了避免过度使用 try-catch 块而变得繁琐，Java 不强制要求编写代码来捕获这类异常

  • 检查型（或受检）异常(checked exception)：其他所有异常，此时编译器会强制程序员检查和处理异常

    • 如果一个方法声明了检查型异常，那么调用它的时候必须将其放在 try-catch 块中，或者通过声明抛出该异常
    例子

    void p1() {
        try {
            p2();
        }
        catch (IOException ex) {
            ...
        }
    }
    

    void p1() throws IOException {
        p2();
    }
    

• 声明异常：每个方法必须说明它可能抛出的检查型异常类型

  public void myMethod() 
  throws IOException, OtherException
  

• 抛出异常：当程序检测到错误时，程序可以创建一个适当异常类型的实例并抛出它

  • 何时该抛出异常：
    • 方法中发生异常
    • 若希望调用者处理该异常，应该创建一个异常对象并将其抛出
    • 如果可以在发生异常的方法中处理它，则无需抛出

  throw new TheException();
  
  TheException ex = new TheException();
  throw ex;
  

  例子

  public void setRadius(double newRadius)
  throws IllegalArgumentException {
      if (newRadius >= 0)
          radius = newRadius;
      else
          throw new IllegalArgumentException(
                      "Radius cannot be negative");
  }
  

• 捕捉异常：

  try {
      // Statements that may throw exceptions
  } catch (Exception1 exVar1) {
      // handler for exception1;
  } catch (Exception2 exVar2) {
      // handler for exception2;
  }
  ...
  catch (ExceptionN exVar3) {
      // handler for exceptionN;
  }
  

  • 可以使用多个 catch 语句来捕获 try 语句块中可能发生的多种异常
  • 异常发生后，JVM 会由上而下来检测当前 catch 语句块所捕获的异常是否与 try 语句块中某个发生的异常匹配；若匹配，则不执行其他的 catch 语句块
  • 如果多个 catch 语句块捕获的是同种类型的异常，则捕获子类异常的 catch 语句块要放在捕获父类异常的 catch 语句块前面

• 重新抛出异常：

  try {
      // statements;
  } catch(TheException ex) {
      // perform operations before exits;
      throw ex;
  }
  

• finally 子句：无论程序使用何种方式退出 try-catch 块，该子句内的代码都会被执行

  try {
      // statements;
  } catch (TheException ex) {
      // handling ex;
  } finally {
      // finalStatements;
  }
  

  • 更具体的，finally 块会在以下情况发生之后执行：

    • try 块中的代码正常执行完毕
    • 在 try 块中抛出异常
    • 在 try 块中执行return ,break , continue
    • catch 块中代码执行完毕
    • 在 catch 块中抛出异常
    • 在 catch 块中执行return ,break , continue

  • ⚠️注意：如果在 catch 块中抛出异常（或者 return 等情况），则 try-catch 块之后的代码不会执行，但是 finally 中的代码始终会执行

    例子

    try {
        statement1;
        statement2;
        statement3;
    } catch(Exception1 ex) {
        handling ex;
    } catch(Exception2 ex) {
        handling ex;
        throw ex;        // (1)
    } finally {
        finalStatements;
    }
    
    Next statement;      // (2)
    

    1. 重新抛出异常，将控制权转移给调用者
    2. 这条语句不会执行，因为已经抛出异常了

  • 使用 finally 块释放资源

  • finally 块不能抛出异常
    • 因为如果在 finally 块中抛出异常，try-catch 块的异常就不能抛出，外部捕捉到的异常就是 finally 块中的异常信息，而 try-catch 块中发生的真正的异常栈信息则丢失了

• try 语句块不可以单独存在，但可以只有try + finally语句块

• 抛出自定义异常异常时带上原始异常信息

• 打印异常信息时带上异常栈

  public void method3() {
      try {
          method2();
      } catch(MyException e) {
          // 对异常进行处理
          e.printStackTrace(); // 打印异常信息
      }
  }
  

• 守护线程中需要捕捉 RuntimeException

  • 守护线程是指在需要长时间运行的线程，其生命周期一般和整个程序的时间一样长，用于提供某种持续的服务
  • 因此需要对 RuntimeException 进行保护，避免因为某一次偶发的异常而导致线程被终止

• 使用异常时需注意：异常处理通常需要更多的时间和资源，因为它需要实例化一个新的异常对象、回滚调用栈并将错误传播到调用方法

  • 所以不要用异常来处理简单的且在预期内的情况

• 定义自定义异常类

  • 尽可能使用 API 中已有的异常类
  • 如果预定义的类不够用，通过扩展 Exception 或其子类来定义自定义异常类
  例子

  /** 自定义异常类，用于处理无效的半径输入 */
  public class InvalidRadiusException extends Exception {
      private double radius;
  
      /** 构造一个异常对象 */
      public InvalidRadiusException(double radius) {
          super("Invalid radius: " + radius);
          this.radius = radius;
      }
  
      /** 返回触发异常的半径值 */
      public double getRadius() {
          return radius;
      }
  }
  
  /** 包含半径设置逻辑的类 */
  public class CircleWithRadiusException {
      /** 圆的半径 */
      private double radius;
  
      /** 设置新半径，如果半径小于 0 则抛出自定义异常 */
      public void setRadius(double newRadius) throws InvalidRadiusException {
          if (newRadius >= 0) {
              radius = newRadius;
          } else {
              throw new InvalidRadiusException(newRadius);
          }
      }
  }
  

• 嵌套：可以将一套完整的 try-catch-finally 结构放入另一个try / catch / finally块中，但要注意：

  • try：如果内层 catch 成功捕获了异常，外层 catch 就不会再感知到这个错误
  • catch：可以缓减 catch 块异常处理失败造成的影响
  • finally：不建议这么做，因为其内部 catch 块会覆盖原来的异常信息

• 如果父类方法没有声明任何异常，子类在重写该方法时不能声明任何检查型异常，但子类依然可以声明抛出任何非检查型异常

Assertions⚓︎

断言(assertions) 包含一个布尔表达式，该表达式应在程序执行期间为真，可用于确保程序正确性并避免逻辑错误。

• 声明：使用 assert 关键字

  assert assertion;
  assert assertion : detailMessage;
  

  其中 assertion 是布尔表达式，detailMessage 是基本类型或 Object 值

• 执行：

  • Java 会评估断言；如果为假，将抛出 AssertionError 异常
  • AssertionError 类有一个无参构造函数和七个重载的单参数构造函数，参数类型分别为 int、long、float、double、boolean、char 和 Object
  • 对于没有详细信息的断言语句，使用无参的 AssertionError 构造函数
  • 对于带有详细信息的断言语句，使用合适的 AssertionError 构造函数以匹配消息的数据类型
  • 由于 AssertionError 是 Error 的子类，当断言为假时，程序会在控制台显示消息并退出
  例子

  public class AssertionDemo {
      public static void main(String[] args) {
          int i; int sum = 0;
          for (i = 0; i < 10; i++) {
              sum += i;
          }
          assert i == 10;
          assert sum > 10 && sum < 5 * 10 : "sum is " + sum;
      }
  }
  

• 运行带断言的程序：

  • 默认情况下在运行时禁用断言
  • 要启用断言，需要使用 –enableassertions 或 -ea 选项
  • 还可以手动禁用断言：使用 –disableassertions 或 -da 选项

I/O⚓︎

• File 类：用于文件名及其目录路径的包装类

  • 它提供了一个抽象，以机器无关的方式处理文件和路径名的大部分机器相关复杂性

  • 属性和方法汇总：

    

  • 它封装了文件或路径的属性，但不包含用于从 / 向文件读取 / 写入数据的方法

• 存储数据的两种方式：

  • 文本格式：字符序列，是人类可读的形式
  • 二进制格式：用字节表示的数据项

• System 标准流

  • System.in：标准输入（键盘），字节输入流
  • System.out：标准输出（控制台），打印输出流
  • System.err：标准错误输出（控制台红字），也是打印输出流

Text I/O⚓︎

Basics⚓︎

• 文本 I/O 需要编码和解码：JVM 在写入字符时将 Unicode 转换为文件特定的编码，在读取字符时将文件特定的编码转换为 Unicode

• 使用 java.io.PrintWriter 写数据

  PrintWriter(filename: String)     // 为指定文件创建 PrintWriter 对象
  print(s: String): void
  print(c: char): void
  print(cArray: char[]): void
  print(i: int): void
  print(l: long): void
  print(f: float): void
  print(d: double): void
  print(b: boolean): void
  

  • 它还包含重载的 println 和 printf 方法，用法同 print，但 println 支持换行，printf 支持格式字符串（之前介绍过）

  • 可以指定字符集，否则会使用运行这个程序的机器的默认编码，可能在不同的机器上有不同的表现

    PrintWriter out = new PrintWriter("myfile.txt", "UTF-8");
    

  例子

  import java.io.PrintWriter;
  import java.io.File;
  
  public class WriteData {
      public static void main(String[] args) throws Exception {
          File file = new File("scores.txt");
          if (file.exists()) {
              System.out.println("File already exists");
              System.exit(0);
          }
  
          // 创建文件
          PrintWriter output = new PrintWriter(file);
  
          // 向文件写入格式化输出
          output.print("John T Smith ");
          output.println(90);
          output.print("Eric K Jones ");
          output.println(85);
  
          // 关闭文件
          output.close();
      }
  }
  

• 使用 java.util.Scanner 读数据（前面也详细介绍过）

Advanced Text I/O⚓︎

• Reader 是读取字符流的抽象类，Writer 是写入字符流的抽象类

  /** Reader */
  // 读取单个字符
  int read()
  // 将字符读入数组
  int read(char[] cbuf)
  // 将字符读入数组的某一部分
  abstract int read(char[] cbuf, int off, int len)
  // 跳过字符
  long skip(long n)
  // 关闭该流并释放与之关联的所有资源
  abstract void close()
  
  /** Writer */
  // 写入字符数组
  void write(char[] cbuf)
  // 写入字符数组的某一部分
  abstract void write(char[] cbuf, int off, int len)
  // 写入单个字符
  void write(int c)
  // 写入字符串
  void write(String str)
  // 写入字符串的某一部分
  void write(String str, int off, int len)
  // 将指定字符添加到此 writer
  Writer append(char c)
  // 将指定字符序列添加到此 writer
  Writer append(CharSequence csq)
  // 将指定字符序列的子序列添加到此 writer
  Writer append(CharSequence csq, int start, int end)
  // 关闭此流，但要先刷新它
  abstract void close()
  // 刷新该流的缓冲
  abstract void flush()
  

• InputStreamReader：字节流转字符流

  // 构造方法:
  // 创建一个使用默认字符集的 InputStreamReader
  InputStreamReader(InputStream in)
  
  // 创建使用给定字符集的 InputStreamReader
  InputStreamReader(InputStream in, Charset cs)
  
  // 创建使用给定字符集解码器的 InputStreamReader
  InputStreamReader(InputStream in, CharsetDecoder dec)
  
  // 创建使用指定字符集的 InputStreamReader
  InputStreamReader(InputStream in, String charsetName)
  
  // 特有方法:
  // 返回此流使用的字符编码的名称
  String getEncoding()
  

• OutputStreamWriter：字符流转字节流

  // 构造方法:
  // 创建一个使用默认字符编码的 OutputStreamWriter
  OutputStreamWriter(OutputStream out)
  
  // 创建使用给定字符集的 OutputStreamWriter
  OutputStreamWriter(OutputStream out, Charset cs)
  
  // 创建使用给定字符集编码器的 OutputStreamWriter
  OutputStreamWriter(OutputStream out, CharsetEncoder enc)
  
  // 创建使用指定字符集的 OutputStreamWriter
  OutputStreamWriter(OutputStream out, String charsetName)
  
  // 特有方法:
  // 返回此流使用的字符编码的名称
  String getEncoding()
  

• BufferedReader、BufferedWriter：字符缓冲流

  /** BufferedReader */
  // 构造方法:
  // 创建一个使用默认大小输入缓冲区的缓冲字符输入流
  BufferedReader(Reader in)
  // 创建一个使用指定大小输入缓冲区的缓冲字符输入流
  BufferedReader(Reader in, int sz)
  // 特有方法:
  // 读取一个文本行
  String readLine()
  
  /** BufferedWriter */
  // 构造方法:
  // 创建一个使用默认大小输出缓冲区的缓冲字符输出流
  BufferedWriter(Writer out)
  // 创建一个使用给定大小输出缓冲区的缓冲字符输出流
  BufferedWriter(Writer out, int sz)
  // 特有方法:
  // 写入一个行分隔符
  void newLine()
  

• FileReader：InputStreamReader 类的直接子类，用来读取字符文件，使用默认字符编码

  // 构造函数
  FileReader(File file)             // 用 File 对象来构造 FileReader
  FileReader(FileDescriptor fd)     // 用文件描述符构造 FileReader
  FileReader(String fileName)       // 用文件的路径名来构造FileReader
  
  public String getEncoding()       // 返回这个流使用的编码方式
  

• FileWriter：OutputStreamWriter 类的直接子类，用来写入字符文件，使用默认字符编码

  // 还是用 File 对象构造，如果第二个参数为 true 的话，
  // 表示以追加的方式写数据，从文件尾部开始写起
  FileWriter(File file, boolean append)
  // 用文件描述符来构造 FileWriter
  FileWriter(FileDescriptor fd)
  // 用文件描述符来构造，第二个参数为 true 的话，表示以追加的形式写入数据
  FileWriter(FileDescriptor fd, boolean append)
  // 用文件的路径名来构造 FileWriter
  FileWriter(String fileName)
  // 用文件路径名来构造 FileWriter，第二个参数为 true 的话，表示以追加的形式写入文件
  FileWriter(String fileName, boolean append)
  

Binary I/O⚓︎

Basics⚓︎

二进制 I/O 不需要额外的转换。

• 将一个字节写入文件时，原始字节会被复制到文件中
• 从文件中读取一个字节时，将返回文件中的确切字节

二进制 I/O 类：

• InputStream

  // 从输入流中读取下一个字节的数据
  // 返回的字节值为 0 到 255 范围内的 int 值
  // 如果没有可用的字节，因为已到达流的末尾，则返回值 -1
  read(): int
  
  // 从输入流中读取最多 b.length 字节到数组 b，并返回实际读取的字节数
  // 流结束时返回 -1
  read(b: byte[]): int
  
  // 从输入流中读取字节并存储到 b[off], b[off+1], ..., b[off+len-1]
  // 返回实际读取的字节数
  // 在流的末尾返回 -1
  read(b: byte[], off: int, len: int): int
  
  available(): int             // 返回可以从输入流中读取的字节数
  close(): void                // 关闭此输入流并释放与该流相关的任何系统资源
  skip(n: long): long          // 跳过并丢弃此输入流中的 n 字节数据，实际跳过的字节数将被返回
  markSupported(): boolean     // 测试此输入流是否支持 mark 和 reset 方法
  mark(readlimit: int): void   // 标记此输入流中的当前位置
  reset(): void                // 将此流重新定位到上次在该输入流上调用 mark 方法时的位置
  

  • 如果在流的末尾继续读取数据，将会发生 EOFException；所以要用 input.available() 来检查文件结束，当 input.available() == 0 时表示文件结束

• OutputStream

  // 将指定的字节写入此输出流，参数 b 是一个整数值
  // (byte) b 被写入输出流
  write(int b): void
  
  // 将数组 b 中的所有字节写入输出流
  write(b: byte[]): void
  
  // 将 b[off], b[off+1], ..., b[off+len-1] 写入输出流
  write(b: byte[], off: int, len: int): void
  
  close(): void    // 关闭此输出流并释放与该流相关的任何系统资源
  flush(): void    // 刷新此输出流，并强制将任何缓冲的输出字节写出
  

• FileInputStream

  • 构造函数：

    public FileInputStream(String filename)
    public FileInputStream(File file)
    

    尝试创建一个不存在的文件的 FileInputStream 时，将发生 java.io.FileNotFoundException

• FileOutputStream

  • 构造函数：

    public FileOutputStream(String filename)
    public FileOutputStream(File file)
    public FileOutputStream(String filename, boolean append)
    public FileOutputStream(File file, boolean append)
    

  • 如果文件不存在，将会创建一个新文件

  • 如果文件已经存在，
    • 前两个构造函数将删除文件中的当前内容
    • 要保留当前内容并将新数据追加到文件中，请使用最后两个构造函数，并将 true 传递给 append 参数

• 过滤器流(filter streams) 是用于某种目的过滤字节的流

  • 基本的字节输入流提供了只能用于读取字节的读取方法
  • 如果想要读取整数、双精度浮点数或字符串，需要一个过滤器类来包装字节输入流
  • FilterInputStream 和 FilterOutputStream 是过滤数据的基类
  • 当需要处理基本数值类型时，使用 DataInputStream 和 DataOutputStream 来过滤字节

• DataInputStream：从流中读取字节，并将它们转换为适当的基本类型值或字符串

  • 继承自 FilterInputStream，并实现 DataInput 接口
  • 其构造函数的参数必须是 InputStream 或其子类（比如 FileInputStream 或 System.in）

  • 方法：

    readBoolean(): boolean
    readByte(): byte
    readChar(): char
    readFloat(): float
    readDouble(): double
    readInt(): int
    readLong(): long
    readshort(): short
    readLine(): String
    readUTF(): String
    

  • 注意：必须以存储的相同顺序和格式读取数据

• DataOutputStream：将基本类型值或字符串转换为字节，并将字节输出到流中

  • 继承自 FilterOutputStream，并实现 DataOutput 接口
  • 其构造函数的参数必须是 OutputStream 或其子类（比如 FileOutputStream 或 System.out）

  • 方法：

    writeBoolean(b: boolean): void
    writeByte(v: int): void
    writeBytes(s: String): void
    writeChar(c: char): void
    writeChars(s: String): void
    writeFloat(v: float): void
    writeDouble(v: double): void
    writeInt(v: int): void
    writeLong(v: long): void
    writeShort(v: short): void
    writeUTF(s: String): void
    

• BufferedInputStream / BufferedOutputStream：

  • 没有包含新方法，所有方法继承自InputStream / OutputStream类
  • 但它们利用缓冲区加速 I/O

  • 构造函数：

    // Create a BufferedInputStream
    public BufferedInputStream(InputStream in)
    public BufferedInputStream(InputStream in, int bufferSize)
    
    // Create a BufferedOutputStream
    public BufferedOutputStream(OutputStream out)
    public BufferedOutputStream(OutputStreamr out, int bufferSize)
    

Object I/O⚓︎

ObjectInputStream / ObjectOutputStream能执行对象的 I/O：

• ObjectInputStream 继承自 InputStream，并实现了 ObjectInput 和 ObjectStreamConstants 接口
• ObjectOutputStream 继承自 OutputStream，并实现了 ObjectOutput 和 ObjectStreamConstants 接口

• 构造函数：

  // Create an ObjectInputStream
  public ObjectInputStream(InputStream in)
  
  // Create an ObjectOutputStream
  public ObjectOutputStream(OutputStream out)
  

Serializable⚓︎

• Serializable 接口：

  • 并非所有对象都可以写入输出流，而可以写入对象流的对象被认为是可序列化的(serializable)
  • 可序列化对象是 java.io.Serializable 接口的实例，因此可序列化对象的类必须实现 Serializable
  • Serializable 接口是一个标记接口(markder interface)，它没有方法，因此您需要在实现 Serializable 的类中添加额外代码
  • 实现此接口使 Java 序列化机制能够自动处理存储对象和数组的过程
  • 凡是实现 Serializable 接口的类都有一个表示序列化版本标识符的变量：private static final long serialVersionUID，它是根据类名、接口名、成员方法及属性等生成的一个 64 位哈希字段
  • static 字段在序列化时会被跳过，因为它不属于任何对象实例

• trasient 关键字：

  • 一个包含不可序列化的实例数据字段的 Serializable 的对象不可以被序列化
  • 要使此类对象能够被序列化，可以使用 transient 关键字标记这些数据字段，以告诉 JVM 在将对象写入对象流时忽略这些字段
  例子

  public class Foo implements java.io.Serializable {
      private int v1;
      private static double v2;
      private transient A v3 = new A();
  }
  class A { } // A is not serializable
  

  • 当 Foo 类的对象被序列化时，只有变量 v1 被序列化
  • 变量 v2 没有被序列化，因为它是一个静态变量
  • 变量 v3 没有被序列化，因为它被标记为 transient
  • 如果 v3 没有被标记为 transient，将会发生 java.io.NotSerializableException

• 序列化数组：

  • 当数组中的所有元素可序列化时，该数组可序列化
  • 此时整个数组可以通过 writeObject 写入文件，之后可使用 readObject 恢复
  例子

  public class TestObjectStreamForArray {
      public static void main(String[] args)
          throws ClassNotFoundException, IOException {
          int[] numbers = {1, 2, 3, 4, 5};
          String[] strings = {"John", "Susan", "Kim"};
  
          try ( // 为 array.dat 创建一个输出流
              ObjectOutputStream output = new ObjectOutputStream(new 
                  FileOutputStream("array.dat", true));
          ) {
              // 将数组写入对象输出流
              output.writeObject(numbers);
              output.writeObject(strings);
          }
  
          try ( // 为 array.dat 创建一个输入流
              ObjectInputStream input = 
                  new ObjectInputStream(new FileInputStream("array.dat"));
          ) {
              int[] newNumbers = (int[])(input.readObject());
              String[] newStrings = (String[])(input.readObject());
  
              // 显示数组内容
              for (int i = 0; i < newNumbers.length; i++)
                  System.out.print(newNumbers[i] + " ");
              System.out.println();
  
              for (int i = 0; i < newStrings.length; i++)
                  System.out.print(newStrings[i] + " ");
          }
      }
  }
  

• 反序列化后的对象不需要调用构造函数重新构造

• 序列前的对象与序列化后的对象地址不同，并且实现了深拷贝

The RandomAccessFile Class⚓︎

前面介绍的所有流被称为只读或只写流，而且这些流的外部文件是顺序(sequential) 文件，无法在不创建新文件的情况下进行更新，通常需要修改文件或向文件中插入新记录。而 Java 提供了 RandomAccessFile 类，支持从随机位置读取和写入文件。

RandomAccessFile(file: File, mode: String)
RandomAccessFile(name: String, mode: String)
close(): void
// 返回从文件开头到下一个 read 或 write 发生位置的偏移量（以字节为单位）
getFilePointer(): long
length(): long
read(): int
read(b: byte[]): int
read(b: byte[], off: int, len: int): int
// 设置从流的开始到下一个 read 或 write 发生的位置的偏移量（以 pos 中指定的字节为单位）
seek(pos: long): void
// 为文件设置新长度
setLength(newLength: long): void
// 跳过 n 字节的输入
skipBytes(int n): int
write(b: byte[]): void
write(b: byte[], off: int, len: int): void

随机访问文件中有一个特殊的标记，称为文件指针(file pointers)。

• 读写操作发生在文件指针的位置
• 当文件被打开时，文件指针设置在文件的开头
• 向文件读取或写入数据时，文件指针会向前移动到下一个数据

许多 RandomAccessFile 中的方法与 DataInputStream 和 DataOutputStream 中的方法相同，比如 readInt()、readLong()、writeDouble()、readLine()、writeInt() 和 writeLong() 可以在数据输入流或数据输出流以及 RandomAccessFile 流中使用。

Piped I/O⚓︎

PipedOutputStream 和 PipedInputStream 分别是管道输出流和管道输入流，它们的作用是让多线程可以通过管道进行线程间的通讯。在使用管道通信时，必须将 PipedOutputStream 和 PipedInputStream 配套使用，并且在不同的线程中使用（否则会引起死锁）。

使用管道通信时，大致的流程是：

• 在线程 A 中向 PipedOutputStream 中写入数据，这些数据会自动的发送到与 PipedOutputStream对 应的 PipedInputStream中，进而存储在 PipedInputStream 的缓冲中
• 此时，线程 B 通过读取 PipedInputStream 中的数据，这样就可以实现线程 A 和线程 B 的通信

PipedReader 和 PipedWriter 也是管道输入流和输出流。它们和PipedInputStream / PipedOutputStream区别是前者操作的是字符，后者是字节。两者的 API 几乎相同，都能输出各种形式的数据，构造函数也几乎相同。

Generics⚓︎

泛型(generics) 是参数化类型(parameterized types) 的特性。利用这个特性，我们可以定义一个具有泛型类型的类或方法，编译器可以使用具体类型来替换这些泛型类型。其关键优点是能够让错误在编译时被检测出来。

• 自定义泛型类

  
  实现部分

  public class GenericStack<E> {
      private java.util.ArrayList<E> list = new java.util.ArrayList<E>();
  
      public int getSize() {
          return list.size();
      }
  
      public E peek() {
          return list.get(getSize() - 1);
      }
  
      public void push(E o) {
          list.add(o);
      }
  
      public E pop() {
          E o = list.get(getSize() - 1);
          list.remove(getSize() - 1);
          return o;
      }
  
      public boolean isEmpty() {
          return list.isEmpty();
      }
  
      @Override
      public String toString() {
          return "stack: " + list.toString();
      }
  }
  

  • 支持多个类型参数

    public class Pair<U, V> {
        U first;
        V second;
        // ...
    }
    

• 泛型方法（注意返回类型是带尖括号的，表示新声明的类型参数，而不是使用类提供的类型参数）

  public static <E> void print(E[] list) {
      for (int i = 0; i < list.length; i++)
          System.out.print(list[i] + " ");
      System.out.println();
  }
  

  • 调用（可在介于点号和方法名之间的位置显式指出类型参数）：

    Integer[] integers = {1, 2, 3, 4, 5};
    String[] strings = {"London", "Paris", "New York", "Austin"};
    GenericMethodDemo.<Integer>print(integers);
    GenericMethodDemo.<String>print(strings);
    

  • 若编译器能推断出所调用的方法，则可以省略类型参数

    GenericMethodDemo.print(integers);
    GenericMethodDemo.print(strings);
    

  • 也支持多个类型参数

    public static <U, V> Pair<U, V> makePair(U first, V second) {
        Pair<U, V> pair = new Pair<>(first, second);
        return pair;
    }
    

• 泛型接口

  public interface Comparable<T> {
      public int compareTo(T o);
  }
  

• 有界泛型类型(bounded generic type)

  例子

  public static void main(String[] args ) {
      Rectangle rectangle = new Rectangle(2, 2);
      Circle circle = new Circle (2);
      System.out.println("Same area? " + equalArea(rectangle, circle));
  }
  
  public static <E extends GeometricObject> boolean
  equalArea(E object1, E object2) {
      return object1.getArea() == object2.getArea();
  }
  

  <E extends GeometricObject> 表示 E 必须是 GeometricObject 或其子类

• 参数化类型没有实际类型参数的继承关系

  
  • 举例：List<Integer> list = new List<Object>(); 会发生编译错误，反之依然
  • 泛型的继承关系需要通过通配符实现

• 通配符(wildcards)：

  • 无限制通配符(unbounded wildcards) <?>：用于代表某种不确定的类型
    • 当只需要处理与具体类型无关的逻辑（例如获取 List 的长度）时非常有用
    • 从这种容器中取出的元素只能被视为 Object 类型
  • 上限通配符(upper bounded wildcards) <? extends T>：限定了类型的上界
    • 它表示类型必须是 T 类型本身或者是它的子类
    • 例子：使用 List<? extends Number> 时，可以确定从中读取出的数据一定是 Number 类型
  • 下限通配符(lower bounded wildcards) <? super T>：限定了类型的下界
    • 它表示类型必须是 T 类型本身或者是它的父类
    • 例子：当需要往容器中存放 T 类型的对象时，使用 List<? super T> 可以确保容器能够兼容该类型

• 泛型的类型擦除(type erasure) 机制

  • 编译器使用泛型类型信息来编译代码，但随后会将其擦除，因此运行时无法获取泛型信息
  • 这使得泛型代码能够与使用基本类型的遗留代码向后兼容
  例子

  List<String> l1 = new ArrayList<>();
  ArrayList<Integer> l2 = new ArrayList<>();
  System.out.println(l1.getClass() == l2.getClass());
  

  程序输出 true。

  • 由于类型擦除，ArrayList<String> 和 ArrayList<Integer> 在运行时的 Class 对象其实都是同一个 java.util.ArrayList
  • 而 getClass() 方法返回对象在运行时的实际类型

• 泛型类为其所有实例共享，不管这些实例的实际类型是什么

  例子

  GenericStack<String> stack1 = new GenericStack<String>();
  GenericStack<Integer> stack2 = new GenericStack<Integer>();
  

  尽管 GenericStack<String> 和 GenericStack<Integer> 是两种类型，但只有一个 GenericStack 类被加载到 JVM 中。

• 限制：

  • 不能创建泛型类型的实例

    • 例子：E object = new E(); 会报错

  • 不允许用泛型类型来创建泛型数组

    • 例子：E[] elements = new E[100];
    • 可以用 E[] elements = (E[]) new Object[100] 来规避，但仍有一个编译警告

  • 泛型类的静态上下文中不能使用类型参数

    • 泛型类的所有实例都有相同的运行时类，所以泛型类的静态变量和方法是被它的所有实例共享的
    • 所以在静态方法、数据域或初始化语句中，为了类而引用泛型参数是非法的
    例子

    public class Test<E>{
        public static void m(E o1){ // illegal
        }
        static {
            E o2;
        }
    }
    

  • 泛型类不能继承 java.io.Throwable，也就是说异常类不能是泛型类

    • JVM 必须检查 try 子句中抛出的异常类型是否与 catch 子句中指定的类型匹配，但（如果用了泛型）在运行期间类型信息不知道
    例子

    try {
        doSomeStuff();
    } catch (SomeException<Integer> e) {
        // ignore that
    } catch (SomeException<String> e) {
        crashAndBurn()
    }
    

    SomeException<Integer> 和 SomeException<String> 都被擦除为同一类型，JVM 无法区分异常实例，因此无法确定应该执行哪个 catch 块。

Collections⚓︎

容器(collections) 是一个容器对象，表示一组通常称为元素的对象。

Set 和 List 是 Collection 的子接口。而 Map 类和 Collection 类是平级的关系。

Collection 接口是操作对象容器的根接口：

The Set Interface⚓︎

Set 接口继承自 Collection 接口。

• 它没有引入新的方法或常量，但它规定 Set 实例不包含重复元素，即集合中不会存在两个元素 e1 和 e2，使得 e1.equals(e2) 为 true

  • 如果重复添加元素，程序不会抛出异常

• Set 接口层级结构：

  

• AbstractSet 类

  • 继承了 AbstractCollection 并实现了 Set 接口
  • 为 equals 方法和 hashCode 方法提供了具体实现，从而确保元素不重复
  • 集合的哈希码是集合中所有元素哈希码的总和
  • 由于没有实现 size 方法和 iterator 方法，因此它是一个抽象类

• HashSet 类

  • 一个实现了 Set 接口具体类
  • 为了提高效率，添加到哈希集合中的对象需要以适当的方式实现 hashCode 方法，以便正确分配哈希码
  • 容器内元素顺序与插入顺序无关
  • 集合元素可以是 null，但只能放入一个 null

  // 实例化
  HashSet<E> set = new HashSet<>(); // 默认容量和加载因子
  HashSet<E> setWithCapacity = new HashSet<>(int initialCapacity); // 指定初始容量
  
  // 添加与删除
  public boolean add(E e);        // 添加元素，若已存在则返回 false
  public boolean remove(Object o); // 删除元素，若不存在则返回 false
  
  // 查询与判断
  public int size();              // 返回元素个数
  public boolean isEmpty();       // 判断是否为空
  public boolean contains(Object o); // 判断是否包含某元素
  
  // 清空与迭代
  public void clear();            // 清空所有元素
  public Iterator<E> iterator();  // 获取迭代器
  

• LinkedHashSet 类

  • 继承了 HashSet 类，同样是根据元素的 hashCode 值来决定元素的存储位置，但是它同时使用双向链表维护元素的次序，使得元素看起来像是以插入顺序保存的
  • 因为用链表维护顺序，所以在迭代访问集合中的全部元素时，性能比 HashSet 好，但是插入时性能稍微差于 HashSet
  • 方法签名同 HashSet

• SortedSet 接口

  • Set 的子接口，保证集合内的元素是有序的 (sorted)

• TreeSet 类

  • 唯一实现 SortedSet 接口的具体类
  • 可以利用迭代器按顺序遍历元素

  • 元素可以以两种方式进行排序：

    • 自然排序：使用 Comparable 接口
    • 定制排序：若没有实现 Comparable 接口，或不想在实现 Comparable 接口的类中使用 compareTo 方法，可以为集合中的元素指定一个比较器(comparator)
    自定义比较器

    比较器是一个实现 java.util.Comparator 接口的类。Comparator 接口有两个方法：compare 和 equals。

    • public int compare(Object element1, Object element2)：

      • 如果 element1 小于 element2，则返回负值
      • 如果 element1 大于 element2，则返回正值
      • 如果它们相等，则返回零

    • public boolean equals(Object element)

      • 如果指定的对象也是一个比较器，并且施加与此比较器相同的排序，则返回 true

  // 实例化
  TreeSet<E> treeSet = new TreeSet<>(); // 自然顺序排序
  TreeSet<E> customSet = new TreeSet<>(Comparator<? super E> comparator); // 自定义排序
  
  // 基础增删查（时间复杂度为 O(log n)）
  public boolean add(E e);        // 按排序顺序插入元素
  public boolean remove(Object o); // 移除元素并重新平衡红黑树
  public boolean contains(Object o); // 查找元素
  
  // 特有的范围与极值查找
  public E first();               // 返回最小（第一个）元素
  public E last();                // 返回最大（最后一个）元素
  public E lower(E e);            // 返回小于 e 的最大元素
  public E higher(E e);           // 返回大于 e 的最小元素
  public E floor(E e);            // 返回小于等于 e 的最大元素
  public E ceiling(E e);          // 返回大于等于 e 的最小元素
  
  // 视图与迭代
  public NavigableSet<E> descendingSet(); // 返回逆序视图
  public Iterator<E> iterator();          // 按升序遍历
  

The List Interface⚓︎

列表(lists) 允许在容器 (collection) 中存储重复元素，并且可以指定元素的存放位置，随后可通过索引访问该元素。

迭代器模式

迭代器(iterator) 模式：一种对象行为型模式，提供一个对象来顺序访问容器对象中的一系列数据，而不暴露容器对象的内部表示。

优点

• 访问一个容器对象的内容而无须暴露它的内部表示
• 遍历任务交由迭代器完成，这简化了容器类
• 它支持以不同方式遍历一个聚合，甚至可以自定义迭代器的子类以支持新的遍历
• 增加新的容器类和迭代器类都很方便，无须修改原有代码
• 封装性良好，为遍历不同的容器结构提供一个统一的接口

缺点

增加了类的个数，这在一定程度上增加了系统的复杂性。

列表迭代器(list iterators) ListIterator：

• 它是一种更加强大的 Iterator 的子类型，但只能用于各种 List 类的访问
• 其最大优点是可以双向移动
• 它还可以产生相对于迭代器在列表中指向的当前位置的前一个和后一个元素的索引，并且可以使用 set() 方法替换它访问过的最后一个元素

迭代器 it 的三个基本操作：

• it.next()：返回迭代器的下一个元素，并且更新迭代器的状态
• it.hasNext()：用于检测容器中是否还有元素
• it.remove()：将迭代器返回的元素删除

List 接口的具体实现：

• ArrayList

  
  • 基于动态数组实现，按插入顺序来保存和访问数据
  • 用途：需要通过索引支持随机访问，而不在末尾之外的位置插入或删除元素（虽然支持，但效率不高，所以不建议这么做）

  // 实例化
  ArrayList<E> list = new ArrayList<>(); // 默认初始容量为 10
  ArrayList<E> listWithCapacity = new ArrayList<>(int initialCapacity); // 指定初始容量
  
  // 增删改查
  public boolean add(E e);           // 在末尾添加元素
  public void add(int index, E element); // 在指定位置插入元素
  public E remove(int index);        // 删除指定索引处的元素
  public boolean remove(Object o);   // 删除首次出现的指定元素
  public E set(int index, E element); // 修改指定索引处的元素
  public E get(int index);           // 获取指定索引处的元素
  
  // 状态与搜索
  public int size();                 // 返回元素个数
  public boolean isEmpty();          // 判断是否为空
  public int indexOf(Object o);      // 返回元素首次出现的索引
  public boolean contains(Object o);  // 判断是否包含某元素
  
  // 调整与转换
  public void trimToSize();          // 将容量调整为当前元素个数
  public void ensureCapacity(int minCapacity); // 手动扩容
  public Object[] toArray();         // 转换为数组
  

  ArrayList 中迭代器的陷阱

  • 在迭代过程中，调用容器的删除方法，则会抛出异常
  • 因为迭代器内部会维护索引位置相关的数据，在迭代过程中，容器不能发生结构性变化（添加 / 插入 / 删除元素）
  • 解决方案：使用迭代器自带的删除方法（it.remove()）

  例子

  Iterator<String> it = list.iterator();
  while (it.hasNext()) {
      String value = it.next();
      if ("target".equals(value)) {
          it.remove();
      }
  }
  

• LinkedList

  
  • 基于双向链表实现

  • 用途：需要在列表的任何位置插入或删除元素

    // LinkedList 支持所有 ArrayList 定义的方法，下面仅列举 LinkedList 独有的方法
    // 针对首尾元素的特有方法（ArrayList 不具备）
    public void addFirst(E e);    // 在链表头部添加元素
    public void addLast(E e);     // 在链表尾部添加元素
    public E getFirst();          // 获取第一个元素
    public E getLast();           // 获取最后一个元素
    public E removeFirst();       // 移除并返回第一个元素
    public E removeLast();        // 移除并返回最后一个元素
    
    // 栈与队列操作（实现 Deque 接口）
    public boolean offer(E e);    // 将元素添加到末尾
    public E poll();              // 移除并返回头元素，为空时返回 null
    public E peek();              // 返回头元素但不移除
    public void push(E e);        // 将元素推入栈顶（头部）
    public E pop();               // 将元素从栈顶（头部）弹出
    

The Collections Class⚓︎

Collections 类包含了用于操作容器 (collections) 和映射、用于创建同步(synchronized) 容器类和只读(read-only) 容器类等的各种静态方法。

// 排序与位置操作
public static void sort(List<T> list);                          // 自然升序排序
public static void sort(List<T> list, Comparator<? super T> c); // 自定义比较器排序
public static void reverse(List<?> list);                       // 反转顺序
public static void shuffle(List<?> list);                       // 随机打乱
public static void swap(List<?> list, int i, int j);            // 交换两个索引处的元素
public static void rotate(List<?> list, int distance);          // 循环移动元素

// 查找与统计
public static int binarySearch(List<? extends T> list, T key);  // 二分查找（需先排序）
public static T max(Collection<? extends T> coll);              // 返回最大元素
public static T min(Collection<? extends T> coll);              // 返回最小元素
public static int frequency(Collection<?> c, Object o);          // 统计元素出现次数
public static int indexOfSubList(List<?> source, List<?> target); // 查找子列表首次出现位置
public static int lastIndexOfSubList(List<?> source, List<?> target); // 查找子列表末次出现位置

// 替换与修改
public static void fill(List<? super T> list, T obj);           // 使用指定元素填充整个列表
public static boolean replaceAll(List<T> list, T oldVal, T newVal); // 替换所有指定的旧值
public static void copy(List<? super T> dest, List<? extends T> src); // 将源列表内容复制到目标列表

// 线程安全化包装（返回同步视图）
public static List<T> synchronizedList(List<T> list);
public static Set<T> synchronizedSet(Set<E> s);
public static Map<K,V> synchronizedMap(Map<K,V> m);

// 不可变与特殊容器
public static List<T> unmodifiableList(List<? extends T> list); // 返回只读列表
public static Set<T> unmodifiableSet(Set<? extends T> s);       // 返回只读集合
public static List<T> emptyList();                              // 获取空的不可变列表
public static <T> List<T> nCopies(int n, T o);                  // 返回包含 n 个相同对象的不可变列表
public static <E> Set<E> singleton(E o);                        // 返回仅含一个元素的不可变容器

// 检查与约束
public static boolean disjoint(Collection<?> c1, Collection<?> c2); // 判断两容器是否有交集
public static <E> Collection<E> checkedCollection(Collection<E> c, Class<E> type); // 运行时类型检查包装

The Vector Class⚓︎

在 Java 2 中，Vector 与 ArrayList 相同，不同之处在于 Vector 包含用于访问和修改向量的同步方法。

到目前为止，引入的新容器数据结构都不是同步的；如果需要同步，可以使用容器 (collections) 类的同步版本。

The Stack Class⚓︎

Stack 类表示一个后进先出（LIFO）的对象栈。元素只能从栈顶访问，并且可以从栈顶检索、插入或删除一个元素。

The Queue Interface⚓︎

队列(queue) 是一种先进先出（FIFO）的数据结构。元素被添加到队列的末尾，并从队列的开头移除。

The PriorityQueue Interface⚓︎

在优先队列(priority queue) 中，元素被分配优先级。当访问元素时，具有最高优先级的元素会首先被移除。

The Map Interface⚓︎

Map 接口将键映射到元素，此时键就像索引。但不同于 List，键可以是任何对象。

Map 的具体类：

• HashMap

  • 在查找值、插入映射和删除映射方面都很高效
  • 容器内元素是无序的

  // 实例化
  HashMap<K, V> map = new HashMap<>(); // 默认初始容量 16，加载因子 0.75
  HashMap<K, V> mapWithCapacity = new HashMap<>(int initialCapacity); // 指定初始容量
  
  // 基础增删改查
  public V put(K key, V value);      // 存储键值对，若键已存在则覆盖旧值并返回旧值
  public V get(Object key);          // 根据键获取值，不存在则返回 null
  public V remove(Object key);       // 根据键移除键值对
  public void clear();               // 清空所有映射
  
  // 状态判断
  public int size();                 // 返回键值对的数量
  public boolean isEmpty();          // 判断是否为空
  public boolean containsKey(Object key);   // 判断是否包含指定键
  public boolean containsValue(Object value); // 判断是否包含指定值
  
  // 视图与遍历
  public Set<K> keySet();            // 获取包含所有键的 Set 视图
  public Collection<V> values();     // 获取包含所有值的 Collection 视图
  public Set<Map.Entry<K, V>> entrySet(); // 获取包含所有键值对的 Set 视图
  
  // 默认值处理（Java 8+）
  public V getOrDefault(Object key, V defaultValue); // 获取值，若不存在则返回默认值
  public V putIfAbsent(K key, V value); // 仅在键不存在时才插入
  

• LinkedHashMap

  • 继承自 HashMap，通过链表实现，支持对映射元素的排序，可以按它们被插入映射中的顺序（称为插入顺序）或最后访问的顺序，从最近最少访问到最近访问（访问顺序）进行检索
  • 无参构造函数构造一个按插入顺序的 LinkedHashMap
  • 要构造一个按访问顺序的 LinkedHashMap，请使用 LinkedHashMap(initialCapacity, loadFactor, true)
  • 方法签名和 HashMap 基本一致

• TreeMap

  • 实现了 SortedMap，适合以排序顺序遍历键（根据键的大小）
  • 和 TreeSet 类似，也有自然排序和定制排序两种方式

  // TreeMap 支持所有 HashMap 定义的方法，下面仅列举 TreeMap 独有的方法
  // 排序相关的实例化
  TreeMap<K, V> treeMap = new TreeMap<>(); // 自然顺序排序
  TreeMap<K, V> customMap = new TreeMap<>(Comparator<? super K> comparator); // 自定义比较器
  
  // 获取极值键值对
  public Map.Entry<K,V> firstEntry();    // 返回键最小的键值对
  public Map.Entry<K,V> lastEntry();     // 返回键最大的键值对
  public K firstKey();                   // 返回最小的键
  public K lastKey();                    // 返回最大的键
  
  // 范围检索与邻近查找
  public Map.Entry<K,V> lowerEntry(K key);   // 查找严格小于指定键的最大键值对
  public Map.Entry<K,V> higherEntry(K key);  // 查找严格大于指定键的最小键值对
  public Map.Entry<K,V> floorEntry(K key);   // 查找小于或等于指定键的最大键值对
  public Map.Entry<K,V> ceilingEntry(K key); // 查找大于或等于指定键的最小键值对
  
  // 子集视图
  public SortedMap<K,V> subMap(K fromKey, K toKey); // 返回指定范围内的子映射
  public SortedMap<K,V> headMap(K toKey);           // 返回小于 toKey 的部分
  public SortedMap<K,V> tailMap(K fromKey);         // 返回大于等于 fromKey 的部分
  
  // 逆序视图
  public NavigableMap<K,V> descendingMap(); // 返回键按降序排列的映射视图
  

  如何遍历 Map

  注意

  Map 不能直接使用 Iterator 遍历！

  • foreach + Lambda 表达式（形式最简单）

    map.forEach((key, value) -> {
        System.out.println("key: " + key + ", value: " + value);
    });
    

  • 遍历 entrySer()（性能最优）

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

  • 仅遍历键或值

    for (String key : map.keySet()) { ... }    // only for keys
    for (String value : map.values()) { ... }  // only for values
    

The Arrays Class⚓︎

Arrays 类包含用于排序和搜索数组、比较数组、填充数组元素、将数组转换为列表等的静态方法。

EnumSet and EnumMap⚓︎

• EnumSet

  • 一个与枚举类型一起使用的专用 Set 实现，其所有元素都必须来自单个枚举类型（即必须是同类型，且该类型是 Enum 的子类）
  • EnumSet 是一个抽象类，只能通过它提供的静态方法来返回 EnumSet 的实现类的实例

  • 两种不同的实现：

    • 如果 EnumSet 大小 < 64，就返回 RegularEnumSet 实例（继承自 EnumSet），这个 EnumSet 实际上只用了一个 long 来存储 EnumSet
    • 如果 EnumSet 大小 >= 64，则返回 JumboEnumSet 实例，它使用一个 long[] 来存储
    • 这样做的好处很明显：大多数情况下返回的 RegularEnumSet效率比 JumboEnumSet 高很多

  • EnumSet 的效率比 HashSet 等效率高

• EnumMap

  • 也是 Map 接口的实现，映射中的键是 Enum 类型
  • 用其它的 Map 实现（如 HashMap）也能完成枚举类型实例到值得映射，但是使用 EnumMap 会更加高效：它只能接收同一枚举类型的实例作为键值，并且由于枚举类型实例的数量相对固定并且有限，所以 EnumMap 使用数组来存放与枚举类型对应的值
  • EnumMap 的键不允许为 null，但值可以为 null，按照键在枚举中的顺序进行保存
  • 非线程安全

Multithreading⚓︎

Threads⚓︎

• 创建任务和线程：

  • 继承 Thread 类：简单，但受限于 Java 的单继承机制
  • 实现 Runnable 接口：它能实现代码与线程的解耦，不过无法返回执行结果
  • 实现 Callable 接口：它支持返回值和抛出异常，通常结合线程池使用，并通过 Future 对象获取结果
  • 虚拟线程：具备轻量级和内存占用小的特点，特别适合网络请求等 IO 密集型任务，能有效提升吞吐量；但对于计算密集型任务则不具备优势
  例子

  

  • 作为任务的类实现了 Runnable 接口，重写了 run() 方法（注意不要搞错方法签名）
    • run() 方法包含了线程的执行逻辑，所以要想让线程做有意义的事就一定得重写该方法
    • 不强制重写，但不重写的话该线程启动后会立马结束
  • 其实例作为参数传递给 Thread 构造函数

• thread.start() 会启动一个全新的线程，线程进入 RUNNABLE 状态（但不一定立即执行）；能够实现真正的并发执行

• thread.run() 不会创建任何新线程，仅在当前线程中按顺序执行代码（因此一般不会用它）
• 静态方法 public static native Thread currentThread(); 返回当前执行的线程对象

• 获取线程的 id 和名称：

  public long getId();
  public final String getName();  // 返回 "main" 或 "Thread-N"（从 0 开始递增）
  

• Java 线程的生命周期

  
  • 其中 RUNNABLE 状态包含就绪(ready) 和运行(running) 中两个子状态，所以进入 RUNNABLE 状态的进程并不一定会立即执行（也许 CPU 核心还在处理其他高优先级的线程，或者时间片尚未分配给该线程）

• Thread 类：

  
  • Thread.yield() 静态方法：使当前运行中的线程主动放弃对 CPU 资源的使用权，即进入就绪状态（Runnable）；不会释放锁
  • Thread.sleep(long mills) 静态方法：使调用此方法的当前线程休眠指定的毫秒数，但实际休眠时间可能会超过 mills；不会释放锁

  • anotherThread.join()：强制当前线程（调用该方法的线程）等待另一个线程（anotherThread）完成；此时当前线程会释放其持有的 anotherThread 的锁，但其他锁不会释放

    例子

    

  • isAlive()：用于确定线程状态

    • 如果线程处于就绪、阻塞或运行状态，则返回 true
    • 如果线程是新创建且尚未启动或已结束，则返回 false

  • interrupt()：通过以下方式改变线程的中断状态（不会中断一个正在运行的线程）：

    • 如果线程当前处于就绪或运行状态，则其中断标志被设置
    • 如果线程当前被阻塞（Object.wait, Thread.join和 Thread.sleep 三种情况之一），则会被唤醒并进入就绪状态，并抛出 java.io.InterruptedException
    • 因此该方法能中断阻塞状态的线程

  • isInterrupted()：检查线程的中断标志是否被设置；不会清除中断标志

    • interrupt() 配合 isInterrupted() 能够中断非阻塞状态的线程

  • 守护 (daemon) 线程

    public final void setDaemon(Boolean on)
    public final boolean isDaemon()
    

    • 一般程序只有在所有线程都结束时才退出，但守护线程除外；当整个程序中剩下的都是守护线程时，程序才会退出
    • 守护线程一般为辅助线程，当主线程退出时，它就没有存在的意义了，如垃圾回收线程

  • 线程优先级

    • 每个线程被赋予一个默认优先级 Thread.NORM_PRIORITY，可以使用 setPriority(int priority) 重置

    • 相关常量

      Thread.MIN_PRIORITY
      Thread.MAX_PRIORITY
      Thread.NORM_PRIORITY
      

    • 高优先级的可运行线程不一定会抢占低优先级线程，高优先级只能说明线程获取 CPU 的概率更大

  • 弃用方法：stop()（终止线程）, suspend(), resume()