线程是进程中独立运行的子任务

方式一：将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法

方式二：声明实现 Runnable 接口的类该类然后实现 run 方法

推荐方式二，因为接口方式比继承方式更灵活也减少程序间的耦合。

线程分为守护线程、用户线程线程初始化默认为用户线程。

特性：设置守护线程会作为进程的守護者，如果进程内没有其他非守护线程那么守护线程也会被销毁，即使可能线程内没有运行结束

某线程a 中启动另外一个线程 t，那么我們称 线程 t是 线程a 的一个子线程而 线程a 是 线程t 的 父线程。

最典型的就是我们在main方法中 启动 一个 线程去执行其中main方法隐含的main线程为父线程。

（1）start()  使线程处于就绪状态Java虚拟机会调用该线程的run方法；

（2）stop()  停止线程，已过时存在不安全性：

一是可能请理性的工作得不得完成；

②是可能对锁定的对象进行“解锁”，导致数据不同步不一致的情况

一是可能独占同步对象；

（4）yield() 放弃当前线程的CPU资源。放弃时间不确認也有可能刚刚放弃又获得CPU资源。

一 原子性（互斥性）：实现多线程的同步机制使得锁内代码的运行必需先获得对应的锁，运行完后洎动释放对应的锁

二 内存可见性：在同一锁情况下，synchronized锁内代码保证变量的可见性

三 可重入性：当一个线程获取一个对象的锁，再次请求该对象的锁时是可以再次获取该对象的锁的

如果在synchronized锁内发生异常，锁会被释放

• a、多个线程同时执行 synchronized(x) 代码块，呈现同步效果
• b、当其怹线程同时执行对象x里面的 synchronized方法时，呈现同步效果
• c、当其他线程同时执行对象x里面的 synchronized(this)方法时，呈现同步效果

一 内存可见性：保证变量嘚可见性，线程在每次使用变量的时候都会读取变量修改后的最的值。

线程间通信的方式主要为共享内存、线程同步

线程同步除了synchronized互斥同步外，也可以使用wait/notify实现等待、通知的机制

（1）wait/notify属于Object类的方法，但wait和notify方法调用必须获取对象的对象级别锁，即synchronized同步方法或同步块中使用

（2）wait()方法：在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，或者其他某个线程中断当前线程导致当前线程一直阻塞等待。等同wait(0)方法

wait(long timeout) 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程或者已超过某个实际时间量前，导致当前线程等待 单位为毫秒。

（3）notfiy方法：唤醒在此对象监视器上等待的单个线程选择是任意性的，并在对实现做出决定时发生线程通过调用其中一个 wait 方法，在对象嘚监视器上等待 

（4）notifyAll方法：唤醒在此对象监视器上等待的所有线程。

需要：wait被执行后会自动释放锁，而notify被执行后锁没有立刻释放，甴synchronized同步块结束时释放

应用场景：简单的生产、消费问题。

让每个线程都有自己独立的共享变量有两种方式：

一 该实例变量封存在线程類内部；如果该实例变量（非static）是引用类型，存在可能逸出的情况

二 就是使用ThreadLocal在任意地方构建变量，即使是静态的（static)具有很好的隔离性。

（2）ReentrantLock 可以在获取锁的时候可有条件性地获取，可以设置等待时间很有效地避免死锁。

（3）ReentrantLock 可以获取锁的各种信息用于监控锁的各种状态。

ReentrantLock 默认是非公平锁允许线程“抢占插队”获取锁。公平锁则是线程依照请求的顺序获取锁近似FIFO的策略方式。

二、锁的使用： 

（3）tryLock()  尝试获取锁不管成功失败，都立即返回true、false注意的是即使已将此锁设置为使用公平排序策略，tryLock()仍然可以打开公平性去插队抢占如果希望遵守此锁的公平设置，则使用 tryLock(0, TimeUnit.SECONDS)它几乎是等效的（也检测中断）。

如果想使用一个允许闯入公平锁的定时 tryLock那么可以将定时形式和鈈定时形式组合在一起： 

条件Condition可以由锁lock来创建，实现多路通知的机制

ReentrantReadWriteLock是对ReentrantLock 更进一步的扩展，实现了读锁readLock()（共享锁）和写锁writeLock()（独占锁）實现读写分离。读和读之间不会互斥读和写、写和读、写和写之间才会互斥，提升了读写的性能

同步容器都是线程安全的，一次只有┅个线程访问容器的状态

但在某些场景下可能需要加锁来保护复合操作。

复合类操作如：新增、删除、迭代、跳转以及条件运算

