1.字符串常量java内部加载：

58同城的java字符串常量池：

public class StringPool58Demo {
    public static void main(String[] args) {
        String str1 = new StringBuilder("58").append("tongcheng").toString();
        System.out.println(str1);
        System.out.println(str1.intern());
        System.out.println(str1.intern() == str1);
        System.out.println();
        String str2 = new StringBuilder("ja").append("va").toString();
        System.out.println(str2);
        System.out.println(str2.intern());
        System.out.println(str2.intern() == str2);
    }
}

intern方法到底讲了什么：

/**
 * Returns a canonical representation for the string object.
 *<p>
* A pool of strings, initially empty, is maintained privately by the
 * class {@codeString}.
 *<p>
* When the intern method is invoked, if the pool already contains a
 * string equal to this {@codeString} object as determined by
 * the {@link#equals(Object)} method, then the string from the pool is
 * returned. Otherwise, this {@codeString} object is added to the
 * pool and a reference to this {@codeString} object is returned.
 *<p>
* It follows that for any two strings {@codes} and {@codet},
 * {@codes.intern() == t.intern()} is {@codetrue}
 * if and only if {@codes.equals(t)} is {@codetrue}.
 *<p>
* All literal strings and string-valued constant expressions are
 * interned. String literals are defined in section 3.10.5 of the
 *<cite>The Java&trade;Language Specification</cite>.
 *
 *@returna string that has the same contents as this string, but is
 *          guaranteed to be from a pool of unique strings.
 */

方法区和运行时常量池溢出：

结果：

力扣算法第一题：两数之和

1.给定一个数m，求大于该数的最小2的n次幂，返回n

2.给定一个整数数组nums 和一个目标数组 target，请你在数组中找出和为目标数组的那两个整数，并返回他们的数组下标

public class TwoSumDemo {
    public static void main(String[] args) {
        int[] nums = new int[]{2,7,11,15};
        int target = 9;
        int[] index =twoSum1(nums,target);
    }
    // 暴力破解
    public static  int[] twoSum1(int[] nums, int target) {
        for (int i = 0; i < nums.length; i++) {
            for (int j = i+1; j < nums.length; j++) {
                if(target-nums[i] == nums[j]){
                    return new int[]{i,j};
                }
            }
        }
        return null;
    }
    // 通过hash完成
    public static  int[] twoSum2(int[] nums, int target) {
        Map<Integer,Integer> map  = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
           int num =  target -nums[i];
           if(map.containsKey(num)){
                return new int[]{map.get(num),i};
           }
           map.put(nums[i],i);
        }
        return null;
    }
}

3.JUC

可重入锁（又名递归锁）

可重入锁的种类：

public class ReEnterLockDemo {
    static ObjectobjectLockA= new Object();
    public static void m1(){
        new Thread(()->{
            synchronized (objectLockA){
                System.out.println(Thread.currentThread().getName() + "\t" + "------外层调用");
                synchronized (objectLockA){
                    System.out.println(Thread.currentThread().getName() + "\t" + "------中层调用");
                    synchronized (objectLockA){
                        System.out.println(Thread.currentThread().getName() + "\t" + "------内层调用");
                    }
                }
            }
        },"t1").start();
    }
    public static void main(String[] args) {
m1();
    }
}

public class ReEnterLockDemo2 {
    public static void main(String[] args) {
        new ReEnterLockDemo2().m1();
    }
    public synchronized void m1(){
        System.out.println("======外");
        m2();
    }
    public synchronized void m2(){
        System.out.println("====中");
        m3();
    }
    public synchronized void m3(){
        System.out.println("====内");
    }
}

可重入锁的实现机制：

LockSupport

什么是LockSupport：

3种让线程等待或唤醒的方法

• 使用Object中wait()方法让线程等待，使用Object中notify()方法唤醒线程

• 使用JUC包中Condition的await()方法让线程等待，使用signal()方法唤醒线程

