高频面试题突击

一、线程

1.1 线程

重中之重

1.线程的创建方式：

1.继承Thread
2.实现Runnable
3.实现Callable
    带有返回值的子线程

代码演示：

public class TicketCall implements Callable<Integer> {
    private TicketRep rep;
    private int num=0;//计数
    public TicketCall(TicketRep rep){
        this.rep=rep;
    }
    //类似 之前的 run
    @Override
    public Integer call() throws Exception {
        while (true){
            synchronized (rep) {
                if (rep.getCurr() < rep.getMaxval()) {
                    rep.setCurr(rep.getCurr() + 1);
                    //卖票
                    System.out.println(new Ticket(rep.getCurr(), Thread.currentThread().getName()));
                    num++;
                    Thread.yield();
                } else {
                    break;
                }
            }
        }
        return num;
    }
}

public class ThreadCreate_Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //多线程 -卖票 --共享
        TicketRep rep=new TicketRep(1000,0,"奥斯卡");
        //创建线程要做的对象
        TicketCall call1=new TicketCall(rep);
        TicketCall call2=new TicketCall(rep);
        //创建回调的对象
        FutureTask<Integer> future=new FutureTask<>(call1);
        //创建线程
        Thread thread1=new Thread(future,"窗口1");
        //创建回调的对象
        FutureTask<Integer> future2=new FutureTask<>(call2);
        //创建线程
        Thread thread2=new Thread(future2,"窗口2");
        thread2.setPriority(9);
        //开启
        thread2.start();
        //开启
        thread1.start();
        System.err.println(thread1.getName()+"---->"+future.get());
        System.err.println(thread2.getName()+"---->"+future2.get());
    }
}

@Data
@AllArgsConstructor
@NoArgsConstructor
public class TicketRep {
    private int maxval;//最大票数
    private int curr;//当前的票数
    private String cinema;//电影院
}

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Ticket {
    private int id;
    private String name;
}

4.线程池

目前5种线程池

sun推荐：Executors 线程池工具类

阿里巴巴推荐：ThreadPoolExecutor 原生创建