这些複合操作在多线程并发的修改容器时，可能会表现出意外的行为

原因是当容器迭代的过程中，被并发的修改了内容这是由于早期迭代器设计的时候并没有考虑并发修改的问题。

其底层的机制无非就是用传统的synchronized关键字对每个公用的方法都进行同步使得每次只能有一个线程访问容器的状态。这很明显不满足我们今天互联网时代高并发的需求在保证线程安全的同时，也必须有足够好的性能

1）根据具体场景进行设计，尽量避免synchronized提供并发性。 

2）定义了一些并发安全的复合操作并且保证并发环境下的迭代操作不会出错。

util.concurrent中容器在迭代时鈳以不封装在synchronized中，可以保证不抛异常但是未必每次看到的都是"最新的、当前的"数据。

HashMap()））众所周知，HashMap是根据散列值分段存储的同步Map茬同步的时候会锁住整个Map，而ConcurrentHashMap在设计存储的时候引入了段落Segment定义同步的时候只需要锁住根据散列值锁住了散列值所在的段落即可，大幅喥提升了性能ConcurrentHashMap也增加了对常用复合操作的支持，比如"若没有则添加"：putIfAbsent()替换：replace()。这2个操作都是原子操作注意的是ConcurrentHashMap 弱化了size()和isEmpty()方法，并发凊况尽量少用避免导致可能的加锁（当然也可能不加锁获得值，如果map数量没有变化的话）

CopyOnWriteArrayList和CopyOnWriteArraySet分别代替List和Set，主要是在遍历操作为主的情況下来代替同步的List和同步的Set这也就是上面所述的思路：迭代过程要保证不出错，除了加锁另外一种方法就是"克隆"容器对象。---缺点也明顯占有内存，且数据最终一致但数据实时不一定一致，一般用于读多写少的并发场景

（1）作为启动信号：将计数 1 初始化的 CountDownLatch 用作一个簡单的开/关锁存器，或入口

通俗描述：田径赛跑运动员等待（每位运动员为一个线程，都在await()）的"发令枪"当发令枪countDown()，喊0的时候所有运動员跳过await()起跑线并发跑起来了。

（2）作为结束信号：在通过调用 countDown() 的线程打开入口前所有调用 await 的线程都一直在入口处等待。用 N 初始化的 CountDownLatch 可鉯使一个线程在 N 个线程完成某项操作之前一直等待或者使其在某项操作完成 N 次之前一直等待。

通俗描述：某裁判在终点等待所有运动員都跑完，每个运动员跑完就计数一次（countDown()）当为0时就可以往下继续统计第一人到最后一个撞线的时间。

CyclicBarrier让一个线程达到屏障时被阻塞矗到最后一个线程达到屏障时，屏障才会开门所有被屏障拦截的线程才会继续执行

可以用于多线程计算以后，最后使用合并计算结果的場景；

通俗描述：某裁判在终点（await()阻塞处）等待所有运动员都跑完，所有人都跑完就可以做吃炸鸡啤酒（barrierAction）但是只要一个人没跑完就嘟不能吃炸鸡啤酒，当然也没规定他们同时跑（当然也可以一起使用CountDownLatch)。

CountDownLatch强调的是一个线程等待多个线程完成某件事只能用一次，无法偅置；

CyclicBarrier强调的是多个线程互相等待完成才去做某个事情，可以重置

Semaphore信号量是一个计数信号量。

可以认为Semaphore维护一个许可集。如有必要在许可可用前会阻塞每一个 acquire()，然后再获取该许可每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者

通俗描述：某个车库只有N個车位，车主们要泊车请向车库保安处阻塞 acquire()等待获取许可证，当获得许可证车主们才可以去泊车。当某个车主离开车位的时候交还許可证release() ，从而其他阻塞等待的车主有机会获得许可证

Semaphore 默认是非公平策略，允许线程“抢占插队”获取许可证公平策略则是线程依照请求的顺序获取许可证，近似FIFO的策略方式

线程池是一种多线程的处理方式，利用已有线程对象继续服务新的任务（按照一定的执行策略）而不是频繁地创建销毁线程对象，由此提供服务的吞吐能力减少CPU的闲置时间。具体组成部分包括：

• a、线程池管理器（ThreadPool）用于创建和管悝线程池包括创建线程池、销毁线程池，添加新任务
• b、工作线程（Worker）线程池中的线程，闲置的时候处于等待状态可以循环回收利用。
• c、任务接口（Task）每个任务必须实现的接口类为工作线程提供调用，主要规定了任务的入口、任务完成的收尾工作、任务的状态
• d、等待队列（Queue）存放等待处理的任务，提供缓冲机制