• LockSupport类可以阻塞当前线程以唤醒指定被阻塞的线程

Exception in thread "B" java.lang.IllegalMonitorStateException
at java.lang.Object.notify(Native Method)
at com.example.demo.question.LockSupportDemo.lambda$main$1(LockSupportDemo.java:28)
at java.lang.Thread.run(Thread.java:748)

public static void main(String[] args) {
    //SynchronizedWaitNotify();
    //lockAwaitSignal();
    Thread a = new Thread(() -> {
        System.out.println(Thread.currentThread().getName() + "\t" + "---come in");
        LockSupport.park(); // 直接被阻塞了，等待通知，或者是等待放行，需要许可证。
        System.out.println(Thread.currentThread().getName() + "\t" + "-----被唤醒");
    }, "A");
    a.start();
    try {
        TimeUnit.SECONDS.sleep(3);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
    Thread b = new Thread(() -> {
        LockSupport.unpark(a); // b 唤醒 a 不需要锁块
        System.out.println(Thread.currentThread().getName() + "\t" + "-----发出通知");
    }, "B");
    b.start();
}

AQS-AbstractQueuedSynchronizer（抽象队列同步器）

Q:

前置知识：

公平锁和非公平锁：

可重入锁：

LockSupport：

自旋锁：

数据结构之链表：

设计模式之模版设计模式：

技术解释：

锁和同步器的关系：

AQS能解决的问题：

• 加锁就会导致阻塞，必须要等持有锁的线程完成了以后，才能进行。有阻塞就需要排队，实现排队必然需要有某种形式的队列来进行管理。

• 抢到资源的线程直接使用处理业务逻辑，抢不到资源的必然涉及一种排队等候机制。抢占资源失败的线程继续去等待（类似银行业务办理窗口都满了，暂时没有手里窗口的顾客只能去候客区等待排队），但等候线程仍然保留获取锁的可能且获取锁流程仍在继续（候客区的顾客也在等着叫号，轮到了再去受理窗口办理业务）。

• 如果共享资源被占用，就需要一定的阻塞等待唤醒机制来保证锁分配。这个机制主要用的是CLH队列的变体实现，将暂时获取不到锁的线程加入到队列中，这个队列就是AQS的抽象表现。它将请求共享资源线程封装成队列的节点（Node），通过CAS、自旋以及LockSupport.park()的方式，维护state变量的状态，使并发达到同步控制的效果。

• 向map中put 放的不是键值对，是一个node节点，node<k,v>。AbstractQueuedSynchronizer将线程封装在node<Thread>中，AbstractQueuedSynchronizer里面装的是一个一个的node，node里面有一个前指针prev，一个后指针next，完成双向队列。

• AQS有一个同步状态的State成员变量 private volatitle int state；，类似于银行办理业务的受理窗口状态，等于零就是没人，自由状态可以办理。大于等于1就是有人占用窗口，等着去

• AQS的CLH队列，CLH队列是一个双向队列，通常情况下通过自旋等待，state变量就判断是否阻塞。CLH从尾部入队，从头部出队

• AQS = state + CLH队列

node内部类：头、尾、前、后

node类内部结构：

node类属性：

AQS源码深度分析：

Spring AOP

AOP的常用注解：

@Before：前置通知：目标方法之前执行

@After：后置通知：目标方法之后执行

@AferReturning：返回后通知：执行方法结束前执行（异常不执行）

@AfterThrowing：异常通知：出现异常时候执行

@Around：环绕通知：环绕目标方法执行

aop的全部通知顺序，springboot或Springboot2对aop的执行顺序影响：

Spring循环依赖：

Spring的三级缓存

三级缓存分别是什么？三个Map有什么异同

什么是循环依赖

如何检测是否存在循环依赖

多例的情况下循环依赖问题为什么无法解决

什么是循环依赖：

两种注入方式对循环依赖的影响：

构造器循环依赖：

public class ServiceB {
    private ServiceA serviceA;
    public ServiceB(ServiceA serviceA){
        this.serviceA = serviceA;
    }
}

public class ServiceA {
    private ServiceB serviceB;
    public ServiceA(ServiceB serviceB){
        this.serviceB = serviceB;
    }
}

public class ClientConstructor {
    public static void main(String[] args) {
        new ServiceA(new ServiceB(new ServiceA()));
    }
}

Setter方法注入：

public class ServiceAA {
    private ServiceBB serviceBB;

    public void setServiceBB(ServiceBB serviceBB){
        this.serviceBB = serviceBB;
        System.out.println("A 里面设置了 B");
    }
}

public class ServiceBB {
    private ServiceAA serviceAA;

    public void setServiceAA(ServiceAA serviceAA){
        this.serviceAA = serviceAA;
        System.out.println("B 里面设置了 A");
    }
}

public class ClientSet {
    public static void main(String[] args) {
        ServiceAA a = new ServiceAA();
        ServiceBB b = new ServiceBB();

        b.setServiceAA(a);
        a.setServiceBB(b);
    }
}

Spring容器：

DefaultSingletonBeanRegistry：

实例化/初始化：

3个Map和四大方法，总体相关对象：

refresh()方法：

Spring创建Bean步骤：

Redis

Redis 6.0.8：

redis传统五大数据类型和落地应用：

String:

list

hash

set：

zset(sorted set)

知道分布式锁吗？有哪些实现方案？谈谈你对redis分布式锁的理解，删除key的时候有什么问题：

redis除了拿来做缓存，你还见过基于redis的什么用法：

redis做分布式锁的时候有需要注意的问题：

如果是redis是单点部署的，会带来什么问题

集群模式下，比如主从模式，有没有什么问题

介绍一下Redlock，谈谈redission

Redis分布式锁如何续期，说说看门狗

redis缓存过期淘汰策略：

redis的LRU算法的简介：

Redis配置：

问题：

2.0:

3.0:

4.0:

5.0:

6.0:

7.0:

8.0:

9.0:

redis缓存过期淘汰策略：

生产上你们的redis内存设置多少？

如何配置、修改redis内存大小

如果redis内存满了你怎么办？

redis清理内存的方式？定期删除和惰性删除了解过吗

如果一个key过期了，是不是马上就在内存中被删除？

redis缓存淘汰策略（8种）

redis的LRU了解过吗？可否手写一个LRU算法

什么是LRU

LRU的算法核心是哈希链表

手写LRU算法：

第二季：

1.谈谈对volatile的理解：

private static void seeOKByVolatile() {
    MyData myData = new MyData(); //线程要操作资源类
    new Thread(()->{
        System.out.println(Thread.currentThread().getName() + "\t come in ");
        // 暂停一会
        try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {throw new RuntimeException(e);}
        myData.addTO60();
        System.out.println(Thread.currentThread().getName() + "\t update nember value" + myData.number);
    },"AAA").start();
    // 第二个线程 main线程
    while (myData.number == 0){// main线程一直等待循环，直到number值不等于零
    }
    System.out.println(Thread.currentThread().getName() + "\t misson is over,main get number value" + myData.number);
}

2.JMM(java内存模型)

JMM三大特性：

number++有几个操作？

atomic原子类：

在那些地方用到过volitile？

单例模式：

public class SingletonDemo {
    private static SingletonDemoinstance= null;

    private SingletonDemo(){
        System.out.println(Thread.currentThread().getName() + "\t 我是构造方法 singletonDemo()");
    }
    public static SingletonDemo getInstance(){
        if(instance== null){
instance= new SingletonDemo();
        }
        return instance;
    }
    public static void main(String[] args) {
        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
    }
}

public class SingletonDemo {
    private static SingletonDemoinstance= null;

    private SingletonDemo(){
        System.out.println(Thread.currentThread().getName() + "\t 我是构造方法 singletonDemo()");
    }
    //DCL模式（Double Check Lock双端检索机制）
    public static SingletonDemo getInstance(){
        if(instance== null){
            synchronized (SingletonDemo.class){
                if(instance == null){
									instance = new SingletonDemo();
                }
            }
        }
        return instance;
    }
}

public class SingletonDemo {
    private static volatile SingletonDemoinstance= null;

    private SingletonDemo(){
        System.out.println(Thread.currentThread().getName() + "\t 我是构造方法 singletonDemo()");
    }
    //DCL模式（Double Check Lock双端检索机制）
    public static SingletonDemo getInstance(){
        if(instance== null){
            synchronized (SingletonDemo.class){
                if(instance== null){
instance= new SingletonDemo();
                }
            }
        }
        returninstance;
    }
}

CAS:

CAS应用：

AtomicInteger为什么用CAS而不是Sychronized？

Unsafe：

为什么用CAS而不用Sychronized？

CAS的缺点：

ABA问题：

原子引用更新：

public class AtomicReferenceDemo {
    public static void main(String[] args) {
        User z3 = new User("z3",22);
        User l4 = new User("l4",25);
        AtomicReference<User> atomicReference = new AtomicReference<>();
        atomicReference.set(z3);
        System.out.println(atomicReference.compareAndSet(z3, l4) + "\t" + atomicReference.get().toString());
        System.out.println(atomicReference.compareAndSet(z3, l4) + "\t" + atomicReference.get().toString());
    }
}
@Data
@ToString
@AllArgsConstructor
class User{
    String userName;
    int age;
}

如何规避ABA问题：

public class ABADemo {
    static AtomicReference<Integer>atomicReference= new AtomicReference<>(100);
    static AtomicStampedReference<Integer>atomicStampedReference= new AtomicStampedReference<>(100, 1);

    public static void main(String[] args) {
        System.out.println("=================ABA问题的产生");
        new Thread(() -> {
atomicReference.compareAndSet(100, 101);
atomicReference.compareAndSet(101, 100);
        }, "t1").start();

        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(atomicReference.compareAndSet(100, 2019) + "\t" +atomicReference.get().toString());

        }, "t2").start();
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("=================ABA问题的解决");
        new Thread(() -> {
            int stamp =atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + "\t 第一次版本号：" + stamp);
            // 暂停一秒钟
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
atomicStampedReference.compareAndSet(100, 101,atomicStampedReference.getStamp(),atomicStampedReference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + "\t 第二次版本号：" +atomicStampedReference.getStamp());
atomicStampedReference.compareAndSet(101, 100,atomicStampedReference.getStamp(),atomicStampedReference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + "\t 第三次版本号：" +atomicStampedReference.getStamp());
        }, "t3").start();

        new Thread(() -> {
            int stamp =atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + "\t 第一次版本号：" +  stamp);
            // 暂停一秒钟
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            boolean b =atomicStampedReference.compareAndSet(100, 101, stamp, stamp + 1);
            System.out.println(Thread.currentThread().getName() + "\t 修改成功否" + b);
        }, "t4").start();
    }
}