public class ThreadPool_Main {
    public static void main(String[] args) {
        // 线程池  有效控制线程的数量，提高线程的复用率
        /**
         * 参数说明：
         * 1.核心线程数量 最小线程数量
         * 2.最大线程数量
         * 3.线程的空闲时间
         * 4.空闲时间的单位
         * 5.阻塞队列 存储在当前线程池上等待任务对象 特点：：先进先出
         *  常用的阻塞队列：7个
         *     1.LinkedBlockingQueue 链表存储
         *     2.ArrayBlockingQueue 数组
         *     3.LinkedTransferQueue 无界阻塞
         *     4.PriorityBlockingQueue 优先级
         * 6.线程创建工厂
         * 7.拒绝策略 就是如果阻塞队列存储已经满了，那么就需要实现拒绝策略实现遗弃
         *         ThreadPoolExecutor.AbortPolicy;//丢弃任务并且抛出异常
         *         ThreadPoolExecutor.DiscardPolicy;//丢弃任务
         *         ThreadPoolExecutor.DiscardOldestPolicy;//丢弃前面的任务，然后提交新任务
         *         ThreadPoolExecutor.CallerRunsPolicy;//调用线程来处理
         * */
        LinkedBlockingQueue q1;
        ArrayBlockingQueue q2;
        LinkedTransferQueue q3;
        PriorityBlockingQueue q4;
        //拒绝策略 设定遗弃方案
//        ThreadPoolExecutor.AbortPolicy;//丢弃任务并且抛出异常
//        ThreadPoolExecutor.DiscardPolicy;//丢弃任务
//        ThreadPoolExecutor.DiscardOldestPolicy;//丢弃前面的任务，然后提交新任务
//        ThreadPoolExecutor.CallerRunsPolicy;//调用线程来处理
        ThreadPoolExecutor executor=new ThreadPoolExecutor(10,100,20,TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(100),new DefaultManagedAwareThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
        //添加线程任务
        executor.execute(()->{
            System.err.println("记住，这是重点！");
        });
        //sun 定义线程池工具类 ，但是阿里巴巴 规范 不允许使用工具类
        //线程池工具类：
        //1.固定线程数量的线程池
        Executors.newFixedThreadPool(10);
        //2.1.8 新增的 抢占式线程池 join  ForkJoinPool
        Executors.newWorkStealingPool();
        //3.创建一个单独线程的线程池 ，可以进行计划执行
        ScheduledExecutorService service=Executors.newSingleThreadScheduledExecutor();
        System.out.println(System.currentTimeMillis()/1000);
        service.schedule(()->{
            System.out.println("3秒后爆炸");
        },3, TimeUnit.SECONDS);
        //4.创建具有计划、定时执行的线程池
        Executors.newScheduledThreadPool(10);
        //5.创建具有缓存的线程池，无限个线程，也没有核心线程数量
        ExecutorService executorService=Executors.newCachedThreadPool();
        //executorService.execute();
    }
}

1.2 线程的锁

1.synchronized

互斥锁、同步锁 保证线程安全，同一时间，只能有1个线程调用
用法：
1.同步代码块  锁的粒度 可以更小
    修饰代码块：
    synchronized(对象){
    }
2.同步方法  锁的对象-当前类的实例
    修饰实例方法
3.同步静态方法 锁的对象-当前类的Class  粒度 大
    修饰静态方法

2.lock

jdk1.5新增的juc（java.util.concurrent）核心，

常用的实现类：ReentrantLock

必须主动释放，使用的时候在try{ 加锁}finally{ 释放}

JUC:java.util.concurrent包下的各种类：

ThreadPoolExecutor、Lock、ConcurrentHashMap等

1.3 锁的概念

1.乐观锁 和悲观锁

对应线程安全，乐观锁一致认为不会发生线程安全，悲观锁相反

乐观锁的实现采用的是无锁编程实现的。最常用：CAS算法

悲观锁实现锁（synchronized、lock）

乐观锁：适用的场景：读多写少

悲观锁：适用的场景：写多读少

CAS:Compare And Swap 比较并交换，是无锁算法的一种。

在不用锁的前提实现线程安全。

1.获取需要读写的内存的值：V

2.要进行比较的值：A

3.要进行替换的值：B

先获取V和A，进行比较，如果一致，就替换原来的值。需要借助原子类，保证比较和替换是原子性。

volatile和AtomicInteger（AtomicLong）

2.公平锁和非公平锁

公平锁：多线程按照顺序执行获取对应的锁。

非公平锁：多个线程抢占的时候，直接尝试加锁，谁抢到算谁的。

优缺点：

公平锁：平等、每个线程都有机会 先来后到

非公平锁：能者多劳

ReentrantLock内部的类： 默认非公平锁。可以通过构造函数选择公平锁

NonfairSync 非公平

FairSync 公平

AQS：AbstractQueuedSynchronizer

公平锁的加锁原理：

非公平锁的实现原理：

protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