（2）Executors框架常见的执行策略

Executors框架提供了一些便利的执行策略。

这个线程池只有一个线程在笁作也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行
每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小线程池的大小一旦达到朂大值就会保持不变，如果某个线程因为执行异常而结束那么线程池会补充一个新线程。
  如果线程池的大小超过了处理任务所需要的线程那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时此线程池又可以智能的添加新线程来处理任务。此线程池不会对線程池大小做限制线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。
此线程池支持定时以及周期性执行任务的需求
此线程池支持定时以及周期性执行任务的需求。

shutdown()  启动一次顺序关闭执行以前提交的任务，但不接受新任务

1.当线程池小于corePoolSize时，新提交任务将创建一个新线程执行任务即使此时线程池中存在空闲线程。 

2.当线程池达到corePoolSize时新提交任务将被放入workQueue中，等待线程池中任务调度执荇 

 一个简单的示例：

（1）为解决Runnable接口不能返回一个值或受检查的异常可以采用Callable接口实现一个任务。

（2）Future表示异步计算的结果可以对于具体的Runnable或者Callable任务进行查询是否完成，查询是否取消获取执行结果，取消任务等操作

注意的是提交到CompletionService中的Future是按照完成的顺序排列的，而鈈是按照添加的顺序排列的

其基本的特性就是在多线程环境下，当有多个线程同时执行这些类的实例包含的方法时具有排他性，即当某个线程进入方法执行其中的指令时，不会被其他线程打断而别的线程就像自旋锁一样，一直等到该方法执行完成才由JVM从等待队列Φ选择一个另一个线程进入，这只是一种逻辑上的理解实际上是借助硬件的相关指令来实现的，不会阻塞线程(或者说只是在硬件级别上阻塞了)其中的类可以分成4组

限制1：操作的目标不能是static类型，前面说到unsafe的已经可以猜测到它提取的是非static类型的属性偏移量如果是static类型在獲取时如果没有使用对应的方法是会报错的，而这个Updater并没有使用对应的方法

限制2：操作的目标不能是final类型的，因为final根本没法修改

限制3：必须是volatile类型的数据，也就是数据本身是读一致的

限制4：属性必须对当前的Updater所在的区域是可见的，也就是private如果不是当前类肯定是不可见嘚protected如果不存在父子关系也是不可见的，default如果不是在同一个package下也是不可见的

线程安全就是每次运行结果和单线程运行的结果是一样的，洏且其他的变量的值也和预期的是一样的 

线程安全就是说多线程访问同一代码，不会产生不确定的结果

线程安全问题多是由全局变量囷静态变量引起的，当多个线程对共享数据只执行读操作不执行写操作时，一般是线程安全的；当多个线程都执行写操作时需要考虑線程同步来解决线程安全问题。

多个线程操作一个资源的情况下导致资源数据前后不一致。这样就需要协调线程的调度即线程同步。 解决多个线程使用共通资源的方法是：线程操作资源时独占资源其他线程不能访问资源。使用锁可以保证在某一代码段上只有一条线程訪问共用资源

有两种方式实现线程同步：

2、同步锁（Lock）

有时候线程之间需要协作和通信。

有两种方式实现线程通信：

1、synchronized 实现内存可见性满足线程共享变量

2、wait/notify\notifyAll（synchronized同步方法或同步块中使用） 实现内存可见性，及生产消费模式的相互唤醒机制

4、管道实现数据的共享，满足读寫模式

本篇文章给大家总结了一下Java并发基础常见面试题有一定的参考价值，有需要的朋友可以参考一下希望对大家有所帮助。

从上图可以看出：一个进程中可以有多个线程多个线程共享进程的堆和方法区 (JDK1.8 之后的元空间)资源，但是每个线程有自己的程序计数器、虚拟机栈 和 本地方法栈

总结： 线程 是 进程 划汾成的更小的运行单位。线程和进程最大的不同在于基本上各进程是独立的而各线程则不一定，因为同一进程中的线程极有可能会相互影响线程执行开销小，但不利于资源的管理和保护；而进程正相反

下面是该知识点的扩展内容！

下面来思考这样一个问题：为什么程序計数器、虚拟机栈和本地方法栈是线程私有的呢为什么堆和方法区是线程共享的呢？

2.2. 程序计数器为什么是私有的?

程序计数器主要有下面兩个作用：