我们知道ArrayList是线程不安全，请编码写一个不安全的案例并给出解决方案：

public class ContainerNotSafeDemo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        for (int i = 1; i <=30 ; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,8));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
        //java.util.ConcurrentModificationException
    }
}

public boolean add(E e) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        newElements[len] = e;
        setArray(newElements);
        return true;
    } finally {
        lock.unlock();
    }
}

Hashset是不是线程安全的：

Hashset底层是什么：

public HashSet() {
    map = new HashMap<>();
}

public boolean add(E e) {
    return map.put(e,PRESENT)==null;
}

hashMap和ConcurrentHashMAp<>()底层源码有什么不同

栈管运行，堆管存储

公平锁/非公平锁/可重入锁/递归锁/自旋锁 谈谈你的理解？

手写一个自旋锁

public class SpinLockDemo {
    // 原子引用线程
    AtomicReference<Thread> atomicReference = new AtomicReference<>();
    public void myLock() {
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName() + "\t come in ");
        while (!atomicReference.compareAndSet(null, thread)) {
            System.out.println(Thread.currentThread().getName() + "进行比较");
        }
        System.out.println(Thread.currentThread().getName() + "加锁");
    }
    public void myUnlock(){
        Thread thread = Thread.currentThread();
        atomicReference.compareAndSet(thread,null);
        System.out.println(Thread.currentThread().getName() + "解锁");
    }
    public static void main(String[] args) {
        SpinLockDemo spinLockDemo = new SpinLockDemo();
        new Thread(()->{
            spinLockDemo.myLock();
            try {TimeUnit.SECONDS.sleep(5);} catch (InterruptedException e) {throw new RuntimeException(e);}
            spinLockDemo.myUnlock();
        },"AA").start();
        try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {throw new RuntimeException(e);}
        new Thread(()->{
            spinLockDemo.myLock();
            try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {throw new RuntimeException(e);}
            spinLockDemo.myUnlock();
        },"BB").start();

    }
}

