香波特不香

Java常见面试题——多线程

3.2.1 多线程

线程有哪些状态？各种状态之间是怎么切换的？

答：

Java的Thread类中通过static枚举定义了线程的几种状态

NEW：初始，即新创建了一个线程对象，但是还没有start()

RUNNABLE：就绪/运行，调用start()成功后的状态

BLOCKED：阻塞，即线程阻塞于锁

WAITING：线程需要等待其它线程做出一些特定动作（通知或中断）

TIMED_WAITING：指定时间的等待

TERMINATED：结束

1.Thread、Runnable、Callable三种方式有什么区别和联系？

答：Thread类实现了Runable接口仅有的run()方法

Callable接口与Runnable有什么联系？

2.volatile保证不了线程安全，那么它能干什么？

拓展1：volatile在什么场景使用？

因为volatile只保证可见性而不保证原子性，因而在不符合如下两条规则时仍然需要通过加锁（synchronized或java.util.concurrent的原子类）来保证原子性：

（1）运算结果不依赖变量的当前值，或者能够确保只有单一的线程修改变量的值

（2）变量不需要与其它的状态变量共同参与不变约束

像i++这种非线程安全的操作，通过synchronized修饰，即能保证原子性

CAS：比较并交换。参考《深入理解Java虚拟机》13.2.2的2非阻塞同步

CAS是一种无锁算法，包括3个操作数，内存值V，旧的预期值A，需要修改的新值B。在修改前比较旧的预期值和A和内存值V，若相同则修改为新值，否则放弃之前的修改操作。

具体过程是，线程将变量值拷贝一份到工作内存，在修改前将这个拷贝值与主内存值进行比较（可能主内存中的值已经被别的线程修改了），若相等，则修改，不等则放弃操作，重新执行。这里的从主内存刷新要求了可见性，即CAS需要与volatile变量配合。

CAS在JDK中的应用如：java.util.concurrent.atomic.AtomicInteger的incrementAndGet()。

public final int incrementAndGet() {

return unsafe.getAndAddInt(this, valueOffset, 1) + 1;

}

public final int getAndAddInt(Object paramObject, long paramLong, int paramInt)

{

int i;

{

i = getIntVolatile(paramObject, paramLong);

} while (!compareAndSwapInt(paramObject, paramLong, i, i + paramInt));

return i;

}

拓展2：volatile如何与CAS结合保证原子性？

什么是QAS？

答：AbstractQueuedSynchronizer。如果说CAS是java.util.concurrent的基础，那么AQS就是整个Java并发包的核心，ReentrantLock、CountDownLatch、Semaphore等都用到了它。AQS实际上以双向队列的形式连接所有的Entry，比如说ReentrantLock，所有等待的线程被放在一个Entry中并连成双向队列，前面一个线程使用ReentrantLock好了，则双向队列实际上的第一个Entry开始运行。

AQS定义了双向队列所有的操作，而只开放了tryLock和tryRelease方法给开发者使用，若有需要，可以重写这2个方法以实现自己的并发功能。

3.什么是竞态条件？

答：由于多线程对共享资源的竞争便会产生竞态条件，如果需要先执行的程序在竞争资源失败被排到了后面，那么程序执行就可能会出现意想不到的错误。这种错误会重复出现，但很难发现，因为竞争是随机的。

4.Thread的stop()、resume()、suspend()等方法都被标记为过期的，为什么？或者说除了这些方法还提供了什么停止等控制线程的API？

答：早期的stop()等方法由于存在潜在的死锁风险而被弃用了，之后Java没有提供兼容并且线程安全的停止线程的API。在run()或call()运行完后线程会自动结束，如果需要手动终止一个线程，可以用volatile来修饰一个boolean变量，来退出run()的循环或取消任务从而达到中止线程的目的。

拓展1：具体的手动中止线程的方式如何实现？

5.为什么wait()、notify()、notifyAll()等方法是在Object对象中，而不是Thread中？

答：这是一个设计问题，这些方法只有在Object中而不是Thread中才有意义。一个显而易见却又容易忽视的原因是，在Java中，锁在资源共享时才有意义，从语言层面来说，最直观的是对象，而这些方法都是锁级别的操作。也就是说在Java语言中，锁都是对象的锁，而没有线程的锁，而线程等待的也是某个对象的锁被释放。如果这些方法在Thread中，线程等待的是哪个线程的锁就不合理了。