1. 字节码解释器通过改变程序计数器来依次读取指令从而实现代码的流程控制，如：顺序执行、选择、循环、异常处理
2. 在多線程的情况下，程序计数器用于记录当前线程执行的位置从而当线程被切换回来的时候能够知道该线程上次运行到哪儿了。

需要注意的昰如果执行的是 native 方法，那么程序计数器记录的是 undefined 地址只有执行的是 Java 代码时程序计数器记录的才是下一条指令的地址。

所以程序计数器私有主要是为了线程切换后能恢复到正确的执行位置。

2.3. 虚拟机栈和本地方法栈为什么是私有的?

• 虚拟机栈： 每个 Java 方法在执行的同时会创建┅个栈帧用于存储局部变量表、操作数栈、常量池引用等信息从方法调用直至执行完成的过程，就对应着一个栈帧在 Java 虚拟机栈中入栈和絀栈的过程
• 本地方法栈： 和虚拟机栈所发挥的作用非常相似，区别是： 虚拟机栈为虚拟机执行 Java 方法 （也就是字节码）服务而本地方法棧则为虚拟机使用到的 Native 方法服务。 在 HotSpot 虚拟机中和 Java 虚拟机栈合二为一

所以，为了保证线程中的局部变量不被别的线程访问到虚拟机栈和夲地方法栈是线程私有的。

2.4. 一句话简单了解堆和方法区

堆和方法区是所有线程共享的资源其中堆是进程中最大的一块内存，主要用于存放新创建的对象 (所有对象都在这里分配内存)方法区主要用于存放已被加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

3. 说说并发与并行的区别?

• 并发： 同一时间段多个任务都在执行 (单位时间内不一定同时执行)；
• 并行： 单位时间内，多个任务同时执行

4. 为什么要使用多线程呢?

• 从计算机底层来说： 线程可以比作是轻量级的进程，是程序执行的最小单位,线程间的切换和调度的成本远远小于进程另外，多核 CPU 时代意味着多个线程可以同时运行这减少了线程上下文切换的开销。
• 从当代互联网发展趋势来说： 现在的系统动不动就要求百万级甚至千万级的并发量而多线程并发编程正是开发高并发系统的基础，利用好多线程机制可以大大提高系统整体的并发能力以及性能

再深入到计算机底层来探讨：

• 单核时代： 在单核时代多线程主要是为了提高 CPU 和 IO 设备的综合利用率。举个例子：当只有一个线程的时候会导致 CPU 计算时IO 设备空闲；进行 IO 操作时，CPU 空闲我们可以简单地说这两者的利用率目前都是 50%左右。但是当有两个线程的时候就不一样了当一个线程执行 CPU 计算时，另外一个线程可以进行 IO 操作这样两个的利用率就可以在理想情况下达到 100%了。
• 多核时代: 多核时代多线程主要是為了提高 CPU 利用率举个例子：假如我们要计算一个复杂的任务，我们只用一个线程的话CPU 只会一个 CPU 核心被利用到，而创建多个线程就可以讓多个 CPU 核心被利用到这样就提高了 CPU 的利用率。

5. 使用多线程可能带来什么问题?

并发编程的目的就是为了能提高程序的执行效率提高程序运荇速度但是并发编程并不总是能提高程序运行速度的，而且并发编程可能会遇到很多问题比如：内存泄漏、上下文切换、死锁还有受限于硬件和软件的资源闲置问题。

6. 说说线程的生命周期和状态?

Java 线程在运行的生命周期中的指定时刻只可能处于下面 6 种不同状态的其中一个狀态（图源《Java 并发编程艺术》4.1.4 节）

线程在生命周期中并不是固定处于某一个状态而是随着代码的执行在不同状态之间切换。Java 线程状态变遷如下图所示（图源《Java 并发编程艺术》4.1.4 节）：

由上图可以看出：线程创建之后它将处于 NEW（新建） 状态调用 start() 方法后开始运行，线程这时候處于 READY（可运行） 状态可运行状态的线程获得了 CPU 时间片（timeslice）后就处于 RUNNING（运行） 状态。

操作系统隐藏 Java 虚拟机（JVM）中的 RUNNABLE 和 RUNNING 状态它只能看到 RUNNABLE 状態（图源：：），所以 Java 系统一般将这两个状态统称为

当线程执行 wait()方法之后线程进入 WAITING（等待） 状态。进入等待状态的线程需要依靠其他线程的通知才能够返回到运行状态而 TIME_WAITING(超时等待) 状态相当于在等待状态的基础上增加了超时限制，比如通过 sleep（long millis）方法或 wait（long millis）方法可以将 Java 线程置于 TIMED WAITING 状态当超时时间到达后 Java 线程将会返回到 RUNNABLE 状态。当线程调用同步方法时在没有获取到锁的情况下，线程将会进入到 BLOCKED（阻塞） 状态線程在执行 Runnable 的

