前言：大家好，我是小威，24届毕业生，在一家满意的公司实习。本篇将记录几次面试中经常被问到的知识点以及对学习的知识点总结和面试题的复盘。
本篇文章记录的基础知识，适合在学Java的小白，也适合复习中，面试中的大佬🤩🤩。
如果文章有什么需要改进的地方还请大佬不吝赐教👏👏。
小威在此先感谢各位大佬啦~~🤞🤞
在这里插入图片描述

🏠个人主页：小威要向诸佬学习呀
🧑个人简介：大家好，我是小威，一个想要与大家共同进步的男人😉😉
目前状况🎉：24届毕业生，在一家满意的公司实习👏👏

🎁如果大佬在准备面试，可以使用我找实习前用的刷题神器哦刷题神器点这里哟
💕欢迎大家：这里是CSDN，我总结知识的地方，欢迎来到我的博客，我亲爱的大佬😘

在这里插入图片描述

以下正文开始

文章目录

进程和线程的区别
并行和并发的区别
sleep()和wait()区别
操作系统的线程
- 用户级线程
- 内核级线程
- 混合级线程
final，finally，finalize
可中断锁与不可中断锁
排他锁与共享锁
二叉树的最近公共祖先

进程和线程的区别

操作系统启动一个程序的时候，会为这个程序创建一个进程。一个进程可以创建多个线程，一个线程只属于一个进程。
进程是操作系统分配资源的最小单位，而线程是CPU调度的最小单位。一个进程中的多个线程拥有各自的局部变量，线程堆栈和程序计数器，但是能够访问同一进程的共享资源。
进程和进程之间是相互独立的，但是同一个进程之间的线程并不是完全独立的，它们可以共享进程中的堆内存，方法区内存和系统资源。
一个进程发生异常不会对其他进程产生影响，但是一个线程发生异常可能会对所在进程中的其他线程产生影响。
进程之间的上下文切换要比线程之间的上下文切换慢得多。
在这里插入图片描述

并行和并发的区别

并行是指多个线程在同一时刻同时运行，并发是指在同一时间段内同时运行（宏观上是同时运行，微观上是不同时运行的）。
并行是指在多核CPU下，一个CPU核心执行一个线程的时候，另一个CPU同时执行另一个线程，各个线程之间不会争夺CPU资源；而并发是指在一段时间内CPU执行了多个线程，CPU会根据时间片周期在线程之间来回切换，这些线程会争夺CPU的资源，因此在同一时刻不是同时运行的。
并行只有在多个或多核CPU下才会发生，在单核CPU下只能发生串行或并发现象。

在这里插入图片描述

sleep()和wait()区别

sleep()是Thread类中的方法，而wait()是Object中的方法。
调用sleep()方法时，线程不会释放对象锁，而是进入休眠状态，其他的线程无法拿到锁资源；而调用wait()方法，线程会释放对象锁资源，进入线程等待池中等待，为其他线程让出锁资源，其他线程可使用方法或代码块，当其他线程调用notify()或notifyAll()方法时，唤醒等待池中的线程或所有线程，就会进入就绪队列中，等待操作系统分配资源。
sleep()方法不需要强制和synchronized锁一起使用，而wait()和notify()，notifyAll()方法需要和synchronized锁一起使用，wait()和notify()，notifyAll()方法需要放在方法或同步代码块中使用。

在这里插入图片描述

操作系统的线程

操作系统的线程分为用户级线程，内核级线程，和混合级线程。

用户级线程

操作系统空间有用户空间和内核空间。对于用户级线程，用户级线程都是在操作系统的用户空间里创建的，不依赖操作系统的内核空间。用户级线程创建的线程都是在用户空间中进行的，所以线程的运行过程中不会涉及到用户态和内核态的切换。操作系统只能感知进程的存在，不会感知线程的存在，所以一个线程阻塞，会导致整个进程都阻塞。每个用户空间中的进程都会维护一个线程表，来追踪本进程中的线程，在内核级空间中会维护一个进程表来追踪用户空间中所创建的进程。

当然，用户级线程有优点亦有缺点。

用户级线程优点：
线程的切换并不会涉及到内核态和用户态之间的切换，不会影响效率；
用户级线程允许每个进程拥有自己的调度算法
缺点：
由于操作系统感知不到线程的存在，所以当一个线程发生阻塞时，即使同进程中的线程仍然在运行，操作系统也会阻塞整个进程；
用户空间中没有时钟中断机制，如果进程中的某个线程长时间没有释放CPU资源，那么其他线程就会由于得不到资源而长时间等待。

内核级线程

内核级线程的创建和管理都是在操作系统内核空间中进行的，并且操作系统内核同时维护了线程表和进程表来追踪线程和进程的执行状态。操作系统内核保存着线程的执行状态和执行的上下文，如果进程中的某个线程发生阻塞，不会阻塞整个进程，操作系统内核会调度进程中的其他线程。

内核级线程优点：
在内核级线程中，一个线程的阻塞不会导致整个进程的阻塞，操作系统内核可以调度进程中的其他线程，也可以调度其他进程中的线程，总之不会影响到进程；
操作系统内核可以将进程中的多个线程调度到不同的CPU核心上，能够大大增加线程的并行性度，从而提高程序的运行效率。
缺点：
内核级线程如果涉及到线程的阻塞和唤醒，可能会导致用户态和核心态之间的切换，影响程序的执行效率；
内核级线程比较慢，因为内核级线程的创建和管理都需要操作系统内核来实现。