6.线程间通信有哪些方式？各有什么区别？分别是怎么使用的？

7.什么是ThreadLocal？

答：ThreadLocal是Java中一个特殊的变量，每个线程都有，它能够帮助创建代价比较高昂的对象获得线程安全，比如SimpleDateFormat、ThreadLocalRandom……每个Thread中维护了一个以开地址法实现的ThreadLocal.ThreadLocalMap，对数据进行隔离，从而实现线程安全。

8.什么是FutureTask ?怎么用？

答：FutureTask实现了Runnable接口（实现的RunnableFuture接口继承了Runnable接口），所以它可以提交给Executor来执行……

使用举例：

ClassImplementsOfCallable ca1 = new ClassImplementsOfCallable (params);

FutureTask result = new FutureTask<>(ca1);

Thread call1 = new Thread(result);

call1.start();

这里result为执行的返回结果

9.为什么wait()、notify()要在同步代码块中调用？

答：Java API强制要求，避免wait()和notify()产生竞态条件。这些方法使用的前提是必须先获得对象的锁

10.为什么应该在循环中检查等待条件？

11.如何解决生产者消费者问题？

答：即线程间通信的问题，最简单的是wait()、notify()方式，比较好的有Semaphore、BlockingQueue等方式……

12.如何避免死锁？

答：

死锁发生的4个条件：

（1）互斥条件：一个资源每次只能被一个进程使用

（2）请求与保持条件：一个进程因请求资源而阻塞时，对已获得资源保持而不释放

（3）不剥夺条件：进程已获得的资源，在未使用完前，不允许强行剥夺

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

避免死锁的最简单办法是阻止循环等待，将系统中所有的资源设置标志位，排序，规定所有的进程申请资源必须以一定的顺序（升序或降序）做操作来避免死锁。

13.Java中活锁和死锁有什么区别？

答：处于活锁的线程或进程的状态是可以改变的，只是不能继续执行。比如两个线程相互谦让资源会出现线程状态不断来回切换，但状态切换的方向是一致的，导致资源并没有被占用，但是线程也无法继续执行……

14.Thread类的holdsLock()方法可以检测线程是否拥有锁，拥有时返回true,是个本地方法

15.如何获取Java的线程堆栈？

答：Windows：ctrl+break；Linux：kill -3；jstack工具

16.synchronized和ReenTrantLock的区别？

答：synchronized是关键字，而ReentrantLock是Java5之后才引进的类，实现了Lock接口。ReentrantLock更加灵活和可扩展，扩展性体现如：

（1）ReentrantLock可以对获取锁的等待时间进行设置，避免死锁；而synchronized尝试获取锁不能中途取消

（2）ReentrantLock可以获取各种锁的信息

（3）ReentrantLock可以灵活地实现多路通知

二者实现锁的机制也并不相同。ReentrantLock底层调用的是Unsafe的park()方法，而synchronized操作的是对象头信息。

16-1.synchronized和ReentrantLock有什么区别？有人说synchronized最慢，这话靠谱么？

典型回答：synchronized是Java内建的同步机制，所以也有Intrinsic Locking的说法，提供了互斥的语义和可见性，当一个线程已经获得当前锁时，其它试图获取的线程只能等待或阻塞。

在Java5之前，synchronized是仅有的同步手段，可以修饰方法，代码块。

ReentrantLock通常译为再入锁，是Java5提供的锁实现，语义和synchronized基本相同。再入锁通过调用lock()方法获取，书写更灵活。ReentrantLock提供了很多实用的方法，能够实现很多synchronized无法做到的细节控制，如可以控制公平性（fairness），或者利用定义条件等。同时需要注意的是，必须明确调用unlock()方法释放锁，不然会一直持有该锁。

synchronized和ReentrantLock的性能不能一概而论，早期版本的synchronized在很多场景下性能相差较大，在后续版本进行了较多改进，在低竞争场景中表现可能优于ReentrantLock。

知识点：

（1）什么是线程安全？

（2）synchronized、ReentrantLock等机制的基本使用与案例

（3）synchronized、ReentrantLock底层实现；锁膨胀、降级；偏斜锁、自旋锁、轻量级锁、重量级锁等

