1.并发编程的优缺点
2.并发编程三要素是什么?在 Java 程序中怎么保证多线程的运行安全?
3.并行和并发有什么区别?
4.什么是多线程，多线程的优劣?
5.什么是线程和进程?
6.进程与线程的区别
7.什么是上下文切换?
8.守护线程和用户线程有什么区别呢?
9.如何在 Windows 和 Linux 上查找哪个线程cpu利用率最高?
10.什么是线程死锁
13.创建线程有哪几种方式?
- 13.1.继承 Thread 类
- 13.3.实现 Callable 接口
14.说一下 runnable 和 callable 有什么区别?
15.线程的 run()和 start()有什么区别?
16.为什么我们调用 start() 方法时会执行 run() 方法，为什么我们不能直接调用 run() 方法?
17.什么是 Callable 和 Future?
18.什么是 FutureTask

1.并发编程的优缺点

优点（为什么要使用并发编程）

充分利用多核CPU的计算能力:通过并发编程的形式可以将多核CPU的计算能力发挥到极致，性能得到提升
方便进行业务拆分，提升系统并发能力和性能:在特殊的业务场景下，先天的就适合于并发编程。现在的系统动不动就要求百万级甚至千万级的并发量，而多线程并发编程正是开发高并发系统的基础，利用好多线程机制可以大大提高系统整体的并发能力以及性能。面对复杂业务模型，并行程序会比串行程序更适应业务需求，而并发编程更能吻合这种业务拆分。

缺点

并发编程的目的就是为了能提高程序的执行效率，提高程序运行速度，但是并发编程并不总是能提高程序运行速度的，而且并发编程可能会遇到很多问题，比如:内存泄漏、上下文切换、线程安全、死锁等问题。

2.并发编程三要素是什么?在 Java 程序中怎么保证多线程的运行安全?

并发编程三要素(线程的安全性问题体现在):
- 原子性:原子，即一个不可再被分割的颗粒。原子性指的是一个或多个操作要么全部执行成功要么全部执行失败。
- 可见性:一个线程对共享变量的修改,另一个线程能够立刻看到。
- 有序性:程序执行的顺序按照代码的先后顺序执行。(处理器可能会对指令进行重排序)
出现线程安全问题的原因:
- 线程切换带来的原子性问题
- 缓存导致的可见性问题
- 编译优化带来的有序性问题
解决办法:
- JDK Atomic开头的原子类、synchronized、LOCK，可以解决原子性问题
- synchronized、volatile、LOCK，可以解决可见性问题
- Happens-Before 规则可以解决有序性问题
  3.并行和并发有什么区别?
并发:多个任务在同一个 CPU 核上，按细分的时间片轮流(交替)执行，从逻辑上来看那些任务是同时执行。
并行:单位时间内，多个处理器或多核处理器同时处理多个任务，是真正意义上的“同时进行”。
串行:有n个任务，由一个线程按顺序执行。由于任务、方法都在一个线程执行所以不存在线程不安全情况，也就不存在临界区的问题。

做一个形象的比喻:

并发 = 两个队列和一台咖啡机。
并行 = 两个队列和两台咖啡机。
串行 = 一个队列和一台咖啡机。

4.什么是多线程，多线程的优劣?
多线程:多线程是指程序中包含多个执行流，即在一个程序中可以同时运行多个不同的线程来执行不同的任务。
多线程的好处:

可以提高 CPU 的利用率。在多线程程序中，一个线程必须等待的时候，CPU 可以运行其它的线程而不是等待，这样就大大提高了程序的效率。也就是说允许单个程序创建多个并行执行的线程来完成各自的任务。

多线程的劣势:
- 线程也是程序，所以线程需要占用内存，线程越多占用内存也越多;
- 多线程需要协调和管理，所以需要 CPU 时间跟踪线程;
- 线程之间对共享资源的访问会相互影响，必须解决竞用共享资源的问题。
  5.什么是线程和进程?
