多线程知识点(话术)

[必会]什么是线程?

同一个进程内可以执行多个任务，而这每一个任务就可以看做一个线程。
线程 ： 是程序的执行单元 也叫执行路径。是程序使用cpu的基本单位。
单线程：程序只有一条执行路径。
多线程：程序有多条执行路径。
[必会]线程和进程有什么区别?

线程是进程的子集，
一个进程可以有很多线程，
每条线程并行执行不同的任务。
不同的进程使用不同的内 存空 间，
而所有的线程共享一片相同的内存空间。
每个线程都拥有单独的栈内存用来存储本地数据。
[必会]我们如何创建一个线程
继承Thread类

A:自定义类MyThread继承Thread类
B:在MyThread类中重写run()
C:创建MyThread类的对象
D:启动线程对象
实现Runnable接口

A:自定义类MyRunnable实现Runnable接口
B:在MyRunnable里面重写run()
C:创建MyRunnable类的对象
D:创建Thread类的对象,并把C步骤的对象作为构造参数传递
[必会]可以直接调用Thread类的run()方法么

当然可以，但是如果我们调用了Thread的run()方法，
它的行为就会和普通的方法一样，为了在新的线程中执行我们的代码，
必须使用Thread.start()方法。
[必会]生命周期(几种状态)

线程的状态以及状态之间的相互转换： 　
1、新建状态(New)：新创建了一个线程对象。 　　
2、就绪状态(Runnable)：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。 　　
3、运行状态(Running)：就绪状态的线程获取了CPU，执行程序代码。 　　
4、阻塞状态(Blocked)：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。
5、死亡状态(Dead)：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。等待被销毁。
[必会]线程中run和start方法有什么区别？

Thread的start才是正在开启线程,使线程处于一个就绪状态。
Run只是调用了一个普通方法，并没有启动另一个线程，程序还是会按照顺序执行相应的代码 Start则表示，重新开启一个线程，不必等待其他线程运行完，只要得到cpu就可以运行该线程
[必会]wait和sleep的区别

1、sleep()方法是属于Thread类中的，而wait()方法，则是属于Object类中的。
2、sleep()方法导致了程序暂停执行指定的时间，让出cpu给其他线程，但是他的监控状态依然保持着，当指定的时间到了又会自动恢复运行状态。所以在调用sleep()方法的过程中，线程不会释放对象锁。
3、调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备获取对象锁进入运行状态。
[必会]java线程池概述

java线程池的工作原理和数据库连接池的差不多，因为每次重新创建线程 都是很耗资源的操作，所以我们可以建立一个线程池，这样当需要用到线程 进行某些操作时，就可以直接去线程池里面找到空闲的线程，这样就可以直接 使用，而不用等到用到的时候再去创建，用完之后可以把该线程重新放入线程池 供其他请求使用从而提高应用程序的性能。

如何让正在运行的线程暂停一段时间

我们可以使用Thread类的Sleep()方法让线程暂停一段时间。
需要注意的是，这并不会让线程终止，
一旦从休眠中唤醒线程，线程的状态将会被改变为Runnable，
并且根据线程调度，它将得到执行。
用户线程和守护线程有什么区别

当我们在Java程序中创建一个线程，
它就被称为用户线程。
一个守护线程是在后台执行并且不会阻止JVM终止的线程。
当没有用户线程在运行的时候，JVM关闭程序并且退出。
一个守护线程创建的子线程依然是守护线程
比如说我们java中的GC回收 就是一个守护线程
你对线程优先级的理解是什么？

每一个线程都是有优先级的，一般来说，高优先级的线程在运行时会具有优先权，但这依赖于线程调度的实现，这个实现是和操作系统相关的(OS dependent)。我们可以定义线程的优先级，但是这并不能保证高优先级的线程会在低优先级的线程前执行。线程优先级是一个int变量(从1-10)，1代表最低优先级，10代表最高优先级
线程池的优点