（4）java.util.concurrent.lock各种不同实现和案例分析

17.yield()方法的作用？

答：暂停当前线程，静态方法，只能保证当前线程放弃CPU，但并不能保证其它线程获得CPU，因为当前线程在失去CPU使用权后可能又在下一次竞争中获得

18.ConcurrentHashMap的并发度？

答：ConcurrentHashMap把实际Map划分成若干份来实现可扩展性和线程安全，这种划分是通过并发度获得的，是构造函数的一个参数，默认为16，意味着默认最大支持16个线程同时操作。

19.Swing是线程安全的吗？为什么？

答：Swing不是线程安全的，Swing的组件不能在多线程中进行修改，所有对GUI组件的更新都要在AWT线程中完成……

20.invokeAndWait()和invokeLater()有什么区别？

21.Swing API中哪些方法是线程安全的？

22.如何创建Immutable对象？

23.ReadWriteLock?(ReentrantReadWriteLock)

答：ReadWriteLock是Java5引入的接口，ReentrantReadWriteLock是实现了这个接口的读写锁，读锁是共享的，写锁是独占的，读和读不会互斥，读和写，写和读，写和写会互斥。

24.多线程中的忙循环是什么？

答：忙循环是开发者通过循环的方式让一个线程等待，与wait()、sleep()、yield()不同的是，忙循环不会放弃CPU使用权，运行的是一个空循环。目的是保留CPU缓存，在多核系统中，一个等待线程被唤醒后可能在另一个内核中了，这样需要重建缓存，忙循环能够避免重建缓存，减少等待重建的时间。

25.volatile变量和atomic变量有何不同？

答：AtomicInteger类提供的atomic方法具有原子性，而volatile不保证原子性

26.如果同步块内的线程抛出异常会发生什么？

答：无论同步块是正常还是异常退出，线程都会释放锁……

拓展1：锁接口提供的方法异常会自动释放锁么？或则还需要开发者如何处理？

27.双检锁的单例模式以及隐患？线程安全的Singleton？

JVM类加载和静态变量初始化创建Singleton、使用枚举常见Singleton……

28.多线程最佳实践？

（1）给线程取个有意义的名字：给线程取一个和它要完成的任务相关的名字，方便排查问题和跟踪。目前主要的框架和JDK都遵循这个原则。

（2）避免锁定和缩小同步的范围：锁需要上下文切换，耗费时间和空间。应最低限度使用同步和锁，缩小临界范围。

（3）多用同步类，少用wait()和notify()：如CountDownLatch、Semaphore、CyclicBarrier、Exchanger等同步类简化了编码，而wait()、notify()很难实现对复杂控制流的控制，另外同步类在JDK中不断优化。

（4）多用并发集合少用同步集合：并发集合比同步集合的可扩展性更好……

29.如何强制启动一个线程？

答：线程由线程调度器控制，Java没有提供强制启动线程的API……

30.fork join框架？（工作窃取算法）

31.wait()和sleep()有什么不同？

答：wait()是Object类的方法，而sleep()是Thread类的方法；wait()用于线程间通信，会释放锁，而sleep()仅释放CPU，不释放锁。

32.Java中的Semaphore是什么？

答：Java中的Semaphore是一种新的同步类，是一个计数信号。从概念上，信号量维护了一个许可集合，如有必要，在许可可用前会阻塞每一个acquire()，然后再获取许可。每个release()添加一个许可，从而释放一个正在阻塞的获取者，但是，不使用实际的许可对象，Semaphore只对许可可用的号码进行计数，并采取相应行动。信号量常用于多线程，如数据库连接池中。

Semaphore是信号量，用于限制某段代码块的并发数。Semaphore有一个构造函数，可以传入一个int型整数n，表示某段代码最多只有n个线程可以访问，如果超出n，则等待，此处若把n设为1则相当于synchronized。

33.Java中使用的线程调度算法是什么？

答：抢占式。一个线程释放CPU后，操作系统根据线程优先级、线程饥饿情况等数据计算出一个优先级，并分配下一个时间片给优先级最高的线程。

34.Thread.sleep(0)的作用是什么？

