synchronized 发生异常会释放锁
不能拿 String、Integer、Long 等基础类型做锁
synchronized 和 Lock 能保证同一时刻只有一个线程获取锁然后执行同步代码，并且在释放锁之前会将对变量的修改刷新到主存当中。因此可以保证可见性。但是同步块里的非原子操作依旧可能发生指令重排

1. ThreadPoolExecutor

线程数计算公式： 线程数 = CPU 核数 * 期望 CPU 使用率 0~1_ *_（1 + 等待时间 / 计算时间）

1.1. 七大参数

1
2
3
4

ThreadPoolExecutor tpe = new ThreadPoolExecutor(2, 4, 60, TimeUnit.SECONDS, 
                                                new ArrayBlockingQueue<>(4), 
                                                Executors.defaultThreadFactory(),
                                                new ThreadPoolExecutor.CallerRunsPolicy());

• corePoolSize：核心线程数。保留在线程池中的线程数，即使它们处于空闲状态，除非设置了 allowCoreThreadTimeOut。
• maximumPoolSize：最大线程数。线程池中允许的最大线程数，在阻塞队列满了之后加入的任务会创建非核心线程进行处理。
• keepAliveTime：当线程数大于 corePoolSize 时，非核心线程在终止之前等待新任务的最大时间。
• unit：keepAliveTime 参数的时间单位。
• workQueue：阻塞队列。在执行任务之前用于保存任务的队列。 这个队列将只保存 execute 方法提交的 Runnable 任务。提交的线程后若发现线程总数超过 corePoolSize 但是不超过 keepAliveTime 的情况下。
• threadFactory：用来执行的时候创建线程的线程工厂，可用于线程命名。
• handler：在执行被阻塞时使用的处理程序，因为达到了线程边界和队列容量。
  • AbortPolicy：直接抛出异常，这是默认策略。
  • CallerRunsPolicy：用调用者所在的线程来执行任务。
  • DiscardOldestPolicy：丢弃阻塞队列中靠最前的任务，并执行当前任务。
  • DiscardPolicy：直接丢弃任务。

1. 创建线程

继承 Thread 类

1
2
3
4
5
6
7
8
9
10
11
12
13

public class SubThread extends Thread {
    //重写 run（）方法
    public void run() {
        //输出...
    }
}
public class TestThread {
     public static void main(String[] args) {
          SubThread st = new SubThread();
          //调用start（）方法运行线程
          st.start();
     }
}

实现 Runnable 接口

1
2
3
4
5
6
7
8
9
10
11
12

public class PrintNum1 implements Runnable {
     public void run() {
          ...
     }
}
public class TestThread1 {
     public static void main(String[] args) {
          PrintNum1 p = new PrintNum1();
          Thread t1 = new Thread(p);
          t1.start();
     }
}

实现 Callable 接口
与 Runnable 相比，Callable 可以有返回值，返回值通过 FutureTask 进行封装

1
2
3
4
5
6
7
8
9
10
11
12

public class MyCallable implements Callable<Integer> {
    public Integer call() {
        return 123;
    }
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
    MyCallable mc = new MyCallable();
    FutureTask<Integer> ft = new FutureTask<>(mc);
    Thread thread = new Thread(ft);
    thread.start();
    System.out.println(ft.get());
}

栈设置

• -Xss: 栈大小

堆设置

• -Xms: 初始堆大小
• -Xmx: 最大堆大小
• -Xmn: 新生代大小
• -XX:NewSize=n: 设置年轻代大小
• -XX:NewRatio=n: 设置年轻代和年老代的比值。如：为 3，表示年轻代与年老代比值为 1：3，年轻代占整个年轻代年老代和的 1/4
• -XX:SurvivorRatio=n: 年轻代中 Eden 区与两个 Survivor 区的比值。注意 Survivor 区有两个。
  • 如：3，表示 Eden：Survivor=3：2，一个 Survivor 区占整个年轻代的 1/5
• -XX:PretenureSizeThreshold: 大于此值的对象直接在老年代分配
• -XX:MaxTenuringThreshold: 定义年龄的阈值。在 Eden 中的对象经过 Minor GC 依然存活，将移动到 Survivor 中，年龄增加 1 岁，超过该年龄阈值将进入老年代

1. jps（Java Virtual Machine Process Status Tool）

作用： 用来输出 JVM 中运行的进程状态信息
指令： jps [options] [hostid]

• -q 不输出类名、Jar 名和传入 main 方法的参数
• -m 输出传入 main 方法的参数
• -l 输出 main 类或 Jar 的全限名
• -v 输出传入 JVM 的参数

类是在 ** 运行期间第一次使用 ** 时动态加载的，而不是编译时期一次性加载。因为如果在编译时期一次性加载，那么会占用很多的内存

1. 类的生命周期

包括以下 7 个阶段：

• 加载（Loading）
• 验证（Verification）
• 准备（Preparation）
• 解析（Resolution）
• 初始化（Initialization）
• 使用（Using）
• 卸载（Unloading）

GC 日志

PS GC 日志详解

PS 日志格式：

heap dump 部分：

1
2

eden space 5632K, 94% used [0x00000000ff980000,0x00000000ffeb3e28,0x00000000fff00000)
                            后面的内存地址指的是，起始地址，使用空间结束地址，整体空间结束地址

深入学习 JVM-JVM 安全点和安全区域
垃圾收集主要是针对 堆 和 方法区 进行
程序计数器、虚拟机栈和本地方法栈这三个区域属于线程私有的，只存在于线程的生命周期内，线程结束之后也会消失，因此不需要对这三个区域进行垃圾回收

简历：熟悉 GC 常用算法，熟悉常见垃圾回收器，具有实际 JVM 调优实战经验

JVM 组成

JVM 的结构基本上由 4 部分组成：

• _类加载器：_在 JVM 启动时或者类运行时将需要的 class 加载到 JVM 中
• _运行时数据区：_将内存划分成若干个区以模拟实际机器上的存储、记录和调度功能模块
• 执行引擎：执行引擎的任务是负责执行 class 文件中包含的字节码指令，相当于实际机器上的 CPU
• 本地方法调用：调用 C 或 C++ 实现的本地方法的代码返回结果

强引用

被强引用关联的对象不会被回收。

1

Object obj = new Object();

软引用

被软引用关联的对象只有在内存不够的情况下才会被回收。
作用： 缓存

1
2
3

Object obj = new Object();
SoftReference<Object> sf = new SoftReference<Object>(obj);
obj = null;  // 使对象只被软引用关联

// ===== 软引用测试（-Xms:20M -Xmx20M） =====

SoftReference<byte[]> m = new SoftReference<>(new byte[1024102410]);
System.out.println(m.get());

// 再分配一个数组，heap 将装不下，这时候系统会垃圾回收，先回收一次，如果不够，会把软引用干掉
byte[] b = new byte[1024102415];
System.out.println(m.get()); // null