Java多线程基础（线程的四种实现方式）

现代操作系统（ Windows ， macOS ， Linux ）都可以执行多任务。多任务就是同时运行多个任务。例如：播放音乐的同时，浏览器可以进行文件下载，同时可以进行QQ消息的收发。 CPU 执行代码都是一条一条顺序执行的，但是，即使是单核 CPU ，也可以同时运行多个任务。因为操作系统执行多任务实际上就是让 CPU 对多个任务轮流交替执行。操作系统轮流让多个任务交替执行，例如，让浏览器执行 0.001 秒，让QQ执行 0.001 秒，再让音乐播放器执行 0.001 秒。在用户使用的体验看来， CPU 就是在同时执行多个任务。

2，进程与线程：

2.1，什么是程序

程序是含有指令和数据的文件，被存储在磁盘或其他的数据存储设备中，可以理解为程序是包含静态代码的文件。

2.2，什么是进程

进程是程序的一次执行过程，是系统运行程序的基本单位。在 Windows 系统中，每一个正在执行的 exe 文件或后台服务，都是一个进程，由操作系统统一管理并分配资源，因此进程是动态的。我们打开任务管理器可以看到：

以上这些都是进程。

2.3，什么是线程

某些进程内部还需要同时执行多个子任务。例如，我们在使用 WPS 时， WPS 可以让我们一边打字，一边进行拼写检查，同时还可以在后台进行自动保存和上传云文档，我们把子任务称为线程。线程是进程划分成的更小的运行单位。

进程和线程的关系就是：一个进程可以包含一个或多个线程，但至少会有一个主线程。

从这张图我们可以看出一个操作系统里有若干个进程（Process），每个进程里有若干个线程（Thread）。

2.4，进程与线程的区别

根本区别：进程是操作系统资源分配的基本单位，而线程是处理器任务调度和执行的基本单位；

资源开销：每个进程都有独立的代码副本和数据空间，进程之间的切换，资源开销较大；线程可以看做轻量级的进程，每个线程都有自己独立的运行栈和程序计数器，线程之间切换，资源开销小；

包含关系：一个进程内包含有多个线程，在执行过程，线程的执行不是线性串行的，而是多条线程并行共同完成；

内存分配：同一进程内的所有线程共享本进程的内存空间和资源；进程之间的内存空间和资源相互独立；

影响关系：一个进程崩溃后，在保护模式下不会对其他进程产生影响；一个线程崩溃，会导致整个进程退出。所以多进程要比多线程健壮；

执行过程：每个独立的进程有程序运行的入口和程序出口。但是线程不能独立执行，必须依存在应用程序（进程）中，由应用程序提供多个线程执行控制；

2.5，JVM进程

JVM进程的内存区域分配：

多个线程共享 JVM 进程的 Heap （堆区）和 Metaspace （元空间）资源，但每个线程有自己的程序计数器、虚拟机栈和本地方法栈。

JVM进程有哪些线程组成：

public class Main {
    public static void main(String[] args) {
        // 获取 Java 线程管理对象 ThreadMXBean
        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
        // 不需要获取的锁监视器 lockedMonitor 和 synchronizer 信息
        // 仅获取线程和线程信息
        ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false, false);    
        // 遍历线程信息，仅打印线程 ID 和线程名称信息
        for (ThreadInfo threadInfo : threadInfos) {
             System.out.println("[" + threadInfo.getThreadId() + "] " +
             threadInfo.getThreadName());
         }
    }
}

3，线程的基本概念

单线程：单线程就是进程中只有一个线程。单线程在程序执行时，所走的程序路径按照连续顺序排下来，前面的必须处理好，后面的才会执行。

多线程：由一个以上的线程组成的程序称为多线程程序。Java中，一定是从主线程开始执行（main方法），然后在主线程的某个位置创建并启动新的线程。

4，线程的创建与启动

创建方式：

方式一：继承Java.lang.Thread类（线程子类）

// 线程子类
public class SubThread extends Thread {
     public void run() {
         for (int i = 0; i < 10000; i++) {
             System.out.println("子线程" + i + " ");
         }
     }
}
// 主线程main
public class MultiThread {
     public static void main(String[] args) {
         //创建并启动子线程
         SubThread thd = new SubThread();
         thd.start();
 
         //主线程继续同时向下执行
         for (int i = 0; i < 10000; i++) {
             System.out.println("主线程" + i + " ");
         }
     }
}

方式二：实现java.lang.Runnable接口（线程执行类）

// 线程执行类
public class SubThread implements Runnable {
     public void run() {
         for (int i = 0; i < 10000; i++) {
             System.out.println("子线程" + i + " ");
         }
     }
}
// 主线程 main
public class MultiThread {
     public static void main(String[] args) {
         //创建并启动子线程
         Thread t = new Thread(new SubThread());
         t.start();
         //主线程继续同时向下执行
         for (int i = 0; i < 10000; i++) {
             System.out.println("主线程" + i + " ");
         }
     }
}

方式三：实现java.lang.Callable接口，允许子线程返回结果，抛出异常。

// 实现子线程
public class SubThread implements Callable<Integer>{
     private int begin,end;
     public SubThread(int begin,int end){
         this.begin = begin;
         this.end = end;
     }

     @Override
     public Integer call() throws Exception {
         int result = 0;
         for(int i=begin;i<=end;i++){
             result+=i;
         }
         return result;
     }
}

// 主线程
public class MultiThread {
     public static void main(String[] args) {

            // 子线程封装为FutureTask对象,计算1-100的累加和
            SubThread subThread1 = new SubThread(1,100);
            FutureTask<Integer> task1 = new FutureTask<>(subThread1);

            // 子线程封装为FutureTask对象,计算101-200的累加和
            SubThread subThread2 = new SubThread(101,200);
            FutureTask<Integer> task2 = new FutureTask<>(subThread2);

            // 分别启动两个子线程
            new Thread(task1).start();
            new Thread(task2).start();

            // 分别获取两个子线程的计算结果
            int sum1 = task1.get();
            int sum2 = task2.get();

            // 汇总计算结果
            int total = sum1 + sum2
     }
}

方式四：线程池创建：

// 创建固定大小的线程池
ExecutorService threadPool = Executors.newFixedThreadPool(10);
while (true) {
     // 提交多个执行任务至线程池，并执行
     threadPool.execute(new Runnable() {
     @Override
     public void run() {
         System.out.println("当前运行的线程名为： " +
         Thread.currentThread().getName());
         try {
             Thread.sleep(1000);
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
     }
  });
}