答：由于Java采用抢占式的线程调度算法，因此可能出现某条线程常常获得CPU控制权的情况，而某些优先级较低的线程一直获取不到CPU的控制权，通过Thread.sleep(0)可以手动触发一次暂时放弃CPU，重新竞争CPU的机会，作用在于平衡CPU的控制权。sleep(0)后线程进入就绪态，而不是等待态，所以可以继续竞争CPU。

线程类的构造方法、静态块是被哪个线程调用的？

答：线程类的构造方法、静态块是被new这个线程的线程所调用的，run()才是被线程本身调用的。即谁创建这个线程，谁负责调用其构造方法和静态块。

CycliBarrier和CountDownLatch

CycBarrier和CountDownLatch的区别？

都可以表示代码运行到某个点上，区别在于：

（1）CyclicBarrier的某个线程运行到某个点上之后，该线程即停止运行，直到所有的线程都到达了这个点，所有线程才重新运行；CountDownLatch则不是，某线程运行到某个点之后，只是给某个数值-1而已，该线程继续运行

（2）CyclicBarrier只能唤起一个任务，CountDownLatch可以唤起多个任务

（3）CyclicBarrier可重用，CountDownLatch不可重用，计数值为0该CountDownLatch就不可再用了

3.2.2 线程池

1.什么是线程池？为什么要使用它？

拓展1：都说创建线程要花费昂贵的资源和时间，具体是什么数量级？

答：线程消耗包括内存和其它系统资源在内的大量资源，除了Thread对象所需的内存之外，每个线程都需要2个可能很大的执行调用堆栈，除此之外，JVM可能会为每个Java线程创建一个本机线程，这些本机线程将消耗额外的系统资源。线程之间切换的调度开销很小，但是对于服务器程序，可能线程的数量是庞大的，而且调度很频繁，那么切换也可能严重地影响程序的性能。

3、线程池有什么作用？

4、说说几种常见的线程池及使用场景。

5、线程池都有哪几种工作队列？

6、怎么理解无界队列和有界队列？

7、线程池中的几种重要的参数及流程说明。

8.线程池的死锁

答：对于需要返回结果的线程，存在一种情况，所有池线程都在执行已阻塞的等待队列中另一个任务的执行结果，但是阻塞队列已满，这个任务一直得不到空闲线程来执行，而导致线程池的死锁。

场景：线程之间有较多的交互，比如相互之间发送查询，而查询作为排队的任务执行，且查询对象同步等待。

1.应用容器已经有提供线程池？还需要自实现线程池么？

初步理解：容器管理了外部访问，容器的线程池主要解决的是高并发的外部访问，能够同时接受较多的访问请求，但是业务处理部分是服务提供方实现的，这部分可能存在性能瓶颈，另外由应用容器起的线程在执行到业务代码时，仍然可能引起资源竞争。

2.线程池怎么用？以什么形式提供？

答：Java自带了线程池的实现

如下即可创建一个线程池实例

java.util.concurrent.Executors;

java.util.concurrent.ExecutorService;

java.util.concurrent.CompletionService;

参考：https://blog.csdn.net/zy_281870667/article/details/72047325

MyThread mt = null;

ExecutorService es = Executors.newCachedThreadPool();//线程池

CompletionService cs = new ExecutorCompletionService(es);

for(int i=0;i<4;i++){

mt = new MyThread (i+1);

cs.submit(mt);

}

3.连接池由谁实现？

答：连接池可以由J2EE容器实现，也可以由数据库管理框架（如Mybatis）实现，也可以应用自实现。Mybatis的实现使用了代理模式，获取和关闭的连接对象其实是经过包装的对象。

4.有哪几种线程池，有什么区别和联系？分别有什么差异和适用的场景？

答：java.util.concurrent.Executors;

（1）newCachedThreadPool

（2）newFixedThreadPool

（3）newSingleThreadExecutor

（4）newSingleThreadExecutor

拓展1：这些线程池与ThreadPoolExecutor有什么关联？

答：上述4种线程池实际上都是通过返回ThreadPoolExceutor实例实现的，也就是说ThreadPoolExecutor是线程池的实现，提供了不同的参数和构造函数，能够返回不同功能的线程池实例。

newFiexdThreadPool

创建固定数量的线程池，核心线程数和最大线程数固定，工作队列为最大为Integer.MAX_VALUE大小的阻塞队列。当执行任务时，如果线程都忙，就会丢到工作队列等待有空闲线程来执行，若队列满则执行默认的拒绝策略。

