Java并行程序基础，springboot的启动过程面试

本文主要是介绍Java并行程序基础，springboot的启动过程面试，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

public static void main(String[] args) throws InterruptedException {

Thread t1 = new Thread(()->{

while (true) {

if (Thread.currentThread().isInter

【一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义】

浏览器打开：qq.cn.hn/FTf 免费领取

rupted()) {

System.out.println(“Interrupt!”);

break;

}

try {

Thread.sleep(2000);

} catch (InterruptedException e) {

System.out.println(“Interrupted When Sleep”);

Thread.currentThread().interrupt();

}

Thread.yield();

}

});

t1.start();

Thread.sleep(1000);

t1.interrupt();

}

4. 如果在sleep的时候，线程被中断，则程序会抛出异常，并进入异常处理。在catch字句里，由于已经捕获了中断，我们可以立即退出线程，但是并没有这么做。因为**也许在这段代码中，还必须进行后续的处理，保障数据的一致性和完整性。**因此，执行了interrupt()方法再次中断自己，置上中断标志位。只有这么做，在检查isInterrupted()，才能发现当前线程已经被中断了。可以试一下将catch的interrupt注释掉进行验证。

5. Thread.sleep()方法由于中断而抛出异常，此时，它会清除中断标记，如果不加处理，那么在下一次循环开始时，就无法不会这个中断，所以在异常处理中，再次设置中断标志位。

6. 等待（wait）和通知（notify）

===================

1. wait和notify不是在Thread类中的方法，而是在Object类中，意味着任何对象都能调用这两个方法。

2. 如果一个线程调用了wait()方法，那么它就会计入object对象的等待队列。这个等待队列中，可能会有多个线程，因为系统运行多个线程同时等待同一个对象。当notify()被调用是，它就会从这个等待队列中，随机选择一个线程，并将其唤醒。但是这个选择不是公平的，并不是先等待的线程会优先被选择，这个选择完全是随机的。

3. notifyAll()方法会唤醒这个等待队列的所有线程。

4. 无论是wait()或者是notify()方法，必须包含在对应的synchronized语句中，无论是wait()或者notify()都需要首先获取目标对象的一个监视器。

5. 而wait()方法执行后，会释放这个监视器，当被重新notify()后，**要做的第一件事不是继续执行后续的代码，而是要尝试重新获取object的监视器。**如果暂时无法获得，线程还必须要等待这个监视器。当监视器顺利获得后，才可以真正意义上的继续执行。

6. wait()方法和sleep()的区别就是，wait会释放对象的锁，而sleep不会释放锁。

7. 挂起（Suspend）和继续执行（resume）

========================

1. 被挂起的线程必须要等到resume操作后，才能继续指定、

2. 但是已经被标注为废弃方法，不推荐使用。因为suspend()在导致线程暂停的同时，并不会去释放任何资源。此时，任何线程想要访问被它暂用的锁，都会备受牵连，导致无法正常运行。直到对应的线程上进行了resume()操作，被挂起的线程才能继续操作。但是如果resume操作在suspend之前就执行了，那么被挂起的线程就很难有机会被继续执行了。

3. 如果想要实现suspend跟resume，可以通过wait跟notify进行使用。

4. 等待线程结束（join）和谦让（yield）

==========================

1. 一个线程的输入可能非常依赖于另外一个或者多个线程的输出，所以，这个线程就需要等待依赖线程执行完毕，才能继续执行。

public final void join() throws InterruptedException

public final synchronized void join(long millis) throws InterruptedException

3. 第一个join()方法表示无限等待，它会一直阻塞当前线程，知道目标线程执行完毕。

4. 第二个join()给出了一个最大等待时间，如果超过给定时间目标线程还在执行，当前线程也会因为“等不及”，而继续往下执行。

5. join就是加入的意思，因此一个线程要加入另外一个线程，那么最好的方法就是等着它一起走。

public class JoinMain {

public volatile static int i = 0;

public static class AddThread extends Thread {

@Override

public void run() {

for (i = 0; i < 1000000; i++);

}

}

public static void main(String[] args) throws InterruptedException {

AddThread at = new AddThread();

at.start();

at.join();

System.out.println(i);

}

}

7. 主函数中，如果不用join()等待AddThread,那么得到的i很可能是0或者一个非常小的数字。因为AddThread还没执行完，i的值就已经被输出了。但使用join方法后，表示主线程愿意等待AddThread执行完毕，跟着AddThread一起往前走，所以在join()返回，AddThread已经执行完成，故i总是1000000；

8. join的本质是让调用线程wait()在当前线程对象实例上。

if (millis == 0) {

while (isAlive()) {

wait(0);

}

}

10. 可以看到，它调用线程在当前线程对象上进行等待。当执行完成后，被等待的线程会在退出前**调用notifyAll()**通知所有的等待线程继续执行。

