Java创建线程的三种方式

Java创建线程的三种方式

线程与进程

**进程：**计算机中运行着的应用程序就是进程，可以理解成应用程序的动态执行过程。
**线程：**进程中程序的一个个执行线路被称为线程。
进程与线程的区别与联系：
1、进程是操作系统资源分配的最小单位，每一个进程都有自己独立的地址空间；而线程是系统任务调度的最小单位，同一进程的多个线程间共享进程的内存空间(代码段，数据集，堆等)和资源（如打开文件和信号等）；
2、一个程序至少有一个进程,一个进程至少有一个线程；
3、一个线程可以创建和撤销另一个线程，同一个进程中的多个线程之间可以并发执行；
4、线程上下文切换比进程上下文切换要快得多。

Java三种创建线程的方式

线程是进程的具体执行内容，在Java中常用的创建线程的方法有两种，分别为：继承Thread类、实现Runnable接口，此外还有一种不常用的方法:实现Callable接口。本文详细介绍这三种方法。

1、继承Thread类

创建步骤：

1. 创建Thread类的子类，并在子类中重写Thread类的run()方法。run()方法中的代码就是创建线程的具体执行内容，称其为线程的执行体。
2. 实例化Thread子类，从而创建线程对象。
3. 调用线程对象的start()方法，启动该线程。

package excisecode;

public class ThreadTest {
    public static void main(String[] args) {
        System.out.println("线程名称："+Thread.currentThread().getName());
        MyThread t = new MyThread();
        t.start();
    }

    public static class MyThread extends Thread{
        @Override
        public void run() {
            System.out.println("线程名称："+Thread.currentThread().getName());
        }
    }
}

上述程序会先打印主线程的名称，然后创建分支线程，紧接着打印分支线程的名称。

2、实现Runnable接口

创建步骤：

1. 创建一个Runnable接口的实现类，在类中实现接口的run()方法。
2. 创建 Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
3. 调用线程对象的start()方法来启动该线程。

package excisecode;

public class RunnableTest {
    
    public static void main(String[] args) {
        System.out.println("线程名称："+Thread.currentThread().getName());
        RunnableImpl r = new RunnableImpl();
        Thread t = new Thread(r,"www");
        Thread q = new Thread(r,"yyy");
        t.start();
        q.start();
    }
    
    static class RunnableImpl implements Runnable{
        @Override
        public void run() {
            System.out.println("线程名称："+Thread.currentThread().getName());
        }
    }
}

上面的程序中共有三个线程，分别是主线程以及名称为“www”和“yyy”的分支线程。程序会在控制台分别打印字符串"www"和"yyy"。

3、实现Callable接口

1. 创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。
2. 创建Callable实现类的实例，使用FutureTask类来包装Callable对象。（FutureTask是一个包装器，它通过接收Callable来创建，它同时实现了Future和Runnable接口。）
3. 使用FutureTask对象作为Thread对象的target创建新线程。
4. 调用Thread对象的run()方法启动线程。并且调用FutureTask对象的get()方法可以获得子线程执行结束后的返回值。

package excisecode;

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

public class CallableTest {
    public static void main(String[] args) throws InterruptedException {
        CallableImpl call = new CallableImpl();
        FutureTask<Integer> task = new FutureTask<>(call);
        new Thread(task,"实现Callable接口创建的类").start();
        for(int j=0;j<11;j++){
            if(j==5){
                try {
                    System.out.println("子线程返回的结果为："+task.get());
                } catch (ExecutionException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()+":"+j);
            Thread.sleep(500);
        }
    }

    static class CallableImpl implements Callable<Integer>{
        @Override
        public Integer call() throws Exception {
            int i = (int)Math.random()*10+10;
            for(;i>0;i--){
                System.out.println(Thread.currentThread().getName()+":"+i);
                Thread.sleep(500);
            }
            return 0;
        }
    }
}

上述程序主线程和分支线程会争夺CPU的运行时间片，并且当主线程打印输出到数字5时，由于程序调用了FutureTask对象的get()方法，因此主线程会等待分支线程运行完毕，然后再继续执行。

三种线程创建方式的比较

1. 采用实现Runnable、Callable接口的方式创建多线程：
   优势：线程类只是实现了Runnable接口或Callable接口，还可以继承其他类；多个线程可以共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。
   劣势：编程稍微复杂，如果要访问当前线程，则必须使用Thread.currentThread()方法。
2. 使用继承Thread类的方式创建多线程
   优势：编写简单，如果需要访问当前线程，则无需使用Thread.currentThread()方法，直接使用this即可获得当前线程。
   劣势：线程类已经继承了Thread类，所以不能再继承其他父类。
3. Runnable和Callable的区别
   <1> Callable规定重写的方法是call()，Runnable规定重写的方法是run()。
   <2> Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。
   <3>运行Callable任务可以拿到一个Future对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果。

参考博客：
Java创建线程的三种方式及其对比