Java面试准备

个人笔记之Java面试准备：

一、基础知识

1、线程相关的
1.1、Thread源代码解析

public class Thread implements Runnable {}

1.1.1 线程的定义：

A thread is a thread of execution in a program. The Java Virtual Machine allows an application to have multiple threads of execution running concurrently.

Every thread has a priority. Threads with higher priority are executed in preference to threads with lower priority. Each thread may or may not also be marked as a daemon. When code running in some thread creates a new

Thread

object, the new
thread has its priority initially set equal to the priority of the creating thread, and is a daemon thread if and only if the creating thread is a daemon.

When a Java Virtual Machine starts up, there is usually a single non-daemon thread (which typically calls the method named

main

of some designated class). The Java Virtual Machine continues to execute threads until either of the following occurs:

The

exit

method of class

Runtime

has been called and the security manager has permitted the exit operation to take place.
All threads that are not daemon threads have died, either by returning from the call to the

run

method or by throwing an exception that propagates beyond the

run

method.
There are two ways to create a new thread of execution. One is to declare a class to be a subclass of

Thread

. This subclass should override the

run

method of class

Thread

. An instance of the subclass can then be allocated
and started. 

The other way to create a thread is to declare a class that implements the

Runnable

interface. That class then implements the

run

method. An instance of the class can then be allocated, passed as an argument when creating

Thread

, and started. 

Every thread has a name for identification purposes. More than one thread may have the same name. If a name is not specified when a thread is created, a new name is generated for it.

Unless otherwise noted, passing a

null

argument to a constructor or method in this class will cause a

NullPointerException

to be thrown.

1.1.2 线程的用法：extends Thread,  implements Runnable 

1.1.3 线程的分类(daemon)：用户线程/守护线程

1.1.4 主要方法: start(), sleep(), run(), exit(), interrupt(), yield()

1.1.4.1 start()和run()的区别

1.1.5 线程的状态: NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED

1.1.6 主要数据结构: tid, priority, daemon, threadStatus

1.2、线程池源代码解析

1.2.1 

public interface Executor{}

public interface ExecutorService extends Executor{}

public abstract class AbstractExecutorService implements ExecutorService{}

public class ThreadPoolExecutor extends AbstractExecutorService{}

1.2.2

/**
     * Creates a new {@code ThreadPoolExecutor} with the given initial
     * parameters.
     *
     * @param corePoolSize the number of threads to keep in the pool, even
     *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
     * @param maximumPoolSize the maximum number of threads to allow in the
     *        pool
     * @param keepAliveTime when the number of threads is greater than
     *        the core, this is the maximum time that excess idle threads
     *        will wait for new tasks before terminating.
     * @param unit the time unit for the {@code keepAliveTime} argument
     * @param workQueue the queue to use for holding tasks before they are
     *        executed.  This queue will hold only the {@code Runnable}
     *        tasks submitted by the {@code execute} method.
     * @param threadFactory the factory to use when the executor
     *        creates a new thread
     * @param handler the handler to use when execution is blocked
     *        because the thread bounds and queue capacities are reached
     * @throws IllegalArgumentException if one of the following holds:<br>
     *         {@code corePoolSize < 0}<br>
     *         {@code keepAliveTime < 0}<br>
     *         {@code maximumPoolSize <= 0}<br>
     *         {@code maximumPoolSize < corePoolSize}
     * @throws NullPointerException if {@code workQueue}
     *         or {@code threadFactory} or {@code handler} is null
     */
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

1.2.3

public class Executors{}

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

2、IO相关的
2.1、文件IO：装饰器模式（组件，被装饰者，装饰者，具体装饰者）

2.2、网络IO：NIO

2.2.1 Channel：

2.2.2 Buffer：内部数据结构

2.2.3 Selector：实现机制

3、JVM

3.1 垃圾收集( Garbage Collection, GC )

3.1.1 哪些内存需要回收：

Java内存运行时区域的各个部分，其中程序计数器、虚拟机栈、本地方法栈3个区域随线程而生，随线程而灭；栈中的栈帧随着方法的进入和退出而有条不紊地执行着入栈和出栈操作。每一个栈帧中分配多少内存基本上在类结构确定下来时就已知，因此这几个区域的内存分配和回收都具备确定性，因此这几个区域的内存分配和回收都具备确定性，在这几个区域内就不需要过多考虑回收的问题，因为方法结束或者线程结束时，内存自然就跟着回收了。

而Java堆和方法区则不一样，一个接口中的多个实现类需要的内存可能不一样，一个方法中的多个分支需要的内存也可能不一样，我们只有在程序处于运行期间时才能知道会创建哪些对象，这部分内存的分配和回收都是动态的，垃圾收集器所关注的是这部分内存，本章后续讨论中的“内存”分配与回收也仅指这一部分内存。

3.1.2 什么时候回收---一个对象不再被任何途径使用

3.1.2.1  引用计数法：很多教科书判断对象是否存活的算法是这样的：给对象中添加一个引用计数器，每当有一个地方引用它时，计数器值就加1；当引用失效时，计数器值就减1；任何时刻计数器为0的对象就是不可能再被使用的。

3.1.2.2  可达性分析( Reachability Analysis )：这个算法的基本思路就是通过一系列的称为“GC Roots”的对象作为起始点，从这些节点开始向下搜索，搜索所走过的路径称为引用链（Reference Chain），当一个对象到GC Roots没有任何引用链相连（用图论的话来说，就是从GC Roots到这个对象不可达）时，则证明此对象是不可用的。

3.1.2.3 在Java语言中，可作为GC Roots的对象包括下面几种：

虚拟机栈（栈帧中的本地变量表）中引用的对象；

方法区中类静态属性引用的对象；

方法区中常量引用的对象；

本地方法栈中JNI（即一般说的Native方法）引用的对象。

4、集合框架

4.1 List

4.1.1 ArrayList

4.1.2 LinkedList

4.2 Map

4.2.1 HashMap

二、业界框架

1、Spring 

1.1、依赖注入，面向接口

1.2、SpringBoot, SpringCloud

2、iBatis

2.1、源代码解析；

2.2、主要原理；

2.3、性能调优

3、SpringCloud

3.1、服务注册与发现