进程:一个在内存中运行的应用程序。每个进程都有自己独立的一块内存空间，一个进程可以有多个线程，比如在Windows系统中，一个运行的xx.exe就是一个进程。
线程:进程中的一个执行任务(控制单元)，负责当前进程中程序的执行。一个进程至少有一个线程，一个进程可以运行多个线程，多个线程可共享数据。
6.进程与线程的区别
线程具有许多传统进程所具有的特征，故又称为轻型进程(Light—Weight Process)或进程元;而把传统的进程称为重型进程(Heavy—Weight Process)，它相当于只有一个线程的任务。在引入了线程的操作系统中，通常一个进程都有若干个线程，至少包含一个线程。
根本区别:进程是操作系统资源分配的基本单位，而线程是处理器任务调度和执行的基本单位
资源开销:每个进程都有独立的代码和数据空间(程序上下文)，程序之间的切换会有较大的开销;线程可以看做轻量级的进程，同一类线程共享代码和数据空间，每个线程都有自己独立的运行栈和程序计数器(PC)，线程之间切换的开销小。
包含关系:如果一个进程内有多个线程，则执行过程不是一条线的，而是多条线 (线程)共同完成的;线程是进程的一部分，所以线程也被称为轻权进程或者轻量级进程。
内存分配:同一进程的线程共享本进程的地址空间和资源，而进程之间的地址空间和资源是相互独立的影响关系:一个进程崩溃后，在保护模式下不会对其他进程产生影响，但是一个线程崩溃整个进程都死掉。所以多进程要比多线程健壮。
执行过程:每个独立的进程有程序运行的入口、顺序执行序列和程序出口。但是线程不能独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制，两者均可并发执行
7.什么是上下文切换?
多线程编程中一般线程的个数都大于 CPU 核心的个数，而一个 CPU 核心在任意时刻只能被一个线程使用，为了让这些线程都能得到有效执行，CPU采取的策略是为每个线程分配时间片并轮转的形式。当一个线程的时间片用完的时候就会重新处于就绪状态让给其他线程使用，这个过程就属于一次上下文切换。

概括来说就是:当前任务在执行完 CPU 时间片切换到另一个任务之前会先保存自己的状态，以便下次再切换回这个任务时，可以再加载这个任务的状态。任务从保存到再加载的过程就是一次上下文切换。上下文切换通常是计算密集型的。也就是说，它需要相当可观的处理器时间，在每秒几十上百次的切换中，每次切换都需要纳秒量级的时间。所以，上下文切换对系统来说意味着消耗大量的CPU时间，事实上，可能是操作系统中时间消耗最大的操作。
Linux 相比与其他操作系统(包括其他类 Unix 系统)有很多的优点，其中有一项就是，其上下文切换和模式切换的时间消耗非常少。

8.守护线程和用户线程有什么区别呢?

守护线程和用户线程
用户 (User) 线程:运行在前台，执行具体的任务，如程序的主线程、连接网络的子线程等都是用户线程
守护 (Daemon) 线程:运行在后台，为其他前台线程服务。也可以说守护线程是 JVM 中非守护线程的 “佣人”。一旦所有用户线程都结束运行，守护线程会随 JVM 一起结束工作main 函数所在的线程就是一个用户线程啊，main 函数启动的同时在 JVM 内部同时还启动了好多守护线程，比如垃圾回收线程。比较明显的区别之一是用户线程结束，JVM 退出，不管这个时候有没有守护线程运行。而守护线程不会影响 JVM 的退出。

注意事项:

setDaemon(true)必须在start()方法前执行，否则会抛出 IllegalThreadStateException 异常
在守护线程中产生的新线程也是守护线程
不是所有的任务都可以分配给守护线程来执行，比如读写操作或者计算逻辑
守护 (Daemon) 线程中不能依靠 finally 块的内容来确保执行关闭或清理资源的逻辑。因为我们上面也说过了一旦所有用户线程都结束运行，守护线程会随 JVM 一起结束工作，所以守护 (Daemon) 线程中的 finally 语句块可能无法被执行。

9.如何在 Windows 和 Linux 上查找哪个线程cpu利用率最高?
windows上面用任务管理器看，linux下可以用 top 这个工具看。
找出cpu耗用厉害的进程pid，终端执行top命令，然后按下shift+p 查找出cpu利用最厉害的pid号
根据上面第一步拿到的pid号，top -H -p pid 。然后按下shift+p，查找出cpu利用率最厉害的线程号，比如top -H -p 1328
将获取到的线程号转换成16进制，去百度转换一下就行
使用jstack工具将进程信息打印输出，jstack pid号 > /tmp/t.dat，比如 jstack 31365 > /tmp/t.dat

