Java八股文(高阶)背诵版

方法区是静态分配的，编译器将变量绑定在某个存储位置上，而且这些绑定不会在运行时改变。常数池，源代码中的命名常量、String 常量和 static 变量保存在方法区。
JavaStack 是一个逻辑概念，特点是后进先出。一个栈的空间可能是连续的，也可能是不连续的。最典型的 Stack 应用是方法的调用，Java 虚拟机每调用一次方法就创建一个方法帧（frame），退出该方法则对应的方法帧被弹出(pop)。栈中存储的数据也是运行时确定的。所谓的虚拟机栈就是常说的栈。本地方法栈和虚拟机栈所发挥的作⽤⾮常相似，区别是：虚拟机栈为虚拟机执⾏ Java ⽅法（也就是字节码）服务，⽽本地⽅法栈则为虚拟机使⽤到的 Native ⽅法服务。在HotSpot 虚拟机中和 Java 虚拟机栈合二为一。
Java 堆分配(heap allocation)意味着以随意的顺序，在运行时进行存储空间分配和收回的内存管理模型。堆中存储的数据常常是大小、数量和生命期在编译时无法确定的。Java 对象的内存总是在 heap 中分配。我们每天都在写代码，每天都在使用 JVM 的内存。
程序计数器:字节码解释器通过改变程序计数器来依次读取指令，从⽽实现代码的流程控制，如：顺序执⾏、选择、循环、异常处理。在多线程的情况下，程序计数器⽤于记录当前线程执⾏的位置，从⽽当线程被切换回来的时候能够知道该线程上次运⾏到哪个位置。
JDK 1.8 的时候，⽅法区（HotSpot的永久代）被彻底移除了（JDK1.7就已经开始了），取⽽代之是元空间，元空间使⽤的是直接内存。

b) java 内存分配

基础数据类型直接在栈空间分配;
方法的形式参数，直接在栈空间分配，当方法调用完成后从栈空间回收;
引用数据类型，需要用 new 来创建，既在栈空间分配一个地址空间，又在堆空间分配对象的类变量;
方法的引用参数，在栈空间分配一个地址空间，并指向堆空间的对象区，当方法调用完后从栈空间回收;
局部变量 new 出来时，在栈空间和堆空间中分配空间，当局部变量生命周期结束后，栈空间立刻被回收，堆空间区域等待 GC 回收;
方法调用时传入的实际参数，先在栈空间分配，在方法调用完成后从栈空间释放;
字符串常量在 DATA 区域分配，this 在堆空间分配;
数组既在栈空间分配数组名称，又在堆空间分配数组实际的大小！

2、解释内存中的栈 (stack) 、堆 (heap) 和方法区 (method area) 的用法

通常一个基本数据类型的变量，一个对象的引用，以及函数调用的现场保存都使用 JVM 中的栈空间；而通过 new 关键字和构造器创建的对象则放在堆空间，堆是垃圾收集器管理的主要区域，现在的垃圾收集器都采用分代收集算法，故堆空间还可以细分为新生代和老生代，再具体一点可以分为 Eden、Survivor（又可分为From Survivor 和 To Survivor）、Tenured；

方法区和堆都是各个线程共享的内存区域，用于存储已经被 JVM 加载的类信息、常量、静态变量、JIT 编译器编译后的代码等数据；

程序中的字面量（literal）如直接书写的 100、"hello" 和常量都是放在常量池中，常量池是方法区的一部分。

栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，栈和堆的大小都可以通过 JVM 的启动参数来进行调整（栈空间用光了会引发 StackOverflowError，而堆和常量池空间不足则会引发 OutOfMemoryError）

3、java 中有几种方法可以实现一个线程？用什么关键字修饰同步方法? stop()和 suspend()方法为何不推荐使用？

实现线程有两种方式：1.继承 Thread 类，重写 run 方法，在调用 start 方法。

实现 Runnable 接口，重写 run 方法。在传给 Thread 构造器，调用时调用 Thread 的 start 方法。

用 synchronized 关键字修饰同步方法。

