创建JAVA线程的三种主要方式

程序 进程 线程

程序： 一组计算机指令有序的集合
进程： 具有一定功能的程序关于某个数据集合上的一次运行活动，进程是系统进行资源分配和调度的一个独立单位。
线程： 线程是进程的实体，是cpu分派和调度的基本单位，它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源，值拥有一点在运行时必不可少的资源（程序计数器 一组寄存器和栈）；但他可以和同属进程的其他线程共享进程的所有资源。

1. 扩展（即继承）java.lang.Thread类

/**
 * @author FengTianHao
 * @version 1.0
 * @since 2018/11/15 17:04
 */

/**
 *  此种实现java线程的方式中,run()方法中的代码是线程要执行的代码段，无返回值
 *
 *  启动线程是在Thread对象上调用start()方法
 */
public class TestThread extends Thread{
    @Override//重写父类的run()方法
    public void run()//该方法里面的代码段是线程要执行的代码段
    {
        System.out.println("TestThread.run");
    }
    public static void main(String[] args)
    {
        TestThread thread=new TestThread();//创建线程
        thread.start();//启动线程
    }
}

2.实现java.lang.Runable接口

/**
 * @author FengTianHao
 * @version 1.0
 * @since 2018/11/15 17:04
 */

/**
 * 如果采用实现Runnable来实现线程需要调用Thread构造方法
 * Thread(Runnable target)
 * Thread(Runnable target, String name)
 * Thread(ThreadGroup group, Runnable target)
 * Thread(ThreadGroup group, Runnable target, String name)
 * Thread(ThreadGroup group, Runnable target, String name, long stackSize)
 */

public class TestThread implements Runnable{
    private String name;//可以给线程起名字
    public TestThread(String name)
    {
        this.name=name;
    }
    @Override
    public void run() {
        for(int i=0;i<100;i++)
        {
            System.out.println(name+i);
        }
    }
    public static void main(String[] args)throws  Exception
    {
        TestThread thread=new TestThread("fth");
        Thread t1=new Thread(thread);
        t1.start();
    }
}

3.使用callable和future创建线程

/**
 * @author FengTianHao
 * @version 1.0
 * @since 2018/11/15 17:04
 */

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

/** 从javajdk5开始，java提供Callable接口，该接口提供一个方法call()
 *  该方法作为线程执行体
 *  该方法可以有返回值，还可以抛出异常
 *  java jdk5提供了Future接口来代表call方法的返回值
 *  并提供了Future接口的实现类FutureTask
 *  FutureTask类实现了Future的接口，也实现了Runnable的接口
 */

public class TestThread implements Callable<Integer> {
    //创建Callable接口的实现类，并实现call方法

    int i=0;
    @Override
    public Integer call() throws Exception {

        for(;i<10;i++){}
        return i;
    }
    public static void main(String[] args)
    {
        TestThread thread=new TestThread();
        FutureTask<Integer> ft=new FutureTask<>(thread);//使用FutureTask类封装Callable对象的call方法的返回值
        Thread td=new Thread(ft);//使用FutureTask对象作为Thread的target创建线程
        td.start();//启动线程
        try {
            System.out.println(ft.get());//通过FutureTask中的get方法获得线程执行完后的返回值
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

}

结论

采用Runnable和Callable的优势：线程类在实现Runnable接口或者Callable接口的情况下还可以继承其他类，这可以使多个线程共享一个target对象,因此适合多个线程处理同一份资源。一般推荐通过实现接口来创建多线程。