IO、多线程、反射授课文档

IO流、多线程、反射

IO流

Java 中的流（Stream）、文件（File）和 IO（输入输出）是处理数据读取和写入的基础设施，它们允许程序与外部数据（如文件、网络、系统输入等）进行交互。

java.io 包是 Java 标准库中的一个核心包，提供了用于系统输入和输出的类，它包含了处理数据流（字节流和字符流）、文件读写、序列化以及数据格式化的工具。

java.io 是处理文件操作、流操作以及低级别 IO 操作的基础包。

java.io 包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等。

一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示向一个目标写数据。

文件IO

// 字节流 - 适合图片、视频等
FileInputStream fileIn = new FileInputStream("file.jpg");
FileOutputStream fileOut = new FileOutputStream("copy.jpg");

// 字符流 - 适合文本文件
FileReader reader = new FileReader("text.txt");
FileWriter writer = new FileWriter("output.txt");

网络IO

URI uri = new URI("https://www.baidu.com");
InputStream inputStream = uri.toURL().openStream();

缓冲器流

// 缓冲字节流 - 性能更好
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("file.txt"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.txt"));

// 缓冲字符流 - 最常用文本处理方式
BufferedReader br = new BufferedReader(new FileReader("text.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"));

装饰器模式

装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。

装饰器模式通过将对象包装在装饰器类中，以便动态地修改其行为。

这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。

使用场景

• 当需要在不增加大量子类的情况下扩展类的功能。
• 当需要动态地添加或撤销对象的功能。

// 核心思想：装饰类和被装饰类实现相同的接口
public abstract class InputStream {
    public abstract int read() throws IOException;
}

// 被装饰的基类
public class FileInputStream extends InputStream {
    // 直接读取文件
}

// 装饰类
public class BufferedInputStream extends InputStream {
    private InputStream in;  // 持有被装饰对象的引用

    public BufferedInputStream(InputStream in) {
        this.in = in;  // 包装其他输入流
    }

    // 增强的功能：添加缓冲
    public int read() throws IOException {
        // 缓冲读取逻辑
        return in.read();
    }
}

装饰器的优点：

• 增强功能：在不修改原有类的基础上添加新功能

• 灵活组合：可以多层嵌套，按需组合功能

• 统一接口：所有装饰流都继承自相同的基类

• 透明性：使用时与普通流没有区别

多线程

Java 给多线程编程提供了内置的支持。

进程（Process）

一个进程包括由操作系统分配的内存空间，包含一个或多个线程。一个线程不能独立的存在，它必须是进程的一部分。一个进程一直运行，直到所有的非守护线程都结束运行后才能结束。

线程（Thread）

线程是进程中的⼀个实体，是被系统独⽴调度和分派的基本单位。⼀个进程可以由多个线程组成，它们共享进程的内存空间和资源，但每个线程拥有⾃⼰的执⾏堆栈和程序计数器。

实现

Java 提供了三种创建线程的方法：

• 通过实现 Runnable 接口；
  创建一个线程，最简单的方法是创建一个实现 Runnable 接口的类。为了实现 Runnable，一个类只需要执行一个方法调用 run()

  class RunnableDemo implements Runnable {
      private Thread t;
      private final String threadName;
  
      RunnableDemo(String name) {
          threadName = name;
          System.out.println("Creating " + threadName);
      }
  
      public void run() {
          System.out.println("Running " + threadName);
          try {
              for (int i = 4; i > 0; i--) {
                  System.out.println("Thread: " + threadName + ", " + i);
                  // 让线程睡眠一会
                  Thread.sleep(50);
              }
          } catch (InterruptedException e) {
              System.out.println("Thread " + threadName + " interrupted.");
          }
          System.out.println("Thread " + threadName + " exiting.");
      }
  
      public void start() {
          System.out.println("Starting " + threadName);
          if (t == null) {
              t = new Thread(this, threadName);
              t.start();
          }
      }
  }
  
  public class TestThread1 {
  
      public static void main(String[] args) {
          RunnableDemo R1 = new RunnableDemo("Thread-1");
          R1.start();
  
          RunnableDemo R2 = new RunnableDemo("Thread-2");
          R2.start();
      }
  }

• 通过继承 Thread 类本身；
  创建一个线程的第二种方法是创建一个新的类，该类继承 Thread 类，然后创建一个该类的实例。继承类必须重写 run() 方法，该方法是新线程的入口点。它也必须调用 start() 方法才能执行。该方法尽管被列为一种多线程实现方式，但是本质上也是实现了 Runnable 接口的一个实例。

  class ThreadDemo extends Thread {
      private Thread t;
      private final String threadName;
  
      ThreadDemo( String name) {
          threadName = name;
          System.out.println("Creating " +  threadName );
      }
  
      @Override
      public void run() {
          System.out.println("Running " +  threadName );
          try {
              for(int i = 4; i > 0; i--) {
                  System.out.println("Thread: " + threadName + ", " + i);
                  // 让线程睡眠一会
                  Thread.sleep(50);
              }
          }catch (InterruptedException e) {
              System.out.println("Thread " +  threadName + " interrupted.");
          }
          System.out.println("Thread " +  threadName + " exiting.");
      }
  
      public void start () {
          System.out.println("Starting " +  threadName );
          if (t == null) {
              t = new Thread (this, threadName);
              t.start ();
          }
      }
  }
  
  public class TestThread2 {
  
      public static void main(String[] args) {
          ThreadDemo T1 = new ThreadDemo( "Thread-1");
          T1.start();
  
          ThreadDemo T2 = new ThreadDemo( "Thread-2");
          T2.start();
      }
  }

• 通过 Callable 和 Future 创建线程。

1. 创建 Callable 接口的实现类，并实现 call() 方法，该 call() 方法将作为线程执行体，并且有返回值。

2. 创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。

3. 使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。

4. 调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值。

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

public class TestThread3 implements Callable<Integer> {
    public static void main(String[] args) {
        TestThread3 tt = new TestThread3();
        FutureTask<Integer> ft = new FutureTask<>(tt);
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " 的循环变量i的值" + i);
            if (i == 20) {
                new Thread(ft, "有返回值的线程").start();
            }
        }
        try {
            System.out.println("子线程的返回值：" + ft.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

    }

    @Override
    public Integer call() {
        int i = 0;
        for (; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
        return i;
    }
}

对于上述三种实现总结：

首选实现Runnable，继承 Thread 几乎没有必要；

直接 new Thread 适合演示与非常小的使用场景；

Callable + Future/FutureTask 提供结果、异常、取消能力，是 Runnable 的升级。

最佳现代方案：ExecutorService + Callable 或 CompletableFuture；

在 JDK 21+，可考虑虚拟线程进一步简化。

线程安全

我们需要多个线程同时访问一个类时，程序仍能正确工作。

// 非线程安全示例
public class UnsafeCounter {
 private int count = 0;
 // 简单地增加计数器的值
public void increment() {
 count++;
  }

 // 获取当前计数器的值
    public int getCount() {
        return count;
    }
    public static void main(String[] args) throws InterruptedException {
        UnsafeCounter unsafeCounter = new UnsafeCounter();
        // 创建并启动两个线程，都对同⼀个计数器进⾏操作
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                unsafeCounter.increment();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                unsafeCounter.increment();
            }
        });
        t1.start();
        t2.start();
        // 等待两个线程都执⾏完毕
        t1.join();
        t2.join();
        // 输出最终的计数器值
        System.out.println("预期值: 20000");
        System.out.println("实际值: " + unsafeCounter.getCount());
    }
 }

