JAVA 线程基础

线程概念

进程概念

进程：程序在计算机上的一次执行过程，当运行一个程序，就启动了一个进程。凡是用于完成操作系统的各种功能的进程就是系统进程，而所有由用户启动的进程都是用户进程。运行一个JAVA程序会启动一个虚拟机进程，是计算机资源调用的最小单元。

线程概念

线程：进程由一个或者多个线程组成，是独立运行于进程之中的子任务。是操作系统进行 CPU 调度的最小单位。可理解为线程是进程中的一个最小运行单元。JAVA 进程中做少有一个线程，为 main 线程。

两者关系

一个进程包含多个线程。 操作系统调度的最小任务单位其实不是进程，而是线程。线程通过抢占 CPU 时间片执行任务。进程中的所有线程共享该进程的资源。

创建线程

要创建一个新线程非常容易，实例化一个 Thread 实例，然后调用它的 start() 方法。

public class Main {
    public static void main(String[] args) {
        Thread t = new Thread();
        t.start(); 
    }
}

以上代码通过创建 Thread 实例并且启动，在程序退出后便完成了一次线程的执行，但是这样的线程并没有实际意义，因为通常需要在线程中执行相应的业务逻辑，有以下几种方法：

1. 继承Thread对象，重写run方法
2. 实现Runable接口，重写run方法。
3. 继承Callable接口，借助FutureTask来执行。

继承Thread类

从 Thread 派生一个自定义类，然后覆写 run() 方法。

public class TestThread{
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start(); 
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("start MyThread !");
    }
}

实现Runable接口

实现 Runable 接口，重写run方法, 创建 Thread 实例时，传入一个 Runnable 实例。

public class TestThread{
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable());
        t.start(); 
    }
}

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("start MyThread !");
    }
}

实现Callable接口

继承Callable接口，借助FutureTask来执行。Callable接口是一个泛型接口，可以返回指定类型的结果。

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {
    public String call() throws Exception {
        System.out.println("start MyThread !");
        return "hello";
    }
}

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

public class TestThread {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable myCallable = new MyCallable();
        FutureTask<String> futureTask = new FutureTask<String>(myCallable);
        Thread thread = new Thread(futureTask);
        thread.start();
        System.out.println("res:"+ futureTask.get());;
    }


}

三种方式比较

实际上，三种创建创建并没有可比较之处，但是却有不同的应用场景：

1. 如果不考虑从其他类继承相应业务，可以考虑采用继承Thread对象，重写run方法，毕竟类只能单继承。
2. 实现Runable接口，重写run方法。毕竟业务类可以继承多个接口，这种方式有更好的扩展性。
3. 继承Callable接口，借助FutureTask来执行。该方式常用于需要获取线程执行返回值等业务场景。

第一种和第二种的本质差别是类和接口的差别。而第三种拥有返回值。