 final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

volatile：原子可见性

ThreadLocal：线程变量 安全 Map

3.可重入锁和非可重入锁

可重入锁：递归锁 ，ReentrantLock和synchronized 都是可重入锁

线程的方法获取锁的时候，内部方法重新在获取一次锁（不会因为锁被外部获取而进入阻塞）。

优点：在一定程度上可避免死锁。

可重入锁都是实现了AQS：AbstractQueuedSynchronizer（private volatile int state; 记录重入次数）

非可重入锁：不允许一个锁被获取多次。NonReentrantLock（非源生 Netty实现）

4.共享锁和独占锁

共享锁：锁可以被多个线程共享。ReentrantReadWriteLock有个ReadLock ,是只读

独占锁：独享锁、排它锁 、同步锁、互斥锁等 同一时间，只能有一个线程拥有锁。 ReentrantLock和synchronized

实现原理：AQS：AbstractQueuedSynchronizer

ReentrantReadWriteLock.ReadLock;
ReentrantReadWriteLock.WriteLock;

5.自旋锁和适应性自旋锁

降低线程切换的损耗

自旋锁：先让当前的线程等一会，自旋不是阻塞，只是为了减少线程切换

适应性自旋锁：jdk1.6 新增的，默认开启自旋锁，自旋锁的时间不再固定，根据实际情况，自由选择

TicketLock、CLHlock和MCSlock

6.无锁\偏向锁\轻量级锁\重量级锁

synchronized 实现原理：Java对象头和Montior(数据结构 存储线程)

无锁：不使用锁，从而实现线程安全 ：CAS算法

偏向锁：如果一个线程多次获取锁，就会引起偏向锁，就不在参与竞争，而是直接获取锁，从而降低锁的竞争。

轻量级锁：锁是偏向锁，这个被另外线程访问，升级为轻量级锁

重量级锁：会让访问这个锁的其他线程进行阻塞，等待锁的线程都进入了阻塞状态。

1.4 线程的锁的其他问题

1.锁粗化

锁粗化：锁粗化就是告诉我们任何事情都有个度，有些情况下我们反而希望把很多次锁的请求合并成一个请求，以降低短时间内大量锁请求、同步、释放带来的性能损耗

通常情况下，为了保证多线程间的有效并发，会要求每个线程持有锁的时间尽可能短，但是大某些情况下，一个程序对同一个锁不间断、高频地请求、同步与释放，会消耗掉一定的系统资源，因为锁的讲求、同步与释放本身会带来性能损耗，这样高频的锁请求就反而不利于系统性能的优化了，虽然单次同步操作的时间可能很短。

2.锁消除

锁消除是Java虚拟机在JIT编译时，通过对运行上下文的扫描，去除不可能存在共享资源竞争的锁，通过锁消除，可以节省毫无意义的请求锁时间。

锁削除是指虚拟机即时编译器在运行时，对一些代码上要求同步，但是被检测到不可能存在共享数据竞争的锁进行削除。锁削除的主要判定依据来源于逃逸分析的数据支持，如果判断到一段代码中，在堆上的所有数据都不会逃逸出去被其他线程访问到，那就可以把它们当作栈上数据对待，认为它们是线程私有的，同步加锁自然就无须进行。

二、网络

TCP和UDP

NIO

Netty

2.1 网络模型

TCP/IP五层模型

OSI的七层协议

2.2 TCP和UDP

TCP:面向连接

ServerSocket 服务端

Socket 客户端 套接字对象

UDP:面向无连接

DatagramPacket ：数据报包 1.接收 2.发送

DatagramSocket：数据报套接字

相关面试题：

1.TCP和UDP区别

2.TCP三次握手和四次挥手

示例代码：

2.3 NIO

BIO、AIO、NIO?

BIO：同步阻塞 TCP UDP

NIO：同步非阻塞 New IO

AIO：异步非阻塞 NIO2.0

NIO:New IO

核心：

1.Buffer: 存储数据

2.Channel：通道 数据交换

3.Selector：事件监听

基于NIO实现通信：

ServerSocketChannel <——-> ServerSocket

SocketChannel <————->Socket

ByteBuffer : 存储信息

Selector: 监听器，事件：四大事件

服务端：

public static void main(String[] args) throws IOException {
        //创建服务端对象
        ServerSocketChannel serverChannel=ServerSocketChannel.open();//
        //绑定服务端的端口号
        serverChannel.socket().bind(new InetSocketAddress(8888));
        //设置非阻塞
        serverChannel.configureBlocking(false);
        //创建缓存对象  接收和发送
        ByteBuffer readBuffer=ByteBuffer.allocate(1024);
        ByteBuffer writeBuffer=ByteBuffer.allocate(1024);
        //监听器 监听事件
        Selector selector=Selector.open();
        //注册事件
        serverChannel.register(selector,SelectionKey.OP_ACCEPT);
        while (true){
            System.out.println("服务端已经启动……");
            //循环 监听连接
            selector.select();//开启事件轮训 没有事件，就会阻塞
            //获取所有的事件
            Iterator<SelectionKey> keys=selector.selectedKeys().iterator();
            while (keys.hasNext()){
                SelectionKey key=keys.next();
                System.err.println(key);
                if(key.isAcceptable()){
                    System.out.println("有人连接");
                    //是否有客户端连接
                    //同时更改事件监听
                    SocketChannel client = serverChannel.accept();
                    client.configureBlocking(false);
                    client.register(selector, SelectionKey.OP_READ);
                }else if(key.isReadable()){
                    System.out.println("Read");
                    //处理读取事件
                    SocketChannel client= (SocketChannel) key.channel();
                    readBuffer.clear();
                    int num=client.read(readBuffer);
                    if(num>0){
                        //切换指针
                        readBuffer.flip();
                        System.out.println("服务端-接收："+new String(readBuffer.array(),0,num));
                    }
                    client.register(selector,SelectionKey.OP_WRITE);
                }else if(key.isWritable()){
                    //写出事件
                    Scanner scanner =new Scanner(System.in);
                    System.out.println("请输入你要发送的内容：");
                    writeBuffer.clear();
                    writeBuffer.put(scanner.nextLine().getBytes());
                    writeBuffer.flip();
                    SocketChannel client=(SocketChannel)key.channel();
                    client.write(writeBuffer);
                    client.register(selector,SelectionKey.OP_READ);
                }
                keys.remove();
            }
        }
    }

客户端：

