面试题一：并行和并发有什么区别？

并行是指两个或者多个事件在同⼀时刻发⽣；而并发是指两个或多个事件在同⼀时间间隔发⽣；
并行是在不同实体上的多个事件，并发是在同⼀实体上的多个事件；
在⼀台处理器上“同时”处理多个任务，在多台处理器上同时处理多个任务。如 Hadoop 分布式集群。所以并发编程的目标是充分的利⽤处理器的每⼀个核，以达到最⾼的处理性能。

面试题二：线程和进程的区别？

进程：是程序运行和资源分配的基本单位，⼀个程序至少有⼀个进程，⼀个进程至少有⼀个线程。进程在执行过程中拥有独立的内存单元，而多个线程共享内存资源，减少切换次数，从而效率更⾼。

举个例子，当我们双击桌面的图标时，系统会将对应的程序加载进内存，程序将会占用一部分内存用以执行操作。进入到内存的程序即为进程（一个应用程序可以同时运行多个进程）。当使用任务管理器关闭程序时（比如LOL），系统又会将程序从内存中清除，此时进程结束。如图：一个 LOL 进程。
-

线程：是进程的⼀个实体，是 cpu 调度和分派的基本单位，是比程序更小的能独立运行的基本单位。同⼀进程中的多个线程之间可以并发执行。

需要注意的是，Java 本身并不能创造线程，因为线程其实是操作系统的一种资源，它由操作系统管理。我们一般说“Java 支持多线程”，指的就是 Java 可以调用系统资源创建多线程。
在这里插入图片描述

追问：守护线程是什么？

用户线程：我们平常创建的普通线程。
守护线程（即 Daemon thread），是个服务线程，用来服务于用户线程，准确地来说就是服务其他的线程。在JVM中，所有非守护线程都执行完毕后，无论有没有守护线程，虚拟机都会自动退出。

守护线程怎么使用：使用很简单，只是在调用start()方法前，调用 setDaemon(true) 把该线程标记为守护线程。

如何检查一个线程是守护线程还是用户线程：使用isDaemon()方法。
Java垃圾回收线程就是一个典型的守护线程，因为我们的垃圾回收是一个一直需要运行的机制，但是当没有用户线程的时候，也就不需要垃圾回收线程了，守护线程刚好满足这样的需求。

面试题三：创建线程的几种方式？

1. 继承 Thread 类创建线程，重写 run() 方法

public class ThreadDemo1 extends Thread {
    public static void main(String[] args) {
        // ThreadDemo 继承了Thread类，并重写run()
        ThreadDemo t = new ThreadDemo();
        // 开启线程：t线程得到CPU执行权后会执行run()中的代码
        t.start();
    }

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

2. 实现 Runnable 接口创建线程，实现 run() 方法

public class ThreadDemo2 implements Runnable{
    public static void main(String[] args) {
        // ThreadDemo2实现Runnable接口，并实现run()
        ThreadDemo2 target = new ThreadDemo2();
        // 调用Thread构造方法，传入TreadDemo2的实例对象，创建线程对象
        Thread t = new Thread(target);
        // 开启线程：t线程得到CPU执行权后会执行run()中的代码
        t.start();
    }

    public void run() {
        System.out.println("Thread is running");
    }
}

通过 Callable 和 Future 创建线程；
通过线程池创建线程。

追问：Runnable 和 Callable 有什么区别？

Runnable 接口中的 run() 方法的返回值是 void，它做的事情只是纯粹地去执行 run() 方法中的代码而已； run方法不可以抛出异常。
Callable 接口中的 call() 方法是有返回值的，是⼀个泛型，和 Future、FutureTask 配合可以用来获取异步执行的结果。call方法可以抛出异常。

补充：FutureTask

未来的任务，用它就干一件事，异步调用 main 方法就像一个冰糖葫芦，一个个方法由 main 串起来。
但解决不了一个问题：正常调用挂起堵塞问题。
例子：

老师上着课，口渴了，去买水不合适，讲课线程继续，我可以单起个线程找班长帮忙买水，水买回来了放桌上，我需要的时候再去get。
4个同学，A 算1+到20，B 算21+到30，C 算31*到40，D算41+到50，是不是 C 的计算量有点大啊，FutureTask 单起个线程给 C 计算，我先汇总 ABD，最后等 C 计算完了再汇总 C，拿到最终结果。
高考：会做的先做，不会的放在后面做。

原理：在主线程中需要执行比较耗时的操作时，但又不想阻塞主线程时，可以把这些作业交给 Future 对象在后台完成，当主线程将来需要时，就可以通过 Future 对象获得后台作业的计算结果或者执行状态。一般 FutureTask 多用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果。仅在计算完成时才能检索结果；如果计算尚未完成，则阻塞 get 方法。一旦计算完成，就不能再重新开始或取消计算。get方法而获取结果只有在计算完成时获取，否则会一直阻塞直到任务转入完成状态，然后会返回结果或者抛出异常。只计算一次 get 方法放到最后。

public class CallableDemo {
    public static void main(String[] args) {
        FutureTask<Integer> futureTask = new FutureTask<Integer>(() -> {
            System.out.println(Thread.currentThread().getName() + "  come");
            return 1024;
        });
        new Thread(futureTask,"AAA").start();
        try {
            System.out.println(futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

运行结果：
AAA  come
1024