重用线程池中的线程,减少因对象创建,销毁所带来的性能开销;
能有效的控制线程的最大并发数,提高系统资源利用率,同时避免过多的资源竞争,避免堵塞;
能够多线程进行简单的管理,使线程的使用简单、高效。
线程池框架Executor

java中的线程池是通过Executor框架实现的，
Executor 框架包括类：
Executor，Executors，ExecutorService，
ThreadPoolExecutor ，
Callable和Future、FutureTask的使用等
Executor: 所有线程池的接口,只有一个方法。
ExecutorService: 增加Executor的行为，是Executor实现类的最直接接口。
Executors： 提供了一系列工厂方法用于创先线程池，返回的线程池都实现了ExecutorService 接口。
ThreadPoolExecutor：线程池的具体实现类,一般用的各种线程池都是基于这个类实现的
corePoolSize：线程池的核心线程数,线程池中运行的线程数也永远不会超过 corePoolSize 个,默认情况下可以一直存活。可以通过设置allowCoreThreadTimeOut为True,此时 核心线程数就是0,此时keepAliveTime控制所有线程的超时时间。
maximumPoolSize：线程池允许的最大线程数;
keepAliveTime： 指的是空闲线程结束的超时时间;
unit ：是一个枚举，表示 keepAliveTime 的单位;
workQueue：表示存放任务的BlockingQueue Runnable队列。
BlockingQueue:阻塞队列（BlockingQueue）是java.util.concurrent下的主要用来控制线程同步的工具。
Java关键字volatile与synchronized作用与区别?

1,volatile 它所修饰的变量不保留拷贝，直接访问主内存中的。 在Java内存模型中，有main memory，每个线程也有自己的memory (例如寄存器）。为 了性 能，一个线程会在自己的memory中保持要访问的变量的副本。这样就会出现同一个变量在某个瞬间， 在一个线 程的memory中的值可能与另外一个线程memory中的值，或者main memory中的值不一致的情况。一 个变量 声明为volatile，就意味着这个变量是随时会被其他线程修改的，因此不能将它cache在线程memory 中。
2， synchronized 当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代 码。 -、当两个并发线程访问同一个对象object中的这个synchronized( this)同步代码块时 ，一个 时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块 二、 然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线 程仍然 可以访问该object中的非synchronized (this)同步代码块。
3、 尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时， 其他线 程对object中所有其它synchronized (this)同步代码块的访问将被阻塞。
4、当一个线程访问object的一个synchronized (this)同步代码块时，它就获得了这个 object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。
5、以上规则对其它对象锁同样适用.
同步方法和同步块，哪个是更好的选择？

同步块是更好的选择，因为它不会锁住整个对象
（当然你也可以让它锁住整个对象）。
同步方法会 锁住整 个对象，哪怕这个类中有多个不相关联的同步块，
这通常会导致他们停止执行并需要等待获得这个对象上
并发线程局部变量-ThreadLocal

ThreadLocal是一个线程级别的局部变量，并非“本地线程”。
ThreadLocal为每个使用该变量的线程提供了一个独立的变量副本，
每个线程修改副本时不影响其他线程对象的副本 线程局部变量（ThreadLocal variables)的关键点：
一个线程局部变量为每个线程方便的提供了一个单独的变量。
Threadlocal实例通常作为静态的私有的字段出现在一个类中，这个类用来关联一个线程。
当多个线程访问ThreadLocal实例时，每个线程维护ThreadLocal提供的独立的变量副本。
常用的使用可在Dao模式中见到，当Dao类作为一个单例类时，数据库连接被每一个线程独立的维护，互不影响
Lock和synchronized

1）Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；

2）synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；

3）Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；

4）通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。

5）Lock可以提高多个线程进行读操作的效率。

在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。所以说，在具体使用时要根据适当情况选择。
并发安全之volatile

当我们使用volatile关键字去修饰变量的时候，

所以线程都会直接读取该变量并且不缓存它。

这就确保了线程读取到的变量是同内存中是一致的。
并发安全之synchronized