 public static void main(String[] args) throws IOException {
        //1.实例化 通道对象 套接字通道
        SocketChannel channel = SocketChannel.open();
        //2.设置非阻塞
        channel.configureBlocking(false);
        //3.设置缓存对象 接收和写出数据
        ByteBuffer readBuffer = ByteBuffer.allocate(1024);
        ByteBuffer writeBuffer = ByteBuffer.allocate(1024);
        //4.发起连接
        channel.connect(new InetSocketAddress(8888));
        Selector selector=Selector.open();
        //注册事件 连接
        channel.register(selector,SelectionKey.OP_CONNECT);
        while (true){
            selector.select();
            Iterator<SelectionKey> keys=selector.selectedKeys().iterator();
            while (keys.hasNext()){
                //获取当前的事件对象
                SelectionKey key=keys.next();
                //校验事件的类型
                if(key.isConnectable()){
                    System.out.println("连接成功");
                    channel.finishConnect();//完成连接
                    SocketChannel client=(SocketChannel)key.channel();
                    System.out.println(client);
                    client.register(selector,SelectionKey.OP_READ|SelectionKey.OP_WRITE);
                    //注册事件
                    //key.interestOps(SelectionKey.OP_READ |SelectionKey.OP_WRITE);
                }else if(key.isReadable()){
                    SocketChannel client= (SocketChannel) key.channel();
                    readBuffer.clear();
                    int num=client.read(readBuffer);
                    if(num>0){
                        readBuffer.flip();
                        System.out.println("客户端：-接收："+new String(readBuffer.array(),0,num));
                    }
                }else if(key.isWritable()){
                    Scanner scanner = new Scanner(System.in);
                    System.out.println("客户端：请输入你要发送的内容：");
                    writeBuffer.clear();
                    writeBuffer.put(scanner.nextLine().getBytes());
                    writeBuffer.flip();
                    SocketChannel client=(SocketChannel) key.channel();
                    client.write(writeBuffer);
                }
               // keys.remove();
            }
        }

2.4 Netty

目前市场最火的NIO框架。

Netty 是一个基于NIO的客户、服务器端的编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，例如实现了某种协议的客户、服务端应用。Netty相当于简化和流线化了网络应用的编程开发过程，例如：基于TCP和UDP的socket服务开发。

基于Netty实现网络通信：

1.依赖jar

<dependency>
   <groupId>io.netty</groupId>
   <artifactId>netty-all</artifactId>
   <version>4.1.51.Final</version>
</dependency>

2.创建服务端

public static void main(String[] args) throws InterruptedException {
        //1.创建各种组
        EventLoopGroup accepts=new NioEventLoopGroup(10);
        EventLoopGroup works=new NioEventLoopGroup(10);
        //2.创建服务端对象
        ServerBootstrap serverBootStrap=new ServerBootstrap();
        //3.链式编程  设置各种
        serverBootStrap.group(accepts,works).channel(NioServerSocketChannel.class)
        .option(ChannelOption.SO_BACKLOG,1024).childHandler(
                new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
                        ChannelPipeline pipeline=socketChannel.pipeline();
                        //设置消息处理器
                        pipeline.addLast(new MyHandler());
                    }
                });
        //4、启动 设置
        ChannelFuture future=serverBootStrap.bind(9999).sync();
        System.out.println("服务端已经启动……");
        future.channel().closeFuture().sync();
    }
    //定义消息处理器
    static class MyHandler extends ChannelInboundHandlerAdapter{
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
            System.out.println("Read……");
            //转换消息
            ByteBuf buf=(ByteBuf)msg;
            //实例化字节数组
            byte[] arr=new byte[buf.readableBytes()];
            //读取内容
            buf.copy().readBytes(arr);
            System.out.println("服务端："+new String(arr));
        }
        @Override
        public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
            Scanner scanner=new Scanner(System.in);
            System.out.println("请输入要发送的内容");
            //写出并刷新
            ctx.writeAndFlush(Unpooled.wrappedBuffer(scanner.nextLine().getBytes()));
        }
        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
            System.err.println("崩了……"+cause.getMessage());
        }
    }

3.创建客户端

