多线程基础

1.什么是线程？

1.1 线程与进程

进程是操作系统中运行的一个任务，是系统进行资源分配和调度的基本单位。线程是进程的一个基本执行单元。一个进程汇总至少包含一个线程，线程无法独立执行，必须在应用程序中，而进程有一个程序运行的入口，执行序列和程序的出口。简单的说：

进程：程序资源的基本单位

线程：cpu执行的基本单位

1.2 java中的线程

java之父对线程的定义是：线程是一个独立执行的调用序列，同一个进程的线程在同一时刻共享一些系统资源，也能访问同一个进程所创建的对象资源。Java.lang.Thread对象负责统计和控制这种行为。

每个程序都至少拥有一个线程，即作为Java虚拟机启动参数运行在主类main方法的线程。在Java虚拟机初始化过程中也可能启动其他的后台线程。这种线程的数目和种类因jvm的实现而有所差异。然而所有用户级线程都是显示被构造并在主线程或者是其他用户线程种被启动。

在java中想要实现多线程，主要有三种方式：

1. 继承Thred类
2. 实现Runable接口
3. 实现Callable接口，与Future，线程池结合使用

public class ExtendsThread extends Thread{

    /**
     * 继承thread类实现线程
     */
    @Override
    public void run(){
        for(int i=0;i<10;i++){
            System.out.println("ExtendsThread"+i);
        }
    }
}

public class ThreadTest {

    public static void main(String[] args) {
        //继承thread类实现线程
//        ExtendsThread thread = new ExtendsThread();
//        thread.start();

        //实现Runnable接口
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("我是线程1");
            }
        });
        thread1.start();
    }
}

public class CallableThreadTest implements Callable<String> {

    @Override
    public String call() throws Exception {
        return "我是线程2";
    }
}

...
//实现Callable接口，与Future
        FutureTask<String> futureTask = new FutureTask<>(new CallableThreadTest());
        new Thread(futureTask).start();
        System.out.println(futureTask.get());

1.3 线程的状态

java给多线程提供了内置的支持，一个线程指的是进程中一个单一顺序的控制流，一个进程可以并发多个线程，每条线程并行执行不同的任务。多线程是多任务的一种特别的形式，且多线程使用了更小的资源开销。

1.3.1 线程的生命周期

线程是一个动态执行的过程，它也有一个从产生到死亡的过程。

下图显示了一个线程完整的生命周期。

新建状态（NEW）：使用new关键字和Thread类或其子类建立一个线程对象后，该线程就处于新建状态。它保持这个状态直到遇见执行start方法的线程。

就绪状态（RUNNABLE）：当线程对象调用了strat方法后，该线程就进入了就绪状态，就绪状态的线程处于等待队列中，要等待虚拟机里线程调度器的调度。

运行状态（RUNNABLE）：如果就绪状态的线程获取cpu资源，就可以执行run方法，此时线程便处于运行状态。在这个状态的线程最为复杂，它可以变成阻塞状态，就绪状态和我死亡状态。

阻塞状态（BLOCKED）：如果一个线程执行了sleep，suspend等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间到达或者获得cpu资源后可以重新进入就绪状态。大致分为三类：

· 等待阻塞：运行状态中的线程执行wait方法，使线程进入到等待队列

· 同步阻塞：线程在获取synchronized同步锁失败（因为被其他线程占用）

· 其他阻塞：通过调用线程的sleep或join发出了I/O请求时，线程就会进入到阻塞状态。当sleep状态超时，join等待线程终止或超时，或者I/O处理完毕，线程重新转入就绪状态

死亡状态（TERMINATED）：一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。

1.4 线程常用方法

Tread.yeild(): 执行此方法会向系统线程调度器发出一个暗示，告诉其当前Java线程打算放弃对cpu的使用，但这个暗示有可能被调度器忽略，因为让步的线程还有可能被线程调度程序再次选中。使用该方法可以防止线程对cpu的过度使用，提高系统性能。