在多线程并发访问资源（这类资源称为临街资源）的时候，由于割裂来了原子操作，所以会导致数据不一致的情况。为了避免这种情况，需要使用同步机制，同步机制能够保证多线程并发访问数据的时候不会出现数据不一致的情况。

一种同步机制是使用synchronized关键字，这种机制也称为互斥锁机制，这就意味着同一时刻只能有一个线程能够获取到锁，获得的锁也被称为互斥锁。其他需要获取该互斥锁的线程只能被阻塞，直到获取到该锁的线程释放锁。在Java中，每个类都有一个内置锁，之所以如此，是因为Java并发专家认为这样可以避免显式创建锁。
并发安全之Lock

Lock是java在1.5以后提供的线程安全接口，里面定义了几个方法：

如:

lock()、tryLock()、tryLock(long time, TimeUnit unit)和lockInterruptibly()是用来获取锁的。unLock()方法是用来释放锁的
Lock lock = …;
if(lock.tryLock()) { //获取锁
try{
//处理任务
}catch(Exception ex){

}finally{
lock.unlock(); //释放锁
}

}else {
//如果不能获取锁，则直接做其他事情
}
使用Lock必须要求我们手动释放锁。 （lock.unlock()方法）

不然可能造成死锁。
不可变对象对多线程有什么帮助

前面有提到过的一个问题，

不可变对象保证了对象的内存可见性，

对不可变对象的读取不需要进行额外的同步手段，

提升了代码执行效率。 前面有提到过的一个问题，

不可变对象保证了对象的内存可见性，对不可变对象的读取不需要进行额外的同步手段，

提升了代码执行效率。 前面有提到过的一个问题，不可变对象保证了对象的内存可见性，

对不可变对象的读取不需要进行额外的同步手段，提升了代码执行效率。
线程之间是如何通信的？

当线程间是可以共享资源时，

线程间通信是协调它们的重要的手段。

Object类中wait()\notify()\notifyAll()方法

可以用于线程间通信关于资源的锁的状态
notify和notifyAll区别

他们的作用都是通知处于等待该对象的线程。 1、notifyAll使所有原来在该对象上等待被notify的线程统统退出wait的状态，变成等待该对象上的锁，一旦该对象被解锁，他们就会去竞争。 2、notify是通知其中一个线程，不会通知所有的线程。
volatile关键字在Java中有什么作用？

当我们使用volatile关键字去修饰变量的时候，

所以线程都会直接读取该变量并且不缓存它。

这就确保了线程读取到的变量是同内存中是一致的。
同步方法和同步块

同步块，这意味着同步块之外的代码是异步执行的，这比同步整个方法更提升代码的效率。

请知道一条原则：同步的范围越小越好。

借着这一条，我额外提一点，虽说同步的范围越少越好，但是在Java虚拟机中还是存在着一种叫做锁粗化的优化方法，这种方法就是把同步范围变大。

这是有用的，比方说StringBuffer，它是一个线程安全的类，自然最常用的append()方法是一个同步方法，我们写代码的时候会反复append字符串，

这意味着要进行反复的加锁->解锁，这对性能不利，因为这意味着Java虚拟机在这条线程上要反复地在内核态和用户态之间进行切换，因此Java虚拟机会将多次append方法调用的代码进行一个锁粗化的操作，将多次的append的操作扩展到append方法的头尾，变成一个大的同步块，这样就减少了加锁–>解锁的次数，有效地提升了代码执行的效率。
常见线程名词解释

主线程：JVM调用程序main()所产生的线程。
当前线程：这个是容易混淆的概念。一般指通过Thread.currentThread()来获取的进程。
后台线程：指为其他线程提供服务的线程，也称为守护线程。JVM的垃圾回收线程就是一个后台线程。
用户线程和守护线程的区别在于，是否等待主线程依赖于主线程结束而结束
前台线程：是指接受后台线程服务的线程，其实前台后台线程是联系在一起，就像傀儡和幕后操纵者一样的关系。傀儡是前台线程、幕后操纵者是后台线程。由前台线程创建的线程默认也是前台线程。可以通过isDaemon()和setDaemon()方法来判断和设置一个线程是否为后台线程。
线程类的一些常用方法：