不使用 stop()，是因为它不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。suspend()方法容易发生死锁。调用 suspend()的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。此时，其他任何线程都不能访问锁定的资源，除非被"挂起"的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁。所以不应该使用 suspend()，而应在自己的 Thread 类中置入一个标志，指出线程应该活动还是挂起。若标志指出线程应该挂起，便用 wait()命其进入等待状态。若标志指出线程应当恢复，则用一个 notify()重新启动线程

4、sleep() 和 wait() 有什么区别?

sleep 是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用 sleep 不会释放对象锁。

wait 是 Object 类的方法，对此对象调用 wait 方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出 notify 方法（或 notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。

5、当一个线程进入一个对象的一个 synchronized 方法后，其它线程是否可进入此对象的其它方法?

分几种情况：

1. 其他方法前是否加了 synchronized 关键字，如果没加，则能。
2. 如果这个方法内部调用了 wait，则可以进入其他 synchronized 方法。
3. 如果其他个方法都加了 synchronized 关键字，并且内部没有调用 wait，则不能。
4. 如果其他方法是 static，它用同步锁是当前类的字节码，与非静态的方法不能同步，因为非静态的方法用的是 this。

6、简述 synchronized java.util.concurrent.locks.Lock 的异同？

答： Lock 是 Java 5 以后引入的新的 API，和关键字 synchronized 相比主要相同点：Lock 能完成 synchronized 所实现的所有功能；主要不同点：Lock 有比synchronized 更精确的线程语义和更好的性能，而且不强制性的要求一定要获得锁。synchronized 会自动释放锁，而 Lock 一定要求程序员手工释放，并且最好在 finally 块中释放（这是释放外部资源的最好的地方）。

7、谈谈 synchronized 和 ReentrantLock 的区别

synchronized 依赖于 JVM ⽽ ReentrantLock 依赖于 API

synchronized 是依赖于 JVM 实现的，虚拟机团队在 JDK1.6 为 synchronized 关键字进⾏了很多优化，这些优化都是在虚拟机层⾯实现的，并没有直接暴露给开发人员。

ReentrantLock 是 JDK 层⾯实现的（也就是 API 层⾯，需要 lock() 和 unlock() ⽅法配合try/finally 语句块来完成）

2.ReentrantLock ⽐ synchronized 增加了⼀些⾼级功能

①等待可中断，可以通过lock.lockInterruptibly()来实现中断等待锁的线程的机制，使其放弃等待改为处理其他事情。

②可实现公平锁；ReentrantLock可以指定是公平锁还是⾮公平锁。⽽synchronized只能是⾮公平锁。

③可实现选择性通知（锁可以绑定多个条件）ReentrantLock类结合Condition实例可以实现“选择性通知”，而使用synchronized关键的话执行notifyAll()会通知所有等待线程。

8、线程的基本概念

一个程序中可以有多条执行线索同时执行，一个线程就是程序中的一条执行线索，每个线程上都关联有要执行的代码，即可以有多段程序代码同时运行，每个程序至少都有一个线程，即 main 方法执行的那个线程。如果只是一个 cpu，它怎么能够同时执行多段程序呢？这是从宏观上来看的，cpu 一会执行 a 线索，一会执行 b 线索，切换时间很快，给人的感觉是 a,b 在同时执行，好比大家在同一个办公室上网，只有一条链接到外部网线，其实，这条网线一会为 a 传数据，一会为 b 传数据，由于切换时间很短暂，所以，大家感觉都在同时上网。

9、什么是多线程

线程是程序执行流的最小单元，相对独立、可调度的执行单元，是系统独立调度和分派

CPU 的基本单位。在单个程序中同时运行多个线程完成不同的工作，称为多线程。

10、程序、进程、线程之间的关系

程序是一段静态的代码，是应用软件执行的蓝本。

进程是程序一次动态执行的过程，它对应了从代码加载、执行完毕的一个完整过程，这也是进程开始到消亡的过程。

线程是进程中独立、可调度的执行单元，是执行中最小单位。

一个程序一般是一个进程，但可以一个程序中有多个进程。

一个进程中可以有多个线程，但只有一个主线程。

Java 应用程序中默认的主线程是 main 方法，如果 main 方法中创建了其他线程，JVM