编辑/tmp/t.dat文件，查找线程号对应的信息

10.什么是线程死锁

死锁是指两个或两个以上的进程(线程)在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程(线程)称为死锁进程(线程)。
多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。
如下图所示，线程 A 持有资源 2，线程 B 持有资源 1，他们同时都想申请对方的资源，所以这两个线程就会互相等待而进入死锁状态。

下面通过一个例子来说明线程死锁，代码模拟了上图的死锁的情况 (代码来源于《并发编程之美》): ```java public class DeadLockDemo{ private static Object resource1 =new Object(); private static Object resource2 =new Object(); public static voidmain(String[] args){

 new Thread(()->{
     synchronized(resource1){ 
         System.out.println(Thread.currentThread()+"get resource1");
         try{ 
             Thread.sleep(1000);
         }catch(InterruptedException e){ 
             e.printStackTrace();
         } 
         System.out.println(Thread.currentThread()+"waiting get resource2");
         synchronized(resource2){ 
             System.out.println(Thread.currentThread()+"get resource2");
         }
     }
 },"线程 1").start();
 new Thread(()->{
     synchronized(resource2){ 
         System.out.println(Thread.currentThread()+"get resource2");
         try{ 
             Thread.sleep(1000);
         }catch(InterruptedException e){ 
             e.printStackTrace();
         } 
         System.out.println(Thread.currentThread()+"waiting get resource1");
         synchronized(resource1){
             System.out.println(Thread.currentThread()+"get resource1");
         }
     }
 },"线程 2").start();

} }

输出结果 Thread[线程 1,5,main] get resource1 Thread[线程 2,5,main] get resource2 Thread[线程 1,5,main] waiting get resource2 Thread[线程 2,5,main] waiting get resource1

线程 A 通过 synchronized (resource1) 获得 resource1 的监视器锁，然后通过 Thread.sleep(1000);让线程 A 休眠 1s 为的是让线程 B 得到CPU执行权，然后获取到 resource2 的监视器锁。线程 A 和线程 B 休眠结束了都开始企图请求获取对方的资源，然后这两个线程就会陷入互相等待的状态，这也就产生了死锁。上面的例子符合产生死锁的四个必要条件。
<a name="HOZa4"></a>
# 11.形成死锁的四个必要条件是什么
1. **互斥条件:**线程(进程)对于所分配到的资源具有排它性，即一个资源只能被一个线程(进程)占用，直到被该线程(进程)释放
1. **请求与保持条件:**一个线程(进程)因请求被占用资源而发生阻塞时，对已获得的资源保持不放。
1. **不剥夺条件:**线程(进程)已获得的资源在末使用完之前不能被其他线程强行剥夺，只有自己使用完毕后才释放资源。
1. **循环等待条件:**当发生死锁时，所等待的线程(进程)必定会形成一个环路 (类似于死循环)，造成永久阻塞
<a name="e4PP4"></a>
# 12.如何避免线程死锁
我们只要破坏产生死锁的四个条件中的其中一个就可以了。
- **破坏互斥条件**
这个条件我们没有办法破坏，因为我们用锁本来就是想让他们互斥的(临界资源需要互斥访问)。
- **破坏请求与保持条件**
一次性申请所有的资源。
- **破坏不剥夺条件**
占用部分资源的线程进一步申请其他资源时，如果申请不到，可以主动释放它占有的资源。
- **破坏循环等待条件**
靠按序申请资源来预防。按某一顺序申请资源，释放资源则反序释放。破坏循环等待条件。<br />我们对线程 2 的代码修改成下面这样就不会产生死锁了。
```java
new Thread(()->{
    synchronized(resource1){ 
        System.out.println(Thread.currentThread()+"get resource1");
        try{ 
            Thread.sleep(1000);
        }catch(InterruptedException e){ 
            e.printStackTrace();
        } 
        System.out.println(Thread.currentThread()+"waiting get resource2");
        synchronized(resource2){ 
            System.out.println(Thread.currentThread()+"get resource2");
        }
    }
},"线程 2").start();
Thread[线程 1,5,main] get resource1 
Thread[线程 1,5,main] waiting get resource2
Thread[线程 1,5,main] get resource2
Thread[线程 2,5,main] get resource1
Thread[线程 2,5,main] waiting get resource2
Thread[线程 2,5,main] get resource2

