线程的实现方式

什么是线程？

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

那什么是进程呢？

进程是程序的一次执行过程，是系统运行程序的基本单位。在Windows系统中，每一个正在执行的exe文件或后台服务，都是一个进程，由操作系统统一管理并分配资源，因此进程是动态的。 例如：正在运行中的浏览器就是一个进程，正在运行中的音乐播放器是另一个进程，同理，正在运行中的QQ和WPS等都是进程。
操作系统运行一个程序，即是一个进程从创建，运行到消亡的过程。简单来说，一个进程就是一个执行中的程序，它在计算机中一个指令接着一个指令地执行着， 同时，每个进程还占有某些系统资源如 CPU时间，内存空间，文件，输入输 出设备的使用权等。

进程和线程的关系是什么呢

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

线程创建启动、

通过创建Thread实例，完成线程的创建。线程的内部实现可以通过继承Thread类、实现Runnable接口等方式进行封装。通过调用Thread实例的start()方法启动新线程。查看Thread类的源代码，会看到start()方法内部调用了一个private native void start0()方法，native修饰符表示这个方法是由JVM虚拟机内部的C代码实现的本地方法，由JVM根据当前操作系统进行本地实现。

public class Main {
    public static void main(String[] args) {
        // Step1: main主线程执行输出
        System.out.println("main start...");
        
        // Step2: main主线程，创建子线程sub，输出字母A-Z
        Thread sub = new Thread() {
            // Step4：子线程被执行时，自动调用run()方法
            public void run() {
                for(char c='A';c<='Z';c++){
                    System.out.println("子线程:" + c);
                }
            }
        };
        
        // Step3: main主线程，启动子线程sub
        sub.start();
        
        // Step4: main主线程执行输出字母的ASCII码
        for(int c ='a';c<='z';c++){
            System.out.println("main线程:" + c);
        }
        System.out.println("main end...");
    }
}

线程的创建方式（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.util.concurrent.Callable 接口，允许子线程返回结果、抛出异常

// 实现子线程
public class SubThread implements Callable{
    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;
      }
}



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

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

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

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

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

方式四：线程池

线程的状态（6个）

NEW：新建状态

Runnable：运行状态

Blocked：阻塞状态

Waiting：等待状态

Timed Waiting：计时状态

Terminated：终止状态

当线程启动后，它可以在Runnable、Blocked、Waiting和Timed Waiting这几个状态之间切换，直到最后变成Terminated状态，线程终止