面经笔记

怼烎@ 2022-12-05 13:48 234阅读 0赞

# 一、Java #

## 1，基础 ##

1，平时编程什么时候用int Integer  
int默认为0，Integer默认为null，用Integer可以判断出是没参加考试还是考了0分。

2，LIst中为什么不能用int  
集合中存放的都是对象的引用，实际内容都在堆上面或者方法区里面，但是基本数据类型是在栈上分配空间的。随时就被收回的。但是通过自动包装类就可以把基本类型转为对象类型，存放引用就解决了这个问题。

3，int i = 1；可能存在于JVM哪些区域  
作为方法中的局部变量时存放在虚拟机栈帧上的局部变量表中；  
如果时作为类的普通属性，会和所在实例对象一起分配在堆中；  
如果是静态成员变量放在方法区中。

4，BIO，NIO，AIO  
同步阻塞IO、同步非阻塞IO、异步非阻塞IO。

5，Java反射机制存在的意义，为什么C没有  
获取运行时类的信息，动态代理等，  
C可以直接访问内存地址，Java通过反射弥补。

6，函数式编程的好处  
函数式编程关系数据的映射，可以将函数当成变量一样使用，如当成参数；  
确定性，函数调用的结果不依赖调用的时间和位置，结果确定；  
并行，多线程不共享状态，没有资源竞争，不需要锁；代码简洁易读。  
懒加载（惰性求值）

7，尾递归  
尾递归是在方法的最后一步调用递归，如 ~f(n);\}, ~return f(n);\}  
这样可以重用栈帧，减少内存消耗，但Java的编译器不支持尾递归的优化，但可以使用lambda的懒加载(惰性求值)机制来延迟递归的调用，从而实现栈帧的复用。  
[https://www.jb51.net/article/126839.htm][https_www.jb51.net_article_126839.htm]  
8，Object的方法  
native：getClass(),hashcode(),clone(),notify(),notifyAll(),wait()  
java：equals(),toString(),finalize()

9，单例模式

public class Singleton{
        
    	private static volatile Singleton instance = null;
    	private Singleton(){
        }
    	public static Singleton getInstance(){
        
    		if(instance == null){
        
    			synchronized (Singleton.class){
        
    				if (instance == null){
        
    					instance = new Singleton();
    				}
    			}
    		}
    		return instance;
    	}

10，Java 启动一个main程序时，有多少个线程  
\[6\] Monitor Ctrl-Break  
\[5\] Attach Listener  
\[4\] Signal Dispatcher  
\[3\] Finalizer  
\[2\] Reference Handler  
\[1\] main  
[https://blog.csdn.net/chenxi004/article/details/104972979/][https_blog.csdn.net_chenxi004_article_details_104972979]

## 2，Java容器 ##

HashMap中entry对象里面的结构体里有几个参数

## 3，Java多线程 ##

1，TreadLocal  
threadlocal而是一个线程内部的存储类，可以在指定线程内存储数据，数据存储以后，只有指定线程可以得到存储数据。  
（1）每个Thread维护着一个ThreadLocalMap的引用  
（2）ThreadLocalMap是ThreadLocal的内部类，用Entry来进行存储  
（3）ThreadLocal创建的副本是存储在自己的threadLocals中的，也就是自己的ThreadLocalMap。  
（4）ThreadLocalMap的键值为ThreadLocal对象，而且可以有多个threadLocal变量，因此保存在map中  
（5）在进行get之前，必须先set，否则会报空指针异常，当然也可以初始化一个，但是必须重写initialValue()方法。  
（6）ThreadLocal本身并不存储值，它只是作为一个key来让线程从ThreadLocalMap获取value。  
[https://baijiahao.baidu.com/s?id=1653790035315010634&wfr=spider&for=pc][https_baijiahao.baidu.com_s_id_1653790035315010634_wfr_spider_for_pc]

2，四种预定义线程池的区别，各自workqueue size是多大  
说明：Executors 各个方法的弊端：  
1）newFixedThreadPool 和 newSingleThreadExecutor:  
主要问题是堆积的请求处理队列可能会耗费非常大的内存，甚至 OOM。  
2）newCachedThreadPool 和 newScheduledThreadPool:  
主要问题是线程数最大数是 Integer.MAX\_VALUE，可能会创建数量非常多的线程，甚至 OOM。  
**1)CacheThreadPool**：SynchronousQueue容量为0

/**无参构造方法*/
     public static ExecutorService newCachedThreadPool() {
        
            return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                          60L, TimeUnit.SECONDS,
                                          new SynchronousQueue<Runnable>());
        }
     /**有参的构造方法，可以传入threadFactory*/
     public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
        
            return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                          60L, TimeUnit.SECONDS,
                                          new SynchronousQueue<Runnable>(),
                                          threadFactory);
        }