混合级线程

混合级线程是用户级线程和内核级线程的相结合，混合级线程在用户空间中维护了线程表来追踪当前的线程，在内核空间中维护了线程表和进程表来追踪线程和进程的执行状态。并且在混合级线程中，操作系统只能感知到由操作系统内核创建的线程以及用户空间的线程基于内核空间的线程执行。由于用户空间的线程是基于内核空间的线程执行的，所以用户空间的线程数据间接决定了新建的内核空间的线程数量。

补充：我们调用Thread类中的start()方法创建Java线程，Java线程会和内核线程一一对应，每创建一个Java线程，就会在操作系统中创建一个对应的内核线程，而内核线程会被调度到CPU上执行。

在这里插入图片描述

final，finally，finalize

final为修饰符，可以用来修饰类，修饰方法，修饰变量。被final关键字修饰的类不能被继承，被final修饰的方法不能被其他类重写，被final修饰符修饰的变量为常量，并且必须被初始化，初始化之后该值不能被修改。

而对于finally，finally与try{ },catch{ },finally{ }共同使用。如果在try{ }代码块中出现异常，在catch{ }中会捕捉到异常，而finally{ }无论什么情况下，只要加了finally{ }，就一定会执行finally{ }中的代码。如果使用了try{},则必须要有catch{}或finally{}其中的一个。如果三个模块同时存在，并且catch{}模块中有return方法时，当try{}抛出异常，那么会等finally{}模块里的方法执行完毕，再执行catch{}中的return返回结果。

finalize()是Object类中的方法，在无用的对象被垃圾回收器回收时触发。
在这里插入图片描述

可中断锁与不可中断锁

可中断锁是指在多线程情况下可以被中断的锁，前面介绍的ReentranLock锁就是可中断锁。可以使用lockInterruptibly()可中断模式抢占锁方法，具体是通过Thread类中的interrupt()方法发出中断信号来使当前抢占锁的过程被中断；也可以使用 tryLock(long time, TimeUnit unit)方法，即在指定的时间内抢占锁资源，如果当前线程抢占锁资源成功返回true，失败或超出指定时间没有抢到锁资源会返回false，被中断会抛出InterruptedException异常而终止抢占锁。两个方法都是通过Thread类的interrupt()方法发出中断信号来处理中断的。

而不可中断锁是指线程在抢占锁的过程中不能被中断，如前面提到的synchronized锁就是不可中断锁。线程在抢占不可中断锁是，如果抢占成功则执行程序代码，如果抢占失败，则线程会阻塞挂起，并且线程在阻塞挂起的过程中不可被中断。

在这里插入图片描述

排他锁与共享锁

在加锁后，在多线程情况下，同一时刻资源能够被多个线程访问的就是共享锁，只能一个线程拿到锁访问资源的锁叫做排他锁。
排它锁只能在同一时刻被一个线程获取到，排它锁也被称为独占锁，互斥锁。如果一个线程获取到了排它锁，其他线程要想再获取到相同的锁资源，会获取不到，只能阻塞等待拿到排它锁的线程释放锁后才能获取到排它锁。前面介绍的synchronized锁，ReentranLock锁，ReadWriteLock的write锁都属于排它锁。
而共享锁是指在同一时刻能够被多个线程获取到锁，但是在多个线程获取到共享锁后，只能够读取临界区的资源和数据，不能修改临界区的资源和数据。共享锁只是在读操作上是共享的。
在这里插入图片描述

二叉树的最近公共祖先

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

示例 1：

输入： root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
输出：3 解释：节点 5 和节点1 的最近公共祖先是节点 3 。

示例 2：

输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 输出：5 解释：节点 5 和节点
4 的最近公共祖先是节点 5 。因为根据定义最近公共祖先节点可以为节点本身。

示例 3：

输入：root = [1,2], p = 1, q = 2
输出：1

思路：本题可以采用递归的形式，如果两节点位于左子树，右子树两边，则最近公共祖先一定是根结点，如果两节点都位于左边或右边，则先找到的那个节点肯定就是最近的公共祖先，如果都没有找到，那就返回空，因此找到左边的返回left，找到右边的返回right，进行判断即可。

代码+详解：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if (root == null || root == p || root == q) {
            //只要当前根节点是p和q中的任意一个，就返回（因为不能比这个更深了，再深p和q中的一个就没了）
            return root;
        }
        //根节点不是p和q中的任意一个，那么就继续分别往左子树和右子树找p和q
        TreeNode left = lowestCommonAncestor(root.left, p, q);
        TreeNode right = lowestCommonAncestor(root.right, p, q);
        //p和q都没找到，那就没有
        if(left == null && right == null) {
            return null;
        }
        //左子树没有p也没有q，就返回右子树的结果
        if (left == null) {
            return right;
        }
        //右子树没有p也没有q就返回左子树的结果
        if (right == null) {
            return left;
        }
        //左右子树都找到p和q了，那就说明p和q分别在左右两个子树上，所以此时的最近公共祖先就是root
        return root;
    }
}