我们分析一下上面的代码为什么避免了死锁的发生?
线程 1 首先获得到 resource1 的监视器锁，这时候线程 2 就获取不到了。然后线程 1再去获取 resource2 的监视器锁，可以获取到。然后线程 1 释放了对 resource1、resource2 的监视器锁的占用，线程 2 获取到就可以执行了。这样就破坏了破坏循环等待条件，因此避免了死锁。

13.创建线程有哪几种方式?

创建线程有四种方式:

继承 Thread 类;
实现 Runnable 接口;
实现 Callable 接口;
使用 Executors 工具类创建线程池
13.1.继承 Thread 类
步骤

定义一个Thread类的子类，重写run方法，将相关逻辑实现，run()方法就是线程要执行的业务逻辑方法
创建自定义的线程子类对象
调用子类实例的start()方法来启动线程 ```java public class MyThread extends Thread{ @Override public void run(){
```
 System.out.println(Thread.currentThread().getName()+" run()方法正在执行...");
```
} }

public class TheadTest{ public static void main(String[] args){ MyThread myThread =new MyThread(); myThread.start(); System.out.println(Thread.currentThread().getName()+” main()方法执行结束”); } } 结果：顺序不一定，但是main方法可能会运行快一些 main main()方法执行结束 Thread-0run()方法正在执行…

<a name="Xtww3"></a>
## 13.2.实现 Runnable 接口
步骤
1. 定义Runnable接口实现类MyRunnable，并重写run()方法
1. 创建MyRunnable实例myRunnable，以myRunnable作为target创建 Thead对象，**该Thread对象才是真正的线程对象**
1. 调用线程对象的start()方法
```java
public class MyRunnable implements Runnable{
    @Override
    public void run(){ 
        System.out.println(Thread.currentThread().getName()+" run()方法执行中...");
    }
}
public class RunnableTest{
    public static void main(String[] args){ 
        MyRunnable myRunnable =new MyRunnable(); 
        Thread thread =new Thread(myRunnable);
        thread.start();
        System.out.println(Thread.currentThread().getName()+" main()方法执行完成");
    }
}
结果：顺序不一定，但是main方法可能会运行快一些
main main()方法执行结束
Thread-0run()方法正在执行...

13.3.实现 Callable 接口

步骤

创建实现Callable接口的类myCallable
以myCallable为参数创建FutureTask对象
将FutureTask作为参数创建Thread对象
调用线程对象的start()方法 ```java public class MyCallable implements Callable
{ @Override public Integer call(){
```
 System.out.println(Thread.currentThread().getName()+" call()方法执行中...");
 return 1;
```
} }

public class CallableTest{ public static void main(String[] args){ FutureTask futureTask =new FutureTask(new MyCallable()); Thread thread =new Thread(futureTask); thread.start(); try{ Thread.sleep(1000); System.out.println(“返回结果 “+ futureTask.get()); }catch(InterruptedException e){ e.printStackTrace(); }catch(ExecutionException e){ e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+” main()方法执行完成”); } } Thread-0 call()方法执行中… 返回结果 1 main main()方法执行完成

<a name="ksxFd"></a>
## 13.4.使用 Executors 工具类创建线程池
Executors提供了一系列工厂方法用于创先线程池，返回的线程池都实现了 ExecutorService接口。<br />主要有new FixedThreadPool，new CachedThreadPool，new SingleThreadExecutor，new ScheduledThreadPool，后续详细介绍这四种线程池
```java
public class MyRunnable implements Runnable{
    @Override 
    public void run(){ 
        System.out.println(Thread.currentThread().getName()+" run()方法执行中...");
    }
}
public class SingleThreadExecutorTest{
    public static void main(String[] args){
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        MyRunnable runnableTest =new MyRunnable();
        for(int i =0; i <5; i++){
            executorService.execute(runnableTest);
        } 
        System.out.println("线程任务开始执行");
        executorService.shutdown();
    }
}
执行结果
线程任务开始执行
pool-1-thread-1 run()方法执行中...
pool-1-thread-1 run()方法执行中...
pool-1-thread-1 run()方法执行中...
pool-1-thread-1 run()方法执行中...
pool-1-thread-1 run()方法执行中...