11. 因此需要注意，不要在应用程序中，在Thread对象上使用类似wait()或者notify()等方法，因为这很有可能影响系统API的工作，或者被系统API所影响。

public static native void yield();

13. yield()这是个静态方法。一旦执行，它会使当前线程让出CPU。当前线程让出CPU后，还会进行CPU资源的争夺，但是是否能被再次分配到，就不一定了。

14. ​​​​​​​volatile与Java内存模型（JMM）

=================================

1. ​​​​​​​Java内存模型都是围绕着原子性，有序性，可见性展开。

2. Java使用了一些特殊的操作或者关键字来什么，告诉虚拟机，在这个地方，尤其注意，不能随意变动优化目标指令。volatile就是其中之一。

3. volatile：易变的，不稳定的。

4. 当volatile去申明一个变量，就等于告诉虚拟机。这个变量极有可能会被某些线程修改。为了确保这个变量被修改后，应用程序范围内所有线程都能够“看到”。虚拟机就必须采用一些特殊的手段，保证这个变量的可见性等特点。

5. volatile并不能替代锁。也无法保证一些符合操作的原子性。volatile无法保证i++原子性操作。

6. volatile能保障数据的可见性和有序性。

7. ​​​​​​​守护线程（Daemon）

=======================

1. ​​​​​​​守护线程是一种特殊的线程，是系统的守护者，在后台默默地完成一些系统性的服务。比如垃圾回收线程，JIT线程就可以理解为守护线程。

2. 线程的优先级

======

1. Java使用1~10表示线程优先级。**数字越大优先级越高。**​​​​​​​

2. 同步方法以及同步块

=========

1. 线程同步

1. 由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保障数据在方法中被访问时的正确性，在访问时加入锁机制**synchronized，**当一个线程获得对象的排他锁，独占资源，其他线程必须等待，使用后是否锁即可。但是存在以下问题：

2. 一个线程持有锁会导致其他所有需要此锁的线程挂起。

3. 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题

4. 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先倒置，引起性能问题。

5. 关键字synchronized的作用是实现线程间的同步。它的工作是对同步的代码加锁，使得每一次，只能有一个线程进入同步块，从而保证线程间的安全性。

6. 指定加锁对象：对给定对象加锁，进入同步代码前要获得给定对象的锁。

7. 直接作用于实例方法：相当于对当前实例加锁，进入同步代码前要获得当前实例的锁。

8. 直接作用于静态方法：相当于对当前类加锁，进入同步代码块要获得当前类的锁。

9. synchronized除了保证**线程同步，还可以保证线程之间的可见性和有序性。**从可见性上来说，synchronized可以完全代替volatile，只是使用上没那么方便。就有序性而言，由于synchronized限制每次只有一个线程可以访问同步块，无论同步块内的代码如何被乱序执行，只要保证串行语义一致性，那么执行结果总是一样的。

10. 同步方法

1. 可以通过private关键字来保证数据对象只能被方法访问，所以只需要针对方法提出一套机制，这套机制就是synchronized关键字。有synchronized方法和synchronized块

2. synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就会独占该锁，直到方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行

3. 缺陷：若将一个大的方法申明为synchronized将会影响效率。

4. 同步块

1. 同步块：synchronized（obj）{}

2. Obj 称之为 同步监视器

3. obj可以使任何对象，推荐使用共享资源作为同步监视器

4. 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class

5. 同步监视器的执行过程

6. 第一个线程访问，锁定同步监视器，执行其中代码

7. 第二个线程访问，返现同步监视器被锁定，无法访问

8. 第一个线程访问完毕，解锁同步监视器

9. 第二个线程访问，发现同步监视器没有锁，然后锁定并访问

10. 死锁

==

1. 多个线程各自占有一些资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方资源释放，都停止执行的情形，某一个同步块同时拥有“两个以上对象的锁”时，就可能发生“死锁”

2. 产生死锁的四个必要条件：

3. **互斥条件：**一个资源每次只能被一个进程使用

4. **请求与保持条件：**一个进程因请求资源而阻塞时，对已获得的资源保持不放

5. **不剥夺条件：**进程已获得的资源，在未使用完之前，不能强行剥夺

6. **循环等待条件：**若干进程之间形成一种头尾相接的循环等待资源关系

7. 只要破坏其中任意一个或多个条件就可以避免死锁发生

8. ​​​​​​​Lock（锁）

==============

1. java.util.concurrent.locks.Lock 接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象

2. ReentrantLock（可重入锁），它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显示加锁，释放锁。

3. 

4. synchronzied跟Lock对比

===================

1. Lock是显示锁（手动开启和关闭锁，别忘记关闭锁）synchronized是隐式锁，除了作用域自动释放

2. Lock只有代码块锁，synchronized有代码块锁和方法锁

3. 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性

4. 优先使用顺序

5. Lock > 同步代码块（已经进入了方法体，分配了相应资源） > 同步方法（在方法体之外）

这篇关于Java并行程序基础，springboot的启动过程面试的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！