sleep(): 强迫一个线程睡眠Ｎ毫秒。

isAlive(): 判断一个线程是否存活。

join(): 等待线程终止。

activeCount(): 程序中活跃的线程数。

enumerate(): 枚举程序中的线程。

currentThread(): 得到当前线程。

isDaemon(): 一个线程是否为守护线程。

setDaemon(): 设置一个线程为守护线程。(用户线程和守护线程的区别在于，是否等待主线程依赖于主线程结束而结束)

setName(): 为线程设置一个名称。

wait(): 强迫一个线程等待。

notify(): 通知一个线程继续运行。

setPriority(): 设置一个线程的优先级。
什么是死锁

死锁就是两个或两个以上的线程被无限的阻塞，线程之间相互等待所需资源。这种情况可能发生在当两个线程尝试获取其它资源的锁，而每个线程又陷入无限等待其它资源锁的释放，除非一个用户进程被终止。就 JavaAPI 而言，线程死锁可能发生在一下情况。 当两个线程相互调用 Thread.join () 当两个线程使用嵌套的同步块，一个线程占用了另外一个线程必需的锁，互相等待时被阻塞就有可能出现死锁
多线程高并发业务问题

处理高并发一般有分流和队列两种分式。

分流可以用集群实现。

队列可以用activeMQ消息队列或者线程锁。

集群我搭建过nginx+tomcat+redis的集群；

消息队列就是把所有的线程消息集中管理，

排成对一个一个的进行。具体的实现方式，我没有去转入的研究过。

线程锁的方式在生成订单编号时用到过，就是在生成编号的方法上加上syn开头的同步锁。对了我们做项目中有个同事提到了用redis可以实现，说redis是单线程的。如果把库存放到redis里边，就可以防止负库存的实现。还有就是我们项目中有时候会用到线程池的技术，比如做数据的批量导入时，如果使用单线程方式，速度会很慢，如果引入线程池，同时开启n个线程，同时进行就可以增加很大的效率。 问题：java开启线程的几种方式：我了解的有继承Thread类，实现runable接口。但是我们现在基本上这样用的比较少，大部分时间都是开启一个spring的线程池。ThreadPoolTaskExecutor
Semaphore有什么作用

Semaphore就是一个信号量，它的作用是限制某段代码块的并发数。
Semaphore有一个构造函数，可以传入一个int型整数n，表示某段代码最多只有n个线程可以访问，
如果超出了n，那么请等待，等到某个线程执行完毕这段代码块，下一个线程再进入。由此可以看出如果Semaphore构造函数中传入的int型整数n=1，相当于变成了一个synchronized了。
CyclicBarrier和CountDownLatch的区别

两个看上去有点像的类，都在java.util.concurrent下，都可以用来表示代码运行到某个点上，二者的区别在于：

（1）CyclicBarrier的某个线程运行到某个点上之后，该线程即停止运行，直到所有的线程都到达了这个点，所有线程才重新运行；CountDownLatch则不是，某线程运行到某个点上之后，只是给某个数值-1而已，该线程继续运行

（2）CyclicBarrier只能唤起一个任务，CountDownLatch可以唤起多个任务

（3）CyclicBarrier可重用，CountDownLatch不可重用，计数值为0该CountDownLatch就不可再用了
线程调度器(Thread Scheduler)和时间分片(Time Slicing)

线程调度器是一个操作系统服务，它负责为Runnable状态的线程分配CPU时间。一旦我们创建一个线程并启动它，它的执行便依赖于线程调度器的实现。 时间分片是指将可用的CPU时间分配给可用的Runnable线程的过程。分配CPU时间可以基于线程优先级或者线程等待的时间。线程调度并不受到Java虚拟机控制，所以由应用程序来控制它是更好的选择（也就是说不要让你的程序依赖于线程的优先级）。