Thread#sleep(): 使线程进入休眠，状态变为 TIME_WAITING（定时等待状态）

Tread.interrupt(): 中断当前线程的执行，允许当前线程对自身进行中断，否则将会校验调用方线程是否有对该线程的权限。如果当前线程因被调用Object.wait() 或者线程本身的join()，处于阻塞状态中，此时调用该方法会抛出InterruptException，而且线程的阻塞状态会被清除。

Thread.interrupted():查看当前线程是否处于中断状态，返回true/false，如果调用成功，会清除当前线程的interrupt status，所以如果连续两次调用该方法，第二次会返回false。

Thread.isInterrupted(): 查看当前线程是否处于中断状态，返回true/false，与上一个方法不同的是，它不会清除当前线程的interrupt status。

Thread.join(): A线程调用B线程的join方法，将会使A等待B执行，直到B线程终止。如果传入time参数，将会使A等待B执行time的时间，如果time时间到达，将会切换到A线程，继续执行A线程。一般可以理解为插队～

2.多线程能用来干什么？

一个可能在很多人看来很扯淡的一个问题：我会用多线程就好了，还管它有什么用？在我看来，这个回答更扯淡。所谓"知其然知其所以然"，"会用"只是"知其然"，"为什么用"才是"知其所以然"，只有达到"知其然知其所以然"的程度才可以说是把一个知识点运用自如。

2.1 发挥多核CPU的优势

随着工业的进步，现在的笔记本、台式机乃至商用的应用服务器至少也都是双核的，4核、8核甚至16核的也都不少见，如果是单线程的程序，那么在双核CPU上就浪费了50%，在4核CPU上就浪费了75%。单核CPU上所谓的"多线程"那是假的多线程，同一时间处理器只会处理一段逻辑，只不过线程之间切换得比较快，看着像多个线程"同时"运行罢了。多核CPU上的多线程才是真正的多线程，它能让你的多段逻辑同时工作，多线程，可以真正发挥出多核CPU的优势来，达到充分利用CPU的目的。

2.2 防止阻塞

从程序运行效率的角度来看，单核CPU不但不会发挥出多线程的优势，反而会因为在单核CPU上运行多线程导致线程上下文的切换，而降低程序整体的效率。但是单核CPU我们还是要应用多线程，就是为了防止阻塞。试想，如果单核CPU使用单线程，那么只要这个线程阻塞了，比方说远程读取某个数据吧，对端迟迟未返回又没有设置超时时间，那么你的整个程序在数据返回回来之前就停止运行了。多线程可以防止这个问题，多条线程同时运行，哪怕一条线程的代码执行读取数据阻塞，也不会影响其它任务的执行。

2.3 便于建模

这是另外一个没有这么明显的优点了。假设有一个大的任务A，单线程编程，那么就要考虑很多，建立整个程序模型比较麻烦。但是如果把这个大的任务A分解成几个小任务，任务B、任务C、任务D，分别建立程序模型，并通过多线程分别运行这几个任务，那就简单很多了。

3.如何使用多线程？

3.1 多线程实现

public static void main(String[] args) {
        //线程池实现
        ExecutorService  executorService = Executors.newFixedThreadPool(5);
        //execute直接执行线程
        executorService.execute(new Thread());
        executorService.execute(() -> System.out.println("runnable"));
        //submit提交有返回结果的任务，运行完后返回结果。
        Future<String> future = executorService.submit(() -> "a");
        try {
            System.out.println(future.get());
        } catch (Exception e) {
            e.printStackTrace();
        }

        ArrayList<String> list = new ArrayList<>();
        //有返回值的线程组将返回值存进集合
        for (int i = 0;i < 5;i ++ ) {
            int finalI = i;
            Future<String> future1 = executorService.submit(() -> "res" + finalI);
            try {
                list.add(future1.get());
            } catch (Exception e) {
                e.printStackTrace();
            } 
        }
        for (String s : list) {
            System.out.println(s);
        }
    }

输出结果：