公平锁和非公平锁

可重入锁（又叫递归锁）

自旋锁

独占锁（写锁）/共享锁（读锁）/互斥锁

class MyCache{
    private volatile Map<String,Object> map = new HashMap<>();
    private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    //private Lock lock = new ReentrantLock();
    // 写缓存三个操作，写、读、清空
    public void put(String key,Object value){
        rwLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t 正在写入" + key);
            try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {throw new RuntimeException(e);}
            map.put(key,value);
            System.out.println(Thread.currentThread().getName() + "\t 写入完成" + key);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            rwLock.writeLock().unlock();
        }
    }
    public void get(String key){
        rwLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t 正在读取" );
            try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {throw new RuntimeException(e);}
            Object result = map.get(key);
            System.out.println(Thread.currentThread().getName() + "\t 读取完成:" +result);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            rwLock.readLock().unlock();
        }
    }
}

public class ReadWriteLockDemo {
/**
     *读写锁demo
     *读锁的共享锁可保证并发读诗非常高效的，读写，写读，写写的过程是互斥的。
* */
public static void main(String[] args) {
        MyCache myCache =new MyCache();
        for (int i = 1; i < 5; i++) {
            final int tempInt = i;
            new Thread(()->{
                myCache.put(tempInt+ "",tempInt + "");
            },String.valueOf(i)).start();
        }
        for (int i = 1; i < 5; i++) {
            final int tempInt = i;
            new Thread(()->{
                myCache.get(tempInt+"");
            },String.valueOf(i)).start();
        }
    }
}