public static ExecutorService newFixedThreadPool(int nThreads) {

return new ThreadPoolExecutor(nThreads, nThreads,

0L, TimeUnit.MILLISECONDS,

new LinkedBlockingQueue());

}

public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {

return new ThreadPoolExecutor(nThreads, nThreads,

0L, TimeUnit.MILLISECONDS,

new LinkedBlockingQueue(),

threadFactory);

}

newCachedThreadPool

带缓冲线程池，核心线程数为0，最大线程数为Integer的最大值，超过0个的空闲线程在60秒后销毁，SynchronousQueue是一个可直接提交的队列，当有新任务时，若有空闲线程则执行任务，若没有则创建一个线程，适合执行速度快而且小的线程，否则超出最大线程池边界会造成内存溢出。

public static ExecutorService newCachedThreadPool() {

return new ThreadPoolExecutor(0, Integer.MAX_VALUE,

60L, TimeUnit.SECONDS,

new SynchronousQueue());

}

public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {

return new ThreadPoolExecutor(0, Integer.MAX_VALUE,

60L, TimeUnit.SECONDS,

new SynchronousQueue(),

threadFactory);

}

newSingleThreadExecutor

单线程线程池，核心线程数和最大线程数均为1，每次只执行一个线程，多余的先存储到工作队列。

public static ExecutorService newSingleThreadExecutor() {

return new FinalizableDelegatedExecutorService

(new ThreadPoolExecutor(1, 1,

0L, TimeUnit.MILLISECONDS,

new LinkedBlockingQueue()));

}

public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {

return new FinalizableDelegatedExecutorService

(new ThreadPoolExecutor(1, 1,

0L, TimeUnit.MILLISECONDS,

new LinkedBlockingQueue(),

threadFactory));

}

newScheduledThreadPool

调度线程池，按一定周期执行任务

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {

return new ScheduledThreadPoolExecutor(corePoolSize);

}

public static ScheduledExecutorService newScheduledThreadPool(

int corePoolSize, ThreadFactory threadFactory) {

return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);

}

拒绝策略

（1）AbortPolicy

默认的拒绝策略，直接抛出拒绝异常

（2）CallerRunsPolicy

如果线程池未关闭，则会在调用者线程中直接执行新任务，这会导致主线程提交线程性能变慢。

（3）DiscardPolicy

丢弃，即不处理新任务

（4）DiscardOldestPolicy

抛弃最老的任务，从队列取出最老的任务然后放入新的任务进行执行

关闭线程池

shutdown():不再接受新任务，之前提交的任务等执行结束再关闭线程池。

shutdownNow():不再接受新任务，试图停止池中的任务再关闭线程池，返回所有未处理的线程列表。

5.线程池的submit()和execute()方法有什么区别和联系？

答：都可以向线程池提交任务。

execute()定义在Executor接口中，返回为void；

submit()定义在ExecutorService接口中，继承自Executor，返回持有计算结果的Future对象，并且能通过Future的get方法捕获线程中的异常。其它线程池类如ThreadPoolExecutor、ScheduledThreadPoolExecutor都有这些方法。

6.如果提交任务时，线程队列已满，会发生什么？

答：

（1）如果使用的是无界队列LinkedBlockingQueue，那么继续添加任务到阻塞队列中等待执行，LinkedBlockingQueue可以近乎认为是一个无穷大的队列，可以无限存放任务

（2）如果使用的是有界队列如ArrayBlockingQueue，那么任务会先被添加，然后根据maximumPoolSize的值增加线程数量，如果增加了线程数量仍然处理不过来，则会使用拒绝策略RejectedExceptionHandler处理满了的任务，默认是AbortPolicy

7.高并发、任务执行时间短的业务怎样使用线程池？并发不高、任务执行时间长的业务又如何？并发高、任务执行时间长的业务又如何？

（1）高并发、任务执行时间短的业务，线程池线程数可设置为CPU+1，减少线程上下文切换

（2）并发不高、任务执行时间长的业务需要区分看

（a）如果执行时间主要集中在IO，即IO密集型任务，因IO操作不占用CPU，所以不应让CPU空闲，适合加大线程数，让CPU处理更多任务