**2）FixedThreadPool**：LinkedBlockingQueue默认大小为Integer.MAX\_VALUE ，为无界队列。

/**创建固定大小的线程数*/
    public static ExecutorService newFixedThreadPool(int nThreads) {
        
            return new ThreadPoolExecutor(nThreads, nThreads,
                                          0L, TimeUnit.MILLISECONDS,
                                          new LinkedBlockingQueue<Runnable>());
        }
     
    /**创建固定大小的线程数，并可以指定threadFactory*/
     public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
        
            return new ThreadPoolExecutor(nThreads, nThreads,
                                          0L, TimeUnit.MILLISECONDS,
                                          new LinkedBlockingQueue<Runnable>(),
                                          threadFactory);
        }

**3）ScheduledThreadPool：** DelayedWorkQueue是基于堆结构的等待队列。初始数组大小为16

/**创建固定大小的corePool*/
    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        
            return new ScheduledThreadPoolExecutor(corePoolSize);
        }
    /**查看ScheduledThreadPoolExecutor类，发现是集成的ThreadPoolExecutor*/
     public ScheduledThreadPoolExecutor(int corePoolSize) {
        
            super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
                  new DelayedWorkQueue());
        }
    /**创建固定大小的corePool,并指定threadFactory*/
     public static ScheduledExecutorService newScheduledThreadPool(
                int corePoolSize, ThreadFactory threadFactory) {
        
            return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
        }
    /**查看ScheduledThreadPoolExecutor类，发现是集成的ThreadPoolExecutor*/
     public ScheduledThreadPoolExecutor(int corePoolSize,
                                           ThreadFactory threadFactory) {
        
            super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
                  new DelayedWorkQueue(), threadFactory);
        }

**4）SingleThreadExecutor**：LinkedBlockingQueue默认大小为Integer.MAX\_VALUE ，为无界队列。

/**无参*/
    public static ExecutorService newSingleThreadExecutor() {
        
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }
    /**指定threadFactory*/
    public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory) {
        
            return new DelegatedScheduledExecutorService
                (new ScheduledThreadPoolExecutor(1, threadFactory));
        }