就会执行其他的线程。

11、创建线程有几种方式，分别是什么？

创建线程有三种方式：

是继承 Thread 类，创建格式如下：Thread thread = new Thread();
是实现 Runnable 接口，创建格式如下： Thread thread = new Thread(new Runnable()); 其实 Thread 类实现了 Runnable 接口

是实现 Callable 接口

Callable<Integer> oneCallable = new SomeCallable<Integer>();
FutureTask<Integer> oneTask = new FutureTask<Integer>(oneCallable);
Thread oneThread = new Thread(oneTask); 
oneThread.start();

通过线程池方式，获取线程

package com.myjava.thread; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
public class ThreadPool { 
    private      static int POOL_NUM = 10;
    public static void main(String[] agrs){

        ExecutorService executorService = Executors.newFixedThreadPool(5); 
        for (int i = 0; i < POOL_NUM; i++) {

            RunnableThread thread = new RunnableThread(); executorService.execute(thread);

        }

    } 
} 
class RunnableThread implements Runnable{ 
    private  int THREAD_NUM = 10;

    public void run() { 
        for (int i = 0; i <THREAD_NUM; i++) {

            System.out.println("线程"+Thread.currentThread()+i);

        }

    }

}

12、线程的生命周期

新建—就绪 –运行—阻塞—销毁新建：就是使用 new 方法，new 出来的线程就绪：当调用线程的 start()方法后，这时候线程属于等待 CPU 分配资源阶段，谁先抢到 cpu 资源谁开始执行运行：当就绪的线程被调度并且获得 cpu 资源时，便进入运行状态，run 方法定义了线程的操作和功能阻塞：在运行状态的时候，可能因为某些原因导致运行状态线程进入阻塞状态，比如 sleep() 和 wait()之后线程就属于阻塞状态，这时需要其它机制将处于阻塞状态的线程唤醒，比如 notify()或者 notifyAll()方法,唤醒的线程不会立即执行 run()方法，它们要再次等待 cpu 分配资源进入运行状态。

销毁：如果线程正常执行完毕后或线程被提前强制性的终止或出现异常导致终止，那么现场就被销毁，释放资源。

13、线程 currentThread()与 interrupt()方法的使用

currentThread()方法是获取当前线程

interrupt()唤醒休眠线程，休眠线程发生 InterruptedException 异常

14、线程状态

新建状态（New）：新创建了一个线程对象。
就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的 start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取 CPU 的使用权。
运行状态（Running）：就绪状态的线程获取了 CPU，执行程序代码。
阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃 CPU 使用权，暂时停止运行。
死亡状态（Dead）：线程执行完了或者因异常退出了 run()方法，该线程结束生命周期。

15、启动线程的方式？start or run?

启动线程的方式为调用线程的 start()方法。

调用线程的 run（）方法将不会开启线程，而是在原来的主线程上运行。

16、在 java 中守护线程和本地线程区别？

java 中的线程分为两种：守护线程（Daemon）和用户线程（User）。

任何线程都可以设置为守护线程和用户线程，通过方法 Thread.setDaemon(boolean)；true 则把该线程设置为守护线程，反之则为用户线程。Thread.setDaemon()必须在

Thread.start()之前调用，否则运行时会抛出异常。

两者的区别：

唯一的区别是判断虚拟机(JVM)何时离开，Daemon 是为其他线程提供服务，如果全部的 User

Thread 已经撤离，Daemon 没有可服务的线程，JVM 撤离。也可以理解为守护线程是 JVM 自动创建的线程（但不一定），用户线程是程序创建的线程；举例:JVM 的垃圾回收线程是一个守护线程，当所有线程已经撤离，不再产生垃圾，守护线程自然就没事可干了，当垃圾回收线程是 Java 虚拟机上仅剩的线程时，Java 虚拟机会自动离开。

扩展：ThreadDump 打印出来的线程信息，含有 daemon 字样的线程即为守护进程，可能会有：服务守护进程、编译守护进程、windows 下的监听 Ctrl+break的守护进程、Finalizer 守护进程、引用处理守护进程、GC 守护进程。