（b）如果执行时间主要集中在计算，即计算密集型任务，则和（1）一样，减少线程上下文切换

（3）并发高、任务执行时间长的场景关键不在于线程池而在于整体架构的设计，如第一步考虑某些业务数据是否能做缓存，第二步考虑服务器扩容。针对执行时间长的问题，考虑使用中间件进行拆分和解耦。

3.2.2.1 ThreadPoolExecutor

corePoolSize:核心线程池大小

maximumPoolSize:最大线程池大小。

keepAliveTime:如果当前线程池中的线程数超过了corePoolSize，那么如果在keepAliveTime时间内都没有新的任务需要处理，则超过corePoolSize部分的线程会被销毁，默认情况是不会回收core线程的。可通过allowCoreThreadTimeOut改变这一行为。

workQueue：实际用于存储任务的队列。最核心的参数，直接决定了线程池的行为。是否扩容和core、max设置，队列类型相关。

threadFactory:创建线程的工厂。若不指定，默认使用Executors.defaultThreadFactory()，一般会在此设置线程名，异常处理器等。

handler:拒绝策略，当工作队列、线程池全已满时如何拒绝新任务，默认抛出异常。

线程池状态：

RUNNING:当前线程池正在运行中，可以接受新任务以及处理队列中的任务。

SHUTDOWN:不再接受新的任务，但会继续处理队列中的任务。

STOP:不再接受新任务，也不处理队列中的任务，并且会中断正在进行的任务。

TIDYING:所有任务都已处理完毕，线程数为0，转为TIDYING状态后，会调用terminated()回调

TERMINATED：terminated()已执行完毕。

8、什么是反射机制？

9、说说反射机制的作用。

10、反射机制会不会有性能问题？

20、什么是虚拟主机及实现原理？

21、什么是Java虚拟机，为什么要使用？

22、说说Java虚拟机的生命周期及体系结构。

23、说一说Java内存区域。

24、什么是分布式系统？

25、分布式系统你会考虑哪些方面？

26、讲一讲TCP协议的三次握手和四次挥手流程。

答：

三次握手

第一次：连接请求。客户端发送连接请求报文，SYN=1，Seq=X，然后客户端进入SYN_SEND状态，等待服务器确认。

第二次：服务器响应连接请求。服务器收到客户端的连接请求后，SYN=1，ack=X+1，Seq=Y，服务器进入SYN_RECV状态。

第三次：客户端响应请求。客户端将,ack=Y+1，Seq=Z，客户端进入ESTABLISHED状态。

四次挥手

第一次：某一方（可以是客户端，也可以是服务端）主动请求关闭连接。A发起关闭连接请求，FIN=1，seq=m，发送完后进入FIN_WAIT_1状态，不再发送数据，但是可以接收。

第二次：另一方响应关闭请求。B收到关闭请求后向A发送响应，SYN=1，seq=n，ack=m+1，进入CLOSE_WAIT状态。

第三次：被动方发起关闭连接请求。B向A发起关闭请求，FIN=1，SYN=1，seq=w，ack=m+1，进入LAST_ACK状态（B在收到A的关闭请求后，不一定会立即发起关闭请求，可能数据还没传输完，仍然需要发送数据）。

第四次：主动方响应并进入等待状态。A收到FIN后发送响应，SYN=1，seq=m+1，ack=w+1，进入TIME_WAIT状态，B收到响应后进入CLOSED状态。（此处主动方需要等待2MSL时间才关闭）

27、为什么TCP建立连接协议是三次握手，而关闭连接却是四次握手呢？为什么不能用两次握手进行连接？

答：如果是两次，那么存在这样一种情况，客户端某一次发送的连接请求并没有丢失，而是因为某个网络堵塞或其它原因导致这个请求延误，在连接释放之后才到达服务端，那么服务端会误以为这是一个新的连接请求而发出响应报文，如果是两次握手，那么此时连接就已经建立了。然而事实上客户端并没有发送新的连接请求，在收到服务端的响应后不会理睬，也不会发送数据，此时服务端会一直等待客户端的数据，导致服务端浪费很多资源。采用三次握手的方式能够有效避免这种场景。

28、为什么TCP TIME_WAIT状态还需要等2MSL后才能返回到CLOSED状态？

答：MSL即报文最大生存时间，即报文在被丢弃前在网络的最大有效时间。