public class SingleThreadExecutorTest {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        MyRunnable runnableTest = new MyRunnable();
        for (int i = 0; i < 5; i++) {
            executorService.execute(runnableTest);
        }
        System.out.println("线程任务开始执行");
        executorService.shutdown();
    }
}
运行结果：
pool-1-thread-1 run()方法执行中...
pool-1-thread-1 run()方法执行中...
pool-1-thread-1 run()方法执行中...
pool-1-thread-1 run()方法执行中...
pool-1-thread-1 run()方法执行中...
线程任务开始执行

14.说一下 runnable 和 callable 有什么区别?

相同点

都是接口
都可以编写多线程程序
都采用Thread.start()启动线程

主要区别

Runnable 接口 run 方法无返回值;
Callable 接口 call 方法有返回值，是个泛型，和Future、FutureTask配合可以用来获取异步执行的结果
Runnable 接口 run 方法只能抛出运行时异常，且无法捕获处理;Callable 接口 call 方法允许抛出异常，可以获取异常信息

注:Callalbe接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。

15.线程的 run()和 start()有什么区别?

每个线程都是通过某个特定Thread对象所对应的方法run()来完成其操作的， run()方法称为线程体。通过调用Thread类的start()方法来启动一个线程。

start() 方法用于启动线程，run() 方法用于执行线程的运行时代码。
run() 可以重复调用，而 start() 只能调用一次。
start()方法来启动一个线程，真正实现了多线程运行。
调用start()方法无需等待 run方法体代码执行完毕，可以直接继续执行其他的代码; 此时线程是处于就绪状态，并没有运行。然后通过此Thread类调用方法run()来完成其运行状态， run()方法运行结束，此线程终止。然后CPU再调度其它线程。
run()方法是在本线程里的，只是线程里的一个函数，而不是多线程的。如果直接调用run()，其实就相当于是调用了一个普通函数而已，直接调用run()方法必须等待run()方法执行完毕才能执行下面的代码，所以执行路径还是只有一条，根本就没有线程的特征，所以在多线程执行时要使用start()方法而不是run()方法。
16.为什么我们调用 start() 方法时会执行 run() 方法，为什么我们不能直接调用 run() 方法?
new一个 Thread，线程进入了新建状态。调用 start() 方法，会启动一个线程并使线程进入了就绪状态，当分配到时间片后就可以开始运行了。 start() 会执行线程的相应准备工作，然后自动执行 run() 方法的内容，这是真正的多线程工作。而直接执行 run() 方法，会把 run 方法当成一个 main 线程下的普通方法去执行，并不会在某个线程中执行它，所以这并不是多线程工作。

总结: 调用 start 方法方可启动线程并使线程进入就绪状态，而 run 方法只是 thread 的一个普通方法调用，还是在主线程里执行。

17.什么是 Callable 和 Future?

Callable 接口类似于 Runnable，从名字就可以看出来了，但是 Runnable 不会返回结果，并且无法抛出返回结果的异常，而 Callable 功能更强大一些，被线程执行后，可以返回值，这个返回值可以被 Future 拿到，也就是说，Future 可以拿到异步执行任务的返回值。Future 接口表示异步任务，是一个可能还没有完成的异步任务的结果。所以说 Callable用于产生结果，Future 用于获取结果。

18.什么是 FutureTask

FutureTask 表示一个异步运算的任务。FutureTask 里面可以传入一个 Callable 的具体实现类，可以对这个异步运算的任务的结果进行等待获取、判断是否已经完成、取消任务等操作。只有当运算完成的时候结果才能取回，如果运算尚未完成 get 方法将会阻塞。一个 FutureTask 对象可以对调用了 Callable 和 Runnable 的对象进行包装，由于 FutureTask 也是Runnable 接口的实现类，所以 FutureTask 也可以放入线程池中。

知识梳理

6.1.基础篇(一)

1.并发编程的优缺点

2.并发编程三要素是什么?在 Java 程序中怎么保证多线程的运行安全?

3.并行和并发有什么区别?

4.什么是多线程，多线程的优劣?

5.什么是线程和进程?

6.进程与线程的区别

7.什么是上下文切换?