public static void main(String[] args) throws InterruptedException {
        //1.创建组
        EventLoopGroup accepts=new NioEventLoopGroup(10);
        //2.创建客户端对象
        Bootstrap bootstrap=new Bootstrap();
        //3.链式编程  设置各种
        bootstrap.group(accepts).channel(NioSocketChannel.class)
                .option(ChannelOption.TCP_NODELAY,true).handler(
                new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
                        ChannelPipeline pipeline=socketChannel.pipeline();
                        //设置消息处理器
                        pipeline.addLast(new MyHandler());
                    }
                });
        //4、启动 设置
        ChannelFuture future=bootstrap.connect("localhost",9999).sync();
        System.out.println("客户端已连接");
    }
    //定义消息处理器
    static class MyHandler extends ChannelInboundHandlerAdapter{
        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception {
            ctx.writeAndFlush(Unpooled.wrappedBuffer("我已连接，速来消息".getBytes()));
        }
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
            //转换消息
            ByteBuf buf=(ByteBuf)msg;
            //实例化字节数组
            byte[] arr=new byte[buf.readableBytes()];
            //读取内容
            buf.copy().readBytes(arr);
            System.out.println("客户端："+new String(arr));
        }
        @Override
        public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
            Scanner scanner=new Scanner(System.in);
            System.out.println("客户端：请输入要发送的内容");
            //写出并刷新
            ctx.writeAndFlush(Unpooled.wrappedBuffer(scanner.nextLine().getBytes()));
        }
        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
            System.err.println("崩了……"+cause.getMessage());
        }
    }

三、JVM和GC

3.1 JVM组成

1.类加载器

1.类的加载过程：
    加载（加载时机、类加载器）
    链接（验证（文件格式、元数据、字节码、）、准备、解析）
    初始化
2.类加载器
    1.根类加载器（BootStrap Class Loader）
            Launcher.getBootstrapClassPath()
    2.扩展类加载器（extension Class Loader）
    3.应用类加载器（系统类加载器 system Class Loader）
        ClassLoader loader= ClassLoader.getSystemClassLoader();
        加载步骤
    4.自定义类加载（CustomClassLoader）
3.类的加载机制：
    1.全盘负载
    2.双亲委派
    3.缓存
    双亲委派：

2.JVM五大区域的作用

3.堆

年轻代（伊甸区、幸存者区（FromSpace、ToSpace））、老年代
永久代（JDK1.8遗弃， 改为元数据空间）

新创建对象先存储到年轻代—>伊甸区，如果伊甸区满了，会触发GC(Minor GC)会对伊甸区进行回收，如果存活下来，会转移到幸存者区，以此类推。如果幸存者区满了，会触发GC(Minor GC)进行幸存者区，将存活的对象转移到幸存者区的ToSpace.如果ToSpace满了触发GC(Minor GC).会将存活的对象转移到老年代。

老年代满了，触发GC(Major GC) 清理。

Full GC(清理年轻代和老年代)

为什么幸存者区会有2块？
1.内存碎片化 充分使用

4.Java引用

1.强引用
new 类名()
特点：内存不足，GC运行，如果强引用没有释放，GC还是无法清理，可能会报内存溢出
2.软引用
SoftReference
特点：内存不足，GC运行，GC会强制清理软引用对象
3.弱引用
WeakReference
特点：只要GC运行，GC会强制清理弱引用对象
4.虚引用（幽灵引用、幻影引用）
PhantomReference
特点：引用最弱的，无法获取对象实例。虚可达对象。

5.GC的可达性分析

1.引用计数法
简单
缺点：如果对象存在相互引用，计数不准确 可能导致内存泄漏
2.可达性分析算法
GC ROOT 根节点 向下逐渐分析引用关系，找到没有引用的对象
GC ROOT:是不能包含本地方法栈

6.GC回收算法

1.标记-清除法
2.复制
3.标记-整理法
4.分代收集

7.GC收集器

1.串行垃圾回收器
2.并行垃圾回收器
3.CMS垃圾回收器
4.G1垃圾回收器

8.为什么会OOM?

Out Of Memory
1.老年代 内存溢出
2.永久代（元数据空间） 内存溢出
3.bug GC无法回收内存
    可以设置记录快照。-XHeapDumpOutOfMemoryError
    启用GC日志

JVM和GC的调优：尽量降低Full GC的触发频率，通过设置合理的参数

并行收集器相关参数

CMS相关参数

辅助信息

1.请解释final、finally、finalize的区别？

final 最终的

finally 配合try

finalize 配合虚引用

领域模型、贫血模型、充血模型

浅拷贝和深拷贝

四、高频分享

4.1 集合源码

1.ArrayList