3，AQS  
[https://blog.csdn.net/mulinsen77/article/details/84583716][https_blog.csdn.net_mulinsen77_article_details_84583716]

4，异步并发类

5，callable机制，报错会拿到什么结果

package offer;
    
    import java.util.concurrent.*;
    
    public class CallableTest implements Callable<Integer> {
        
    
        @Override
        public Integer call() throws Exception {
        
            int a = 10 / 0;
            return a;
        }
    
        public static void main(String[] args) {
        
            CallableTest callableTest = new CallableTest();
            FutureTask<Integer> task = new FutureTask<>(callableTest);
            ExecutorService executorService = Executors.newFixedThreadPool(3);
            executorService.submit(task);
            try {
        
                Integer integer = task.get();
            } catch (Exception e) {
        
                System.out.println(1);
            }
        }
    }

6，Synchronized、ReentrantLock底层实现  
synchronized给出的答案是在软件层面依赖JVM，而j.u.c.Lock给出的答案是在硬件层面依赖特殊的CPU原子指令（CAS）。  
[深入分析Synchronized原理][Synchronized]  
[ReentrantLock][]

7，锁升级详细  
**偏向锁**：只有一个线程存在的情况下，对象会偏向该进程，偏向锁的标志位设为1，以后该线程无需系统调用、CAS等操作就能获取该锁，但一旦有线程竞争就会发生锁升级。由于偏向锁记录线程ID和哈希值使用的是同一位置，所以计算哈希值后的对象无法进入偏向锁状态。当偏向锁状态的对象要求计算哈希值时会膨胀为重量级锁。  
\*\*轻量级锁：\*\*轻量级锁的设计初衷是在没有锁竞争的情况下减少重量级锁使用操作系统互斥量产生的性能消耗。轻量级锁尝试获取锁的时候会使用CAS将对象的Mark word更新为指向Lock Record的指针，如果成功就获得锁。如果失败就检查Mark Word是否指向该线程的栈帧，如果是就继续执行。如果存在两条以上的线程竞争该锁，就会升级为重量级锁。  
\*\*重量级锁：\*\*使用操作系统互斥量实现，Mark Word中存放指向互斥量的的指针，获取锁和释放锁都会产生系统调用、用户态和内核态的切换，消耗大量性能消耗。  
[https://www.cnblogs.com/aspirant/p/11470858.html][Synchronized]

8，ReentrantLock怎么实现公平锁和非公平锁  
看两种锁lock方法

非公平锁

final void lock() {
        
    	if (compareAndSetState(0, 1))
        	setExclusiveOwnerThread(Thread.currentThread());
    	else
        	acquire(1);
    }

公平锁

final void lock() {
        
      acquire(1);
    }

所以非公平锁就是在用Lock方法获取锁的时候执行一次CAS操作，若失败一样得入队列老老实实等待，FIFO；而公平锁直接执行acquire(1)方法直接入队。

9，线程安全可见性和缓存一致性  
内存屏障

10，happen-before  
1）程序次序规则：一个线程内，按照代码执行，书写在前面的操作先行发生于书写在后面的操作。  
2）锁定规则：一个unLock操作先行发生于后面对同一个锁的lock操作  
3）olatile变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作  
4）传递规则：如果操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于操作C  
5）线程启动原则：Thread对象的start()方法先行发生于此线程的每一个动作  
线程中断规则:对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生  
6）线程终结规则：线程中所有的操作都先行发生于线程的终止检测，我们可以通过Thread.join()方法结束、Thread.isAlive()方法返回值手段检测到线程已经终止执行

11.线程池的execute和submit方法的区别  
1）execute提交的是Runnable类型的任务，而submit提交的是Callable或者Runnable类型的任务  
2）execute的提交没有返回值，而submit的提交会返回一个Future类型的对象  
3）execute提交的时候，如果有异常，就会直接抛出异常，而submit在遇到异常的时候，通常不会立马抛出异常，而是会将异常暂时存储起来，等待你调用Future.get()方法的时候，才会抛出异常

## 4，JVM ##

1，JVM怎么对泛型提供支持  
Java的泛型是伪泛型，在编译期间，所有的泛型信息都会被擦掉，生成的字节码中是不包含泛型中的类型信息的，叫作泛型擦除。  
[https://www.cnblogs.com/wuqinglong/p/9456193.html][https_www.cnblogs.com_wuqinglong_p_9456193.html]

2，GCRoots的对象有哪些  
a. java虚拟机栈中的引用的对象。  
b.方法区中的类静态属性引用的对象。 （一般指被static修饰的对象，加载类的时候就加载到内存中。）  
c.方法区中的常量引用的对象。  
d.本地方法栈中的JNI（native方法）引用的对象

3，类加载器  
**1)根类加载器（bootstrap class loader）**:它用来加载 Java 的核心类，是用原生代码来实现的，并不继承自 java.lang.ClassLoader（负责加载$JAVA\_HOME中jre/lib/rt.jar里所有的class，由C++实现，不是ClassLoader子类）。由于引导类加载器涉及到虚拟机本地实现细节，开发者无法直接获取到启动类加载器的引用，所以不允许直接通过引用进行操作。  
**2)扩展类加载器（extensions class loader）**：它负责加载JRE的扩展目录，lib/ext或者由java.ext.dirs系统属性指定的目录中的JAR包的类。由Java语言实现，父类加载器为null。  
**3)系统类加载器（system class loader）**：被称为系统（也称为应用）类加载器，它负责在JVM启动时加载来自Java命令的-classpath选项、java.class.path系统属性，或者CLASSPATH换将变量所指定的JAR包和类路径。程序可以通过ClassLoader的静态方法getSystemClassLoader()来获取系统类加载器。如果没有特别指定，则用户自定义的类加载器都以此类加载器作为父加载器。由Java语言实现，父类加载器为ExtClassLoader。  
[https://blog.csdn.net/m0\_38075425/article/details/81627349][https_blog.csdn.net_m0_38075425_article_details_81627349]  
4，符号引用和直接引用  
符号引用是符号，在解析阶段转换为直接引用，是内存地址  
[https://www.cnblogs.com/shinubi/articles/6116993.html][https_www.cnblogs.com_shinubi_articles_6116993.html]

5，类加载中的几种检验  
文件格式检验、元数据检验、字节码检验、符号引用检验

6，创建对象过程中发生并发问题的几种处理办法是什么  
1）CAS  
2）TLAB，Eden区中一块很小的线程安全的区域，大约占整个伊甸区的1%

7，ZGC

8，创建对象的步骤  
1）判断对象对应的类是否被加载、链接、初始化  
2）为对象分配内存（指针碰撞、空闲列表）  
3）处理并发安全问题（CAS、TLAB）  
4）初始化：为对象属性设默认值  
5）设置对象的对象头  
6）执行方法初始化

## 5，Spring ##

[spring笔记][spring]  
1，启动过程  
2，循环依赖  
3，spring有哪些容器  
**beanFactory:**  
（1）实现了org.springframework.beans.Factory.beanFactory接口，提供基本的DI支持。  
（2）beanFactory在创建Bean时，使用了延迟加载，在使用某个Bean时，才对bean进行实例化。  
**ApplicationContext:**  
（1）实现了org.springframework.context.ApplicationContext接口，对beanFactory的扩展，并提供应用级别的服务，例如从属性文件解析文本信息  
（2）在容器启动时，会一次性创建所有的bean，启动时间会比beanFactory时间长。  
ClassPathXmlApplicationContext主要用在在类路径加载xml文件的场景，FileSystemXmlApplicationContext主要用在在文件系统加载xml文件的场景，  
XMLWebApplicationContext主要用在在Web中加载xml文件的场景。

4，Spring 中用到了几种设计模式

5，Mybatis一级缓存和二级缓存  
一级缓存的作用域是SqlSession，二级缓存的作用域是mapper

6，spring中的后置处理器

7，spring bean的作用域  
单例、多例、request、session、application

# 二、MySQL #

1，主从复制  
1）主服务器上面的任何修改都会通过自己的 I/O tread(I/O 线程)保存在二进制日志 Binary log 里面。  
2）从服务器上面也启动一个 I/O thread，通过配置好的用户名和密码, 连接到主服务器上面请求读取二进制日志，然后把读取到的二进制日志写到本地的一个Realy log（中继日志）里面。  
3）从服务器上面同时开启一个 SQL thread 定时检查 Realy log(这个文件也是二进制的)，如果发现有更新立即把更新的内容在本机的数据库上面执行一遍

2，主键索引和非主键索引有什么区别  
主键索引也被称为聚簇索引，叶子节点存放的是整行数据;；而非主键索引被称为二级索引，叶子节点存放的是主键的值.

3，sql语句执行很慢，怎么优化  
4，为什么用b+树，为什么不用hash，二叉树，二叉平衡树、红黑树  
哈希不利于范围查找；  
二叉树高度过高，IO频繁  
B树非叶子节点也会存储数据，一次加载的节点少

5，索引匹配原则  
最左前缀匹配

6，jion的底层实现  
mysql只支持一种join算法：Nested-Loop Join（嵌套循环连接）  
1.Simple Nested-Loop Join：相当于两层for循环遍历  
2.Index Nested-Loop Join（索引嵌套）：非驱动表有索引时  
3.Block Nested-Loop Join：如果有索引，会选取第二种方式进行join，但如果join列没有索引，就会采用Block Nested-Loop Join。可以看到中间有个join buffer缓冲区，是将驱动表的所有join相关的列都先缓存到join buffer中，然后批量与匹配表进行匹配，将第一种多次比较合并为一次，降低了非驱动表（s）的访问频率。默认情况下join\_buffer\_size=256K，在查找的时候MySQL会将所有的需要的列缓存到join buffer当中，包括select的列，而不是仅仅只缓存关联列。在一个有N个JOIN关联的SQL当中会在执行时候分配N-1个join buffer。  
[MySQL Join的底层实现原理][MySQL Join]

7，排除数据库查询性能慢的问题  
explain

8，聚簇索引、非聚簇索引  
聚簇索引将数据和索引放在一块，

9，索引覆盖  
如果索引包含所有要查询的列就叫覆盖索引，无需回表操作。

11，update操作不会判断事务指针吗  
12，undo log是用来做什么的，事务提交的时候会提交什么日志  
13，redo 和bin 的提交顺序  
14，rndo log 和redo log的区别，分别记录了什么 binlog呢？

15，索引失效  
1）模糊查询like以 % 开头  
2）复合索引不使用最左列  
3）包含or的语句没有同时使用索引  
4）数据类型出现隐式转化。如varchar不加单引号的话可能会自动转换为int型，使索引无效，产生全表扫描。  
5）索引列使用函数  
6）索引列使用运算（+、-、\*、/、！、<>、in、exist）  
7）全局扫描效果比用索引好

16，事务怎么实现的  
17，多个线程同时向数据库中进行写入操作  
18，explain  
id:选择标识符  
select\_type:表示查询的类型。  
table:输出结果集的表  
partitions:匹配的分区  
type:表示表的连接类型  
possible\_keys:表示查询时，可能使用的索引  
key:表示实际使用的索引  
key\_len:索引字段的长度  
ref:列与索引的比较  
rows:扫描出的行数(估算的行数)  
filtered:按表条件过滤的行百分比  
Extra:执行情况的描述和说明  
[MySQL Explain详解][MySQL Explain]

19，MyISAM 和 InnoDB的区别  
1）InnoDB支持外键，MyISAM 不支持  
2）InnoDB支持行锁，MyISAM 不支持  
3）MyISAM 只缓存索引，InnoDB即缓存索引页缓存真实数据  
4）InnoDB支持事物，MyISAM 不支持  
5）InnoDB的B+树主键索引的叶子节点就是数据文件，是聚簇索引，辅助索引的叶子节点是主键的值；而MyISAM的B+树主键索引和辅助索引的叶子节点都是数据文件的地址指针。

20，主键索引和唯一索引的区别  
1）主键索引是聚簇索引，唯一索引不是  
2）主键索引不可以为空，唯一索引可以  
3）主键索引只能有一个，唯一索引可以有多个  
4）主键索引可以作为别的表的外键，唯一索引不能

21，update语句执行流程  
读入内存页、执行修改、写入redo日志、写入bin日志

## SQL ##

1，字段：name,course,socre，求每人考的最好的一门

select name,course,max(score) from student
    group by name

2，查询两个表，多表查询的题 一个表有id ， name , age, area,一个表有 consumerid , mount,month。 结果就是将另一个表的mount金额把对应的人的每个月的全部加起来，假如大于100W我们就统计第一个表中他的area实在哪里。联合查询把（我没做出来，尬了挺久，太久没做过sql语句了）  
3，将一个表中某个字段数值第二大的拿出来，假如没有就为NULL

# 三、计算机网络 #

1，TCP UDP区别  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDk2Mzc0MQ_size_16_color_FFFFFF_t_70_pic_center]  
[https://www.cnblogs.com/fundebug/p/differences-of-tcp-and-udp.html][https_www.cnblogs.com_fundebug_p_differences-of-tcp-and-udp.html]

2，基于流和报文的区别，会引发什么问题  
**UDP**：发送方的UDP对应用程序交下来的报文，在添加首部后就交付给IP层，既不合并也不拆分，而是保留这些报文的边界，一次交付一个完整的报文。因此若报文太长，IP层在传送时可能分片，报文太短会让IP数据报首都相对较大，都会降低IP层的效率。  
**TCP**TCP通过字节流传输，即TCP将应用程序看成是一连串的无结构的字节流。每个TCP套接口有一个发送缓冲区，如果字节流太长时，TCP会将其拆分进行发送。当字节流太短时，TCP会等待缓冲区中的字节流达到一定程度时再构成报文发送出去，TCP发给对方的数据，对方在收到数据时必须给矛确认，只有在收到对方的确认时，本方TCP才会把TCP发送缓冲区中的数据删除。

3，TCP拥塞控制，为什么会有快重传和慢恢复  
可能只是丢失了个别报文段而不是发生了网络拥塞  
[https://blog.csdn.net/qq\_43313035/article/details/89069962][https_blog.csdn.net_qq_43313035_article_details_89069962]

4，基于TCP、UDP的协议有什么，OICQ协议  
**TCP**：FTP（21）、SSH（22）、Telent（23）、SMTP（邮件）（25）、DNS（53）、http（80）、https（443）  
**UDP** DNS（53）、DHCP（67/68）、SNMP（161/162）、TFTP（69）（简单文本传输协议）  
SNMP(Simple Network Management Protocol, 简单网络管理协议) ，用于网络信息的收集和网络管理

5，UDP怎么保证数据安全按顺序到达  
6，http请求头、不同版本间的区别  
7，http报文结构  
8，http状态码  
9，cookie、session、分布式session  
10，url请求过程  
1）DNS解析  
2）TCP三次握手  
3）发送请求  
4）接受相应  
5）渲染页面  
6）四次挥手

11，tcp报文结构  
12，请求如何在ip层之间寻址  
13，缓存，强缓存，协商缓存  
14，流量控制和拥塞控制  
流量控制是一对一，防止发送方发的太快接收方来不及接受；拥塞控制是全局，防止过度数据注入网络导致网络拥塞。

15，滑动窗口，拥塞控制的四个算法  
**慢开始**：从一开始窗口翻倍增加，直到慢开始门限  
**拥塞避免**：到达慢开始门限后窗口每次加一  
**快恢复**：一旦出现超时重传，或者收到第三个重复的 ack 时（快重传），TCP 会把慢启动门限 ssthresh 的值设置为 cwnd 值的一半，同时 cwnd = ssthresh  
**快重传**：发送方收到三个重复确认后就重新发送该数据包，并不等待超时重传。

16，DNS请求过程  
1）检查浏览器缓存  
2）检查系统缓存  
3）请求本地域名服务器（LDNS）  
4）如果LDNS仍然没有命中，就直接跳到Root Server 域名服务器请求解析  
5）根域名服务器返回给LDNS一个所查询域的主域名服务器（gTLD Server，国际顶尖域名服务器，如.com .cn .org等）地址  
6） 此时LDNS再发送请求给上一步返回的gTLD  
7）接受请求的gTLD查找并返回这个域名对应的Name Server的地址，这个Name Server就是网站注册的域名服务器  
8.）Name Server根据映射关系表找到目标ip，返回给LDNS  
9）LDNS缓存这个域名和对应的ip  
10）LDNS把解析的结果返回给用户，用户根据TTL值缓存到本地系统缓存中，域名解析过程至此结束

17，DNS请求发出的是什么，接收到的是什么  
发出域名得到IP

18，NAT  
网络地址转换协议

19， TCP SYN攻击  
TCP协议要经过三次握手才能建立连接：于是出现了对于握手过程进行的攻击。攻击者发送大量的SYN包，服务器回应(SYN+ACK)包，但是攻击者不回应ACK包，这样的话，服务器不知道(SYN+ACK)是否发送成功，默认情况下会重试5次（tcp\_syn\_retries）。这样的话，对于服务器的内存，带宽都有很大的消耗。  
**防御方法**：减少超时重传次数，使用SYN　cookie，增加backlog队列（默认是1024），限制SYN并发数。

20，TIME\_WAIT  
主动关闭方在接收到另一端发来的第三次挥手请求后会进入2MSL（数据包在网络中的最大生存时间）时间的TIME＿WAIT状态。这是因为如果第四次回收如果丢失，被动关闭方由于超时重传机制会重新发送FIN包。

21，HTTPS流程  
1）客户端向服务器发起HTTPS请求，连接到服务器的443端口  
2）服务端向证书机构申请数字证书，获得非对称密钥对。然后将自己的公钥和数字证书发给客户端。  
3）客户端验证证书的合法性。如果有效，客户端会随机产生一个对称加密的客户端密钥，然后用服务端的公钥对客户端密钥进行非对称加密，发起HTTPS中的第二个HTTP请求发送给服务端。  
４）服务端用自己的私钥解密得到客户端密钥，然后用客户端密钥对数据进行对称加密，发给客户端。。  
５）客户端用客户端密钥对其进行对称解密，得到服务器发送的数据。

22，路由算法  
1）静态路由，网络管理员手动管理  
2）RIP协议，适用于自治系统内，小规模，最大16跳，每30秒将自己的路由表发送给相邻路由器。路由器收到相邻路由器的路由表后，发现自己没有的net就更新，若已经存在，就比较距离，把较短的更新到自己的路由表。  
3）OSPF协议，适用于自治系统内，用Dijstra算法计算最短路径，判断距离远近的因素包括带宽等。  
4）BGP协议，自治系统之间的协议，力求寻找网络较好的路径，而不是最好。

23，TCP流量控制  
接收方在返回确认报文的时候会告诉发送方自己空闲缓冲区大小，即接收窗口的大小，用win来表示。在接收方缓冲区满之后，发送方停止发送数据，但每隔一段时间都会发送试探报文，询问接收方是否可以接收数据。  
[https://www.cnblogs.com/kubidemanong/p/9987810.html][https_www.cnblogs.com_kubidemanong_p_9987810.html]

# 四、操作系统 #

1，LRU，不适合的场景  
2，僵尸进程  
一个进程在调用exit命令结束自己的生命的时候，其实它并没有真正的被销毁，而是留下一个称为僵尸进程（Zombie）的数据结构（系统调用exit， 它的作用是使进程退出，但也仅仅限于将一个正常的进程变成一个僵尸进程，并不能将其完全销毁）。

在Linux进程的状态中，僵尸进程是非常特殊的一种，它已经放弃了几乎所有内存空间，没有任何可执行代码，也不能被调度，仅仅在进程列表中保留一个位 置，记载该进程的退出状态等信息供其他进程收集。除此之外，僵尸进程不再占有任何内存空间。它需要它的父进程来为它收尸，如果他的父进程没安装 SIGCHLD 信号处理函数调用wait或waitpid()等待子进程结束，又没有显式忽略该信号，那么它就一直保持僵尸状态，如果这时父进程结束了， 那么init进程自动会接手这个子进程，为它收尸，它还是能被清除的。但是如果如果父进程是一个循环，不会结束，那么子进程就会一直保持僵尸状态，这就是 为什么系统中有时会有很多的僵尸进程。

3，父子进程  
4，进程通信的方式  
信号、管道、消息队列、共享内存、socket、文件

5，逻辑页面到真实页面  
多级页表、偏移量

6，进程/线程上下文切换保存了什么信息  
程序计数器，程序运行的位置，进程切换还可能造成页面置换，修改页表。

7，进程切换的时机  
1）需要进行进程调度与切换的情况  
当前进程主动放弃处理机  
（1）进程正常终止  
（2）发生异常终止  
（3）进程主动请求阻塞(如等待I/O)  
当前运行的进程被动放弃处理机  
（1）分给进程的时间片用完  
（2）有更紧急的事需要处理( 如I/O中断)  
（3）有更高优先级的进程进入就绪队列  
2）不能进行进程调度与切换的情况  
（1）在处理中断的过程中。中断处理过程复杂，与硬件密切相关，很难做到在中断处理过程中进行进程切换。  
（2）进程在操作系统内核程序临界区中。  
（3）在原子操作过程中(原语)。原子操作不可中断，要一气呵成(如之前讲过的修改PCB中进程状态标志，并把PCB放到相应队列)  
[https://blog.csdn.net/yrx420909/article/details/104260456][https_blog.csdn.net_yrx420909_article_details_104260456]

8，BIO、NIO、IO多路复用（select、poll、epoll）  
**BIO**：阻塞IO，每一个客户端连接时都需要新建一个线程监听，所有线程都会阻塞。  
**NIO**：非阻塞IO，监听不会阻塞，没有数据返回空。用一个线程监听多个客户端，需要用循环遍历每个客户端是否有数据传输，每次都会产生系统调用，进行内核态和用户态的切换，浪费资源。  
**IO多路复用**：针对NIO问题，Liunx有三种方式：select、poll、epoll。只需要一次系统调用就可以筛选出有数据的文件描述符。首先都会对一组文件描述符（socket）进行相关事件的注册，然后阻塞等待某些事件的发生或等待超时。  
epoll：epoll\_create（创建）、epoll\_ctl（注册）、epoll\_wait（获取）

select用数组实现，有大小限制（1024），poll用链表实现，理论上没有大小限制；两者都是需要在系统调用时把文件描述符作为参数传递。epoll在内存中单独划分了一块区域用于存放socket，在系统调用时不用传递这些参数。

9，操作系统层面线程的具体实现方式是什么  
内核级线程

10，user态到kernel态有哪几种切换方式  
系统调用、异常、设备中断

11，缓存替换算法  
1）FIFO先入先出算法  
2）LRU最近最少使用  
3）LFU最不常用  
4）ARC自适应缓存替换算法

11，详细说一下寄存器在操作系统中的角色  
CPU包含控制器、运算器和寄存器。寄存器是有限存贮容量的高速存贮设备，可以用来暂存指令、数据和内存地址。在中央处理器的控制部件中，包含的寄存器有指令寄存器（IR）和程序计数器（PC）。它可以将控制器的指令交给运算器，也可以暂存溢出的指令。

12.操作系统怎么实现进程独享内存空间  
内存分页。进程只知道逻辑地址，从逻辑地址到物理内存地址转换的时候，页表中的权限位会判断有没有访问权限。

13，CPU调度机制  
先来先服务、短进程优先、高相应比优先、时间片轮循、多级反馈队列。

14，页面置换算法  
最优页面置换算法、先入先出、最近最久未使用、时钟、二次机会法、最不常用法

15，GPU和CPU的架构区别 为什么GPU能加速运算  
[https://www.zhihu.com/question/19903344][https_www.zhihu.com_question_19903344]

16，最高相应比优先调度算法

17，设计LRU

18，成熟的内存分配算法

19，

## 分布式 ##

1，CAP  
2，脑裂问题

# 五、redis #

1，如何保证线程安全的  
单线程机制  
2，多个线程同时读到库存数据怎么解决  
3，为什么线程多的时候要使用锁而不是CAS  
4，网络模型  
默认bridge  
5，数据结构及实现  
string  
list  
hash  
set  
zset　跳跃表

6，高可用和一致性

6，问什么这么快  
内存、单线程、数据结构简单

7，保证缓存一致性  
更新时先加分布式锁，删除redis缓存，保证只有一个线程访问数据库

8，集群同步  
9，主从选举  
10，过期时间，惰性删除和定期删除  
11，过期淘汰机制  
12，持久化  
RDB快照、AOF，使用一个进程单独进行持久化操作

13，Redis为什么用跳表而不用平衡树？  
[https://mp.weixin.qq.com/s?\_\_biz=MzA4NTg1MjM0Mg==&mid=2657261425&idx=1&sn=d840079ea35875a8c8e02d9b3e44cf95&scene=21\#wechat\_redirect][https_mp.weixin.qq.com_s_biz_MzA4NTg1MjM0Mg_mid_2657261425_idx_1_sn_d840079ea35875a8c8e02d9b3e44cf95_scene_21_wechat_redirect]

14，Redis的过期时间怎么实现的

# 六、Linux #

1，常用指令

2，Linux服务器卡顿怎么排查？

# 七、智力题 #

1，甲乙最后三次抛硬币，正反反甲赢，反反正乙赢，谁赢的概率大  
2，一个圆内随机三个点刚好在一个半圆内的概率  
3，一个岛上居民只带红帽子和白帽子，他们不能交流，红帽子数大于等于1，如果他们能知道自己的帽子什么颜色则可以离岛，问最后是什么情况，如果能全部离岛问需要几天。  
4，6个数字的显示屏，倒过来不变的概率，倒过来还是数字的概率  
5，大数据文件，找并集

# 八、其他 #

1，欧拉图  
2，设计10万用户的在线聊天室功能

3，访问慢问题  
1）网络问题  
2）服务器内存、CPU资源问题  
3）数据库问题  
4）图片太大

# 九、算法 #

[https://blog.csdn.net/weixin\_44963741/article/details/108632303][https_blog.csdn.net_weixin_44963741_article_details_108632303]

[https_www.jb51.net_article_126839.htm]: https://www.jb51.net/article/126839.htm
[https_blog.csdn.net_chenxi004_article_details_104972979]: https://blog.csdn.net/chenxi004/article/details/104972979/
[https_baijiahao.baidu.com_s_id_1653790035315010634_wfr_spider_for_pc]: https://baijiahao.baidu.com/s?id=1653790035315010634&wfr=spider&for=pc
[https_blog.csdn.net_mulinsen77_article_details_84583716]: https://blog.csdn.net/mulinsen77/article/details/84583716
[Synchronized]: https://www.cnblogs.com/aspirant/p/11470858.html
[ReentrantLock]: https://www.cnblogs.com/aspirant/p/8657681.html
[https_www.cnblogs.com_wuqinglong_p_9456193.html]: https://www.cnblogs.com/wuqinglong/p/9456193.html
[https_blog.csdn.net_m0_38075425_article_details_81627349]: https://blog.csdn.net/m0_38075425/article/details/81627349
[https_www.cnblogs.com_shinubi_articles_6116993.html]: https://www.cnblogs.com/shinubi/articles/6116993.html
[spring]: https://blog.csdn.net/weixin_44963741/article/details/108307465
[MySQL Join]: https://www.jianshu.com/p/16ad9669d8a9
[MySQL Explain]: https://www.cnblogs.com/tufujie/p/9413852.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDk2Mzc0MQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/5ed54447fc574408aa181ddbc1f7deba.png
[https_www.cnblogs.com_fundebug_p_differences-of-tcp-and-udp.html]: https://www.cnblogs.com/fundebug/p/differences-of-tcp-and-udp.html
[https_blog.csdn.net_qq_43313035_article_details_89069962]: https://blog.csdn.net/qq_43313035/article/details/89069962
[https_www.cnblogs.com_kubidemanong_p_9987810.html]: https://www.cnblogs.com/kubidemanong/p/9987810.html
[https_blog.csdn.net_yrx420909_article_details_104260456]: https://blog.csdn.net/yrx420909/article/details/104260456
[https_www.zhihu.com_question_19903344]: https://www.zhihu.com/question/19903344
[https_mp.weixin.qq.com_s_biz_MzA4NTg1MjM0Mg_mid_2657261425_idx_1_sn_d840079ea35875a8c8e02d9b3e44cf95_scene_21_wechat_redirect]: https://mp.weixin.qq.com/s?__biz=MzA4NTg1MjM0Mg==&mid=2657261425&idx=1&sn=d840079ea35875a8c8e02d9b3e44cf95&scene=21#wechat_redirect
[https_blog.csdn.net_weixin_44963741_article_details_108632303]: https://blog.csdn.net/weixin_44963741/article/details/108632303