CountDownLatch/CyclicBarrier/Semaphore使用过吗

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch count = new CountDownLatch(6);
        for (int i = 1; i <=6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName() + "\t 上晚自习，离开教室");
                count.countDown();
            },String.valueOf(i)).start();
        }
        count.await();
        System.out.println(Thread.currentThread().getName() + "\t ****** 班长最后关门走人");
    }
}

阻塞队列知道吗：

为什么需要BlockingQueue

BlockingQueue：

public class SynchronousQueueDemo {
    public static void main(String[] args) {
        BlockingQueue<String> blockingQueue = new SynchronousQueue<>();

        new Thread(()->{
            try {
                System.out.println(Thread.currentThread().getName() + "\t put 1");
                blockingQueue.put("1");
                System.out.println(Thread.currentThread().getName() + "\t put 2");
                blockingQueue.put("2");
                System.out.println(Thread.currentThread().getName() + "\t put 3");
                blockingQueue.put("3");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        },"AA").start();
        new Thread(()->{
            try {
                try {TimeUnit.SECONDS.sleep(5);} catch (InterruptedException e) {throw new RuntimeException(e);}
                System.out.println(Thread.currentThread().getName() + "\t" + blockingQueue.take());
                try {TimeUnit.SECONDS.sleep(5);} catch (InterruptedException e) {throw new RuntimeException(e);}
                System.out.println(Thread.currentThread().getName() + "\t" + blockingQueue.take());
                try {TimeUnit.SECONDS.sleep(5);} catch (InterruptedException e) {throw new RuntimeException(e);}
                System.out.println(Thread.currentThread().getName() + "\t" + blockingQueue.take());
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        },"BB").start();
    }
}

阻塞队列有没有好的一面

不得不阻塞，如何管理

生产者消费者模式：

class ShareData{
    //资源类
    private int number = 0;
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    public void increment() throws Exception{
        lock.lock();
        try {
            //1、 判断
            while (number!= 0){
                // 等待，不能生产
                condition.await();
            }
            //2、干活
            number++;
            System.out.println(Thread.currentThread().getName()+ "\t" + number);
            //3、通知唤醒
            condition.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void decrement() throws Exception{
        lock.lock();
        try {
            //1、 判断
            while (number== 0){
                // 等待，不能生产
                condition.await();
            }
            //2、干活
            number--;
            System.out.println(Thread.currentThread().getName()+ "\t" + number);
            //3、通知唤醒
            condition.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }


}
public class ProdConsumer_TraditionDemo {
/**
     *题目：一个初始值为0的变量，两个线程对其交替操作，一个加1，一个减1，来5轮。
*
     * 1、线程  操作  资源类
* 2、判断  干活  通知
* 3、防止虚假唤醒机制
*
     * */
public static void main(String[] args) {
        ShareData shareData =new ShareData();
        new Thread(()->{
            for (int i = 1; i <= 5; i++) {
                try {
                    shareData.increment();
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        },"AA").start();
        new Thread(()->{
            for (int i = 1; i <= 5; i++) {
                try {
                    shareData.decrement();
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        },"BB").start();
    }
}

Sychronized和Lock有什么区别？

线程池：

阻塞队列的作用是什么：

使用无界阻塞队列会出现什么问题：

线程池的7大参数：

生产上如何配置合理参数：

谈谈线程池的拒绝策略：

工作中如何使用线程池，是否自定义过线程池：

ExecutorService threadPool = new ThreadPoolExecutor(2,
        5,
        1L,
        TimeUnit.SECONDS,
        new LinkedBlockingDeque<>(3),
        Executors.defaultThreadFactory(),
        new ThreadPoolExecutor.CallerRunsPolicy());

合理配置线程池你是如何考虑的：

死锁编码及定位分析：

产生死锁的主要原因：

JVM

常见的垃圾回收算法：

1、JVM垃圾回收的时候如何确定垃圾？是否知道什么是GC Roots？

2、你说你做过JVM调优和参数配置，请问如何盘点查看JVM系统默认值

• Boolean类型：公式：-XX:+ 或者 - 某个属性值 + 表示开启 - 表示关闭

• kv设置类型：公式：属性key=属性值value

• 两个经典参数：-Xms 和 -Xmx

• 查看JVM默认值

3、你平时工作用过的JVM常用的基本参数有哪些

4、强引用、软引用、弱引用、虚引用分别是什么？

5、请谈谈你对OOM的认识

6、GC垃圾回收算法和垃圾收集器的关系？分别是什么请你谈谈？

7、怎么查看服务器默认的垃圾回收器是哪个？生产上如何配置垃圾回收器的？谈谈你对垃圾收集器的理解？

8、G1垃圾收集器

9、生产环境服务器变慢，诊断思路和氢能评估谈谈？

10、假如生产环境出现CPU占用过高，请你谈谈你的分析思路定位

11、GCRoot如何确定的，哪些对象可以作为GCRoot

12、GCRoot如何分代的？没代用什么算法回收