扩容方法。底层采用array.copyOf 和System.arraycopy来实现数组的复制，同时扩容机制采用每次乘以原来的1.5倍进行扩容。

1.7 ArryList的初始容量10

1.8 ArrayList的初始容量0

2.HashMap

1.7：

底层：数组+链表

HashMap在遇到哈希冲突（对某元素进行哈希运算的时候，得到的存储地址已经被占用了）的时候，HashMap使用了链地址法（使用链表来解决该问题，链表越少，HashMap性能越好）解决该问题

1.8：

底层：数组+链表+红黑二叉树

如果节点超过8就会从链表转换为红黑二叉树。

红黑树的平均查找长度是log(n)，长度为8，查找长度为log(8)=3，链表的平均查找长度为n/2，当长度为8时，平均查找长度为8/2=4，这才有转换成树的必要；链表长度如果是小于等于6，6/2=3，虽然速度也很快的，但是转化为树结构和生成树的时间并不会太短。

HashMap底层的数组，在jdk7中使用的默认初始化容量是16，负载因子是0.75，也就是当数量达到了16*0.75=12的时候，就需要将当前16的容量进行扩容了，扩容需要进行reHash、复制数据等操作（这些操作极其消耗性能，故最好提前预估好HashMap的大小，尽量减少扩容的次数）。

3.ConcurrentHashMap

分段式锁

4.2 框架源码

1.Spring IOC的源码解读

2.Spring AOP源码解读

3.SpringMVC的源码解读

4.Mybatis的源码解读

4.3 SpringBoot自动装配

核心

4.4 Redis

1.Redis淘汰策略

2.Redis的String的底层结构

SDS（simple dynamic string）
保存字符串buf，还保存了free（表示buf中剩余的空间）以及len（当前子字符串的长度）。
优点：
获取字符串长度的复杂度为O（1）
不会造成缓冲区溢出
减少修改字符串带来的内存重分配次数

Redis使用的是内存预分配方法，每次扩容都会额外预留一些空间方便下次扩容

3.RESP协议

Redis是Redis序列化协议，Redis客户端RESP协议与Redis服务器通信

4.5 RabbitMQ

1.vhost

broker（逻辑分组），虚拟的Broker,独立：queue、exchange、binding  权限隔离

2.RabbitMQ消息如何传输？

信道进行数据传输，没有使用TCP
是建立在真实TCP上的虚拟的连接，每个TCP上的信道没有限制

3.保证消息不丢失？

1.消息确认机制

生产者发送消息：

发送消息-到MQ服务器，会将消息转发到对应的队列中，返回一个ACK消息(消息的唯一id)，发送者得到消息，消息发送成功。如果MQ服务器没法处理消息，MQ返回Nack消息，发送者接到之后，就会重新发送。

消费者接收消息：

采用消息确认机制，
1.自动确认
    消费者获取消息，取到了消息，会给MQ服务器发送ACK消息。MQ服务器没有接到ACk消息就不会删除消息。
2.手动确认
    自己手动的进行ack确认
3.不确认模式
    ackxxxx=none 不使用确认机制。MQ服务器消息发送给消费者成功之后，就删除队列中消息。
2.事务
3.开启消息持久化

4.防止消息重复？

消息重复发送或者消息重复消费：

1.消息唯一id(内部生成、外部生成)

2.Redis

3.幂等性

5.RebbitMQ的死信和延迟

4.6 微服务

1.微服务的认知

2.SpringCloud的区别 各种对比

3.Spring Cloud 的常用组件

4.服务通信

5.结合项目

4.7 Nginx

1.Apache 、Tomcat服务器

2.Http、HttpS协议

3.Nginx负载均衡策略

4.Nginx的原理

master进程
worker进程

5.Nginx常用的配置

压缩
统一错误处理
C10K问题（如何处理大量的客户端连接（10000+））

4.8 项目

1.接口安全

验证签名

2.接口盗刷

过滤器  黑白名单 云服务的防御措施（DDOS防护、堡垒机、访问控制）

3.线上问题排查

CPU100%:
1.查消耗cpu最高的进程PID
2.根据PID查出消耗cpu最高的线程号
3.根据线程号查出对应的java线程，进行处理
内存100%：
**通过执行"top -H -p 程序PID"命令查看具体是哪个线程占用cpu最高，找到其线程号**
**通过执行"gstack 程序PID"命令查看程序各线程的堆栈信息**

gdb、gstack

4.版本控制器

5.业务逻辑的实现

6.场景分析

先实现-->后优化

随机应变