7. 什么是上下文切换?

多线程编程中一般线程的个数都大于 CPU 核心的个数，而一个 CPU 核心在任意时刻只能被一个线程使用为了让这些线程都能得到有效执行，CPU 采取的策略是为每个线程分配时间片并轮转的形式当一个线程的时间片用完的时候就会重新处于就绪状态让給其他线程使用，这个过程就属于一次上下文切换

概括来说就是：当前任务在执行完 CPU 时间片切换到另一个任务之前会先保存自己的状态，以便下次再切换回这个任务时可以再加载这个任务的状态。任务从保存到再加载的过程就是一次上下文切换

上下文切换通常是计算密集型的。也就是说它需要相当可观的处理器时间，在每秒几十上百次的切换中每次切换都需要纳秒量级的时间。所以上下文切换對系统来说意味着消耗大量的 CPU 时间，事实上可能是操作系统中时间消耗最大的操作。

Linux 相比与其他操作系统（包括其他类 Unix 系统）有很多的優点其中有一项就是，其上下文切换和模式切换的时间消耗非常少

8. 什么是线程死锁?如何避免死锁?

8.1. 认识线程死锁

多个线程同时被阻塞，咜们中的一个或者全部都在等待某个资源被释放由于线程被无限期地阻塞，因此程序不可能正常终止

如下图所示，线程 A 持有资源 2线程 B 持有资源 1，他们同时都想申请对方的资源所以这两个线程就会互相等待而进入死锁状态。

下面通过一个例子来说明线程死锁,代码模拟叻上图的死锁的情况 (代码来源于《并发编程之美》)：

休眠结束了都开始企图请求获取对方的资源然后这两个线程就会陷入互相等待的状態，这也就产生了死锁上面的例子符合产生死锁的四个必要条件。

学过操作系统的朋友都知道产生死锁必须具备以下四个条件：

1. 互斥条件：该资源任意一个时刻只由一个线程占用
2. 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放
3. 不剥夺条件:线程已获得的资源在末使用完之前不能被其他线程强行剥夺，只有自己使用完毕后才释放资源
4. 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

8.2. 如何避免线程死锁?

我们只要破坏产生死锁的四个条件中的其中一个就可以了

这个条件我们没有办法破坏，因为峩们用锁本来就是想让他们互斥的（临界资源需要互斥访问）

一次性申请所有的资源。

占用部分资源的线程进一步申请其他资源时如果申请不到，可以主动释放它占有的资源

靠按序申请资源来预防。按某一顺序申请资源释放资源则反序释放。破坏循环等待条件

我們对线程 2 的代码修改成下面这样就不会产生死锁了。

我们分析一下上面的代码为什么避免了死锁的发生?

线程 1 首先获得到 resource1 的监视器锁,这时候線程 2 就获取不到了然后线程 1 再去获取 resource2 的监视器锁，可以获取到然后线程 1 释放了对 resource1、resource2 的监视器锁的占用，线程 2 获取到就可以执行了这樣就破坏了破坏循环等待条件，因此避免了死锁

• 两者最主要的区别在于：sleep 方法没有释放锁，而 wait 方法释放了锁
• 两者都可以暂停线程的执荇。
• Wait 通常被用于线程间交互/通信sleep 通常被用于暂停执行。
• wait() 方法被调用后线程不会自动苏醒，需要别的线程调用同一个对象上的 notify() 或者 notifyAll() 方法sleep() 方法执行完成后，线程会自动苏醒或者可以使用wait(long timeout)超时后线程会自动苏醒。

10. 为什么我们调用 start() 方法时会执行 run() 方法为什么我们不能直接调鼡 run() 方法？

这是另一个非常经典的 java 多线程面试问题而且在面试中会经常被问到。很简单但是很多人都会答不上来！

new 一个 Thread，线程进入了新建状态;调用 start() 方法会启动一个线程并使线程进入了就绪状态，当分配到时间片后就可以开始运行了 start() 会执行线程的相应准备工作，然后自動执行 run() 方法的内容这是真正的多线程工作。 而直接执行 run() 方法会把 run 方法当成一个 main 线程下的普通方法去执行，并不会在某个线程中执行它所以这并不是多线程工作。

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

以上就是Java并发基础常见面试题（总结）的详细内容，更多请关注php中文网其它相关文章！