创建线程的方式

首先，先来了解一下什么是线程？什么是进程？

1.进程：是操作系统中一个程序的执行周期。

2.线程：是进程的一个任务，即操作系统中任务调度的基本单位。

3.进程与线程的区别：

• 每个进程拥有自己的一整套变量，是操作系统资源分配的最小单位。
• 线程依托于进程存在，多个线程可以共享进程的资源。
• 启动、撤销一个进程的开销要比一个线程大得多。
• 没有进程就没有线程，进程一旦关闭，所有的线程都会被撤销。

4.创建线程的三种方式：
(1) 继承类：
继承Thread类，并覆写run()，代码如下：

/**
 * @Author: lin
 * @Date: 2019/8/29 9:40
 * @Description:线程的创建方式1
 */

class MyThread extends Thread{
    private String name;
    public MyThread(String name){
        this.name = name;
    }
    @Override
    public void run() {
        System.out.println(this.name+" running...");
    }
}

public class Test {
    public static void main(String[] args) {
        Thread thread1 = new MyThread("myThread1");
        Thread thread2 = new MyThread("myThread2");
        Thread thread3 = new MyThread("myThread3");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

• 我们能不能直接调用run()来启动多线程呢？来看下图：
  
  答案是不能，因为此时相当于只是进行了顺序打印，这跟多线程没有关系。正确做法是调用start()启动多线程，此时我们的线程就会随机交替执行。
  
• start()解析：

public synchronized void start() {
        //若线程状态不为0，表示已经启动过，此时抛出异常
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
        group.add(this);
        //表示此时线程还未启动
        boolean started = false;
        try {
            //调用native方法start0()启动线程
            start0();
            //此时线程已经启动
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
            }
        }
    }

由上可见，当我们调用start()来启动线程的时候，会先判断这个线程是否已经启动过，若已经启动过则报错；若没有启动则调用了本地的start0()来启动线程。

调用start0()实际上会调用JVM_StartThread()，函数内创建了真正与平台相关的本地线程，然后再回调run()，执行我们所定义的线程的具体任务。

(2) 实现接口：

• 实现Runnable接口，并覆写run()，代码如下：

class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+" running...");
    }
}

public class Test {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread thread1 = new Thread(myThread,"myThread1");
        Thread thread2 = new Thread(myThread,"myThread2");
        Thread thread3 = new Thread(myThread,"myThread3");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

我们来看一下，Thread与Runnable的描述：

public class Thread implements Runnable {...}

可见，Thread类与我自定义的类MyThread都实现了Runnable接口，Thread类负责系统资源调度，分配线程等操作，而MyThread用来实现真实业务。即通过实现Runnable接口来创建线程实际上是一种代理模式。

• 实现Callable接口，并覆写call()，代码如下：

class MyThread implements Callable<String> {
    private int ticket = 10;
    @Override
    public String call() throws Exception {
        while(this.ticket>0){
            System.out.println("现在还有 "+this.ticket--+" 张票");
        }
        return "票已经售空！";
    }
}

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<String> callable = new MyThread();
        FutureTask<String> futureTask = new FutureTask<>(callable);
        Thread thread = new Thread(futureTask);
        thread.start();
        System.out.println(futureTask.get());
    }
}

结果如下：

我们来画一下这之间的接口与类的关系：

(3)使用线程池：
一般我们使用ThreadPoolExecutor来创建一个线程，让我们先来看一下它的构造方法：

public ThreadPoolExecutor(    //线程池的基本大小
                              int corePoolSize,
                              //线程池允许创建的最大线程数
                              int maximumPoolSize,
                              //线程活动的保持时间
                              long keepAliveTime,
                              //线程活动保持时间的单位
                              TimeUnit unit,
                              //任务队列，用于保存等待执行的任务的阻塞队列
                              BlockingQueue<Runnable> workQueue,
                              //线程工厂
                              ThreadFactory threadFactory,
                              //当线程池处于饱和状态时，提交新任务所采取的策略
                              RejectedExecutionHandler handler)

使用ThreadPoolExecutor创建一个线程，代码如下：

class Threads implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+" running...");
    }
}

public class TestPool {
    public static void main(String[] args) {
        Threads threads = new Threads();
        ThreadPoolExecutor thread =
                new ThreadPoolExecutor(3,5,
                        2000,TimeUnit.MILLISECONDS,
                        new LinkedBlockingDeque<Runnable>());
        for(int i = 0;i<5;i++){
            thread.execute(threads);
        }
        thread.shutdown();
    }
}

结果如下：

5.对比Thread、Runnable、Callable实现线程有什么不同？

• 继承Thread类，覆写run()，可以满足一般创建线程的需要。
• 实现Runnable接口所创建的所线程，可以更好地体现共享的概念。
• 若当我们需要有一个返回值时，可以使用Callable创建多线程，使用FutureTask的get()来取得这个返回值。