原因1：防止被动方收不到影响而反复发生结束连接请求。如果主动方直接进入CLOSED状态，而被动方可能因为网络或其它原因没有收到主动方的这个响应，而重新发起关闭连接请求，但是主动方已经是CLOSED状态，不可能再响应，被动方无法得知何时关闭请求。

原因2：避免新连接与旧连接的迟到数据混淆。可能网络中仍然存在当前连接的迟到数据，如果直接CLOSED，那么被动方在收到这个数据时会误以为是被动方的新连接的数据而保持连接，实际上却收不到对方的数据而导致连接继续保存，浪费资源。（在Linux等系统中，一个端口不能被重复打开，一个TCP连接在TIME_WAIT状态时，端口仍然被占用，无法使用该端口建立新的连接）

29、什么是DoS、DDoS、DRDoS攻击？如何防御？

30、描述一下Java异常层次结构。

31、什么是检查异常，不受检查异常，运行时异常？并分别举例说明。

32、finally块一定会执行吗？

答：不一定。

（1）若在finally对应的try执行之前返回了，则不会执行finally。比如try之前异常了，或者try之前执行了return。

（2）若在finally对应的try之前或之中执行了System.exit(0)，则不会执行finally，此时会直接停止，即使是在一个有返回的函数中也不会返回。

（3）线程被中断或杀死时，finally也可能不执行。极端情况如死机、断电等，finally也可能不会执行。

可参考：https://blog.csdn.net/jiasanshou/article/details/6996932，经验证与博客中描述一致

33、正常情况下，当在try块或catch块中遇到return语句时，finally语句块在方法返回之前还是之后被执行？

答：之前。

34、try、catch、finally语句块的执行顺序。

答：

（1）正常情况下，先执行try语句块，若顺利执行没有出现异常则在之后执行finally，若出现异常则跳到catch中，try中异常后面的语句不执行，在catch执行完执行finally。

（2）如果try或catch中有控制转移语句（return、throw、break、contine），finally会在控制转移语句之前执行，比如return，finally会在return之前执行。

（3）控制转移语句分为有返回值和无返回值的，或者说控制权转移和保留之分。return和throw为有返回值的，也是控制权会转移给调用者的。如果try中有需要返回的语句，则在执行finally之前会将返回值保留到局部变量表，在执行完finally之后，再将这个值恢复到操作数栈中，这样即使在finally中修改了这个返回值，最后返回给调用者的也是finally执行之前的值；但如果finally中也有返回，则返回的是finally块的值而不是try中的。

注意：如果try中return的是一个方法，eg：return test();那么效果等同于Object tmp =test();return tmp;也就是说执行顺序是先执行test()代码部分，然后是finally部分，最后是try的return。

拓展1：根据《The JavaTM Programming Language,Forth Edith》的描述，finally的执行总是有原因的，可能是try块顺利的执行了，但try中出现return或throw的控制流，此时进入finally的原因会被保留直到finally被执行完，而如果finally中本身也出现了如return、break、抛异常的控制流，那么初始进入finally的原因会被新的取代。

35、Java虚拟机中，数据类型可以分为哪几类？

36、怎么理解栈、堆？堆中存什么？栈中存什么？

37、为什么要把堆和栈区分出来呢？栈中不是也可以存储数据吗？

38、在Java中，什么是是栈的起始点，同是也是程序的起始点？

39、为什么不把基本类型放堆中呢？

40、Java中的参数传递时传值呢？还是传引用？

答：值传递，我们通常通过new获得的是栈中对象的引用，这个引用其实是对象的地址，作为参数传递时传递的是这个地址的副本，所以是值传递。一个典型的验证场景是，在一个函数中传递这个引用，函数里面的操作是将其置空或指向另一个对象，在执行完这个函数后，再取这个引用所指向对象的值，如果是按引用传递，那么此时对象的值一定会变，会根据函数的操作相应变空或是不同的值，但实际测试中发现仍然是原来的值，证明不是按引用传递的。

41、Java中有没有指针的概念？

42、Java中，栈的大小通过什么参数来设置？

43、一个空Object对象的占多大空间？

44、对象引用类型分为哪几类？

答：

（1）强引用，常见的Object obj = new Object()方式创建的对象

（2）软引用：SoftReference