考虑⼀个简单的整数加法操作，如 count = count + 1。

尽管这看起来是⼀条简单的语句，但在多数处理器上，这个操作涉及下⾯⼏个步骤：

1. 从内存中读取 count 的当前值。

2. 在处理器中增加该值。

3. 将新值写回内存。如果两个线程同时执⾏这个操作，那么可能出现以下情况：

   • 线程A读取 count 的值为1。

   • 线程B也读取 count 的值为1。

   • 线程A增加值到2，并写回内存。

   • 线程B也增加值到2，并写回内存。

在这种情况下，虽然 count = count + 1 被执⾏了两次，但 count 的值只从1变到2

为了避免这种情况，可以使用Java提供的同步关键字`synchronized，在任何时候最多只能由⼀个线程进⼊，这样就可以保证increment ⽅法在count++ 操作的线程安全性。

public synchronized void increment() {
 count++;
 }

另一种写法修饰代码块

public void increment() {
synchronized (this){
++count;
}
}

在规范上：

• 建议使⽤共享资源作为锁对象

• 对于实例⽅法建议使⽤this 作为锁对象

• 对于静态⽅法建议使⽤类对象作为锁对象 类名.class

线程池（Executor）

自JDK 1.5开始提供线程池，并且默认提供了4种线程池的实例——Executors提供了静态方法用于生成线程池实例。

线程池：顾名思义，就是一个池子，里面管理着多个线程。你只需要把任务提交给线程池，而无需关心线程的创建和销毁。线程池会复用线程来执行任务。

为什么使用线程池

• 降低资源消耗：通过重复利用已创建的线程，减少线程创建和销毁造成的消耗。

• 提高响应速度：当任务到达时，任务可以不需要等到线程创建就能立即执行。

• 提高线程的可管理性：线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。

四种实例

// 1. 固定大小线程池（80%场景用这个）
ExecutorService fixedPool = Executors.newFixedThreadPool(10);

// 2. 缓存线程池（线程存活时间为60s，在最后一次任务执行完毕60s后没有新工作，则回收线程）
ExecutorService cachedPool = Executors.newCachedThreadPool();

// 3. 单线程池（实际上就是固定大小线程池（1）的情况）
ExecutorService singlePool = Executors.newSingleThreadExecutor();

// 4. 周期性执行任务的线程池
ScheduledExecutorService scheduledPool = Executors.newScheduledThreadPool(5);

提交任务的两种方式

// 方式1：执行无返回值的任务
executor.execute(() -> {
    System.out.println("执行任务");
});

// 方式2：执行有返回值的任务
Future<String> future = executor.submit(() -> {
    return "任务结果";
});

// 获取结果（会阻塞直到任务完成）
String result = future.get();

虚拟线程

虚拟线程（Virtual Threads）是Java 19引入的预览特性，并在Java 21中成为正式特性。它们旨在以更低的资源开销实现高并发，特别适用于I/O密集型任务。

// 方式1：直接启动
Thread virtualThread = Thread.ofVirtual()
    .start(() -> {
        System.out.println("虚拟线程执行任务");
    });

// 方式2：创建但不启动
Thread unstarted = Thread.ofVirtual()
    .unstarted(() -> System.out.println("未启动的虚拟线程"));
unstarted.start();

由于虚拟线程非常的轻量，所以无需再通过线程池优化。

异步模型

在实际业务中，其实我们更应该关注异步编程模型，而把多线程更多的看作实现细节。

反射

反射 在 Java 中，反射是⼀种强⼤的机制，它允许程序在运⾏时检查或修改其⾃身⾏为。使⽤反射，程序能够访问类的属性和⽅法，即使在编译时这些类的名称并未明确给出。这使得 Java 程序可以在运⾏时动态地创建对象、调⽤⽅法、改变字段等，即便这些类、⽅法或字段在编写原始代码时不可知。

工作流程

1. 获取 Class 对象：首先获取目标类的 Class 对象。
2. 获取成员信息：通过 Class 对象，可以获取类的字段、方法、构造函数等信息。
3. 操作成员：通过反射 API 可以读取和修改字段的值、调用方法以及创建对象。

// 举例：输出⼀个类所有的字段和⽅法
public class test1 {
    int field1;

    void method1() {
    }

    void method2() {
    }

    public static void main(String[] args) throws
            InterruptedException, Exception {
        Class<?> clazz = test1.class;
        for (Field field : clazz.getDeclaredFields()) {
            System.out.println("Field: " + field.getName());
        }//输出字段名
        for (Method method : clazz.getDeclaredMethods()) {
            System.out.println("Method: " + method.getName());
        }//输出方法名
    }
}

注解

注解（Annotations）是从 Java 5 开始引⼊的⼀种元数据形式，它们提供了⼀种为代码添加信息的⽅法，但不直接影响代码的执⾏。注解可以被⽤于类、⽅法、变量、参数和Java包等。使⽤注解的主要⽬的是提供信息给编译器，进⾏代码分析，或者通过运⾏时反射机制实现特定功能。

注解很大程度上需要配合反射才能发挥作用

定义注解

public @interface MyAnnotation {
    String value() default "默认值";
 }

使⽤注解

@MyAnnotation(value = "example")    
 public class MyClass {
 }

// 举例：定义并读取注解
@Test2.MyAnnotation(value = "自定义值")
public class Test2 {

    public static void processAnnotations(Object obj) {
        Class<?> clazz = obj.getClass();

        // 读取类上的注解
        MyAnnotation classAnnotation = clazz.getAnnotation(MyAnnotation.class);

        if (classAnnotation != null) {
            System.out.println("找到注解: " + classAnnotation.value());
        } else {
            System.out.println("未找到注解，使用默认值: " + "默认值");
        }
    }


    @Retention(RetentionPolicy.RUNTIME)
    public @interface MyAnnotation {
        String value() default "默认值";
    }

    public static void main(String[] args) {
        Test2 test2 = new Test2();
        processAnnotations(test2);
    }
}

缺点

• 性能开销：由于反射涉及动态解析的类型，因此⽆法执⾏某些 Java 虚拟机优化。 因此，反射操作的性能要⽐⾮反射操作的性能要差，应该在性能敏感的应⽤程序中频繁调⽤的代码段中避免。

• 破坏封装性：反射调⽤⽅法时可以忽略权限检查，因此可能会破坏封装性⽽导致安全问题。

• 内部曝光：由于反射允许代码执⾏在⾮反射代码中⾮法的操作，例如访问私有字段和⽅法，所以反射的使⽤可能会导致意想不到的副作⽤，这可能会导致代码功能失常并可能破坏可移植性