java基础

IO多路复用就是通过一个线程可以同事监视多个文件描述符（读就绪或者写接续，也就是可以监视多个IO操作），如果有一个描述符就绪，那么就可以通知程序做相应的读写操作；

本质上还是同步IO；相对于普通的同步IO,多路复用就可以让一个用户线程监视多个IO操作，普通的同步IO,一个用户线程只能只能监听一个IO操作

select

poll

epoll

NIO组件

NIO工作流程

用户线程调用内核IO操作，需要等IO彻底结束之后才能返回到用户空间，因此IO过程是阻塞的。

调用阻塞直到完成

优点

缺点

IO调用后，如果内核这个时候没有把数据准备好，那么就会直接返回一个状态，这个时候用户的IO线程就不会一直等待内核把数据准备好，而是间隔时间一段时间去轮询内核数据是否已经准备好了。最终是内核把数据准备好了，等待下一次用户线程的询问，就把数据从内核复制到用户内存中

优点

缺点

用户线程对内核发起了IO操作，用户线程没有任何组阻塞；内核准备好数据并复制到用户内存后，会给用户线程发送一个信号，表明数据IO操作已经完成了；

优点

缺点

一个线程做io操作，如果数据还没有准备好，线程是直接返回还是继续等待

阻塞，如果内核没有准备好数据，那么线程就会一直阻塞直到有数据返回为止；非阻塞，如果内核没有准备数据，那么就会直接返回，并且还会不断的去轮询内核是否有准备好数据；

用户线程发起io操作之后，要么阻塞，要么自己不断轮训数据是否准备好

用户线程发起io操作之后，立即返回，不用自己去轮训；io操作完成之后，内核会通知用户线程

子主题

外层是segment数组，每个segment对象都是一个ReentrantLock锁

读操作

写操作

当单个Segment元素的数量超过capacity * loadFactor 阈值的时候会进行单个Segment扩容

Node 数组 + 链表 + 红黑树

扩容条件

CAS + synchronized 来保证并发安全

读操作

写操作

元素总数 size ≥ 扩容阈值 threshold

1.7的锁粒度大，针对是每一个Segment，也就是桶数组（最大也就是16个并发度）

1.8的锁粒度小，并发度高，并发度取决于hash桶的数量

JDK 1.7
单个 Segment 元素数 > threshold
Segment 级别（局部扩容）
分段扩容，减少全表停顿，但可能空间利用率不均匀

JDK 1.8
全局 size >= capacity * loadFactor
整表扩容（协作迁移）
全局一致性更好，支持多线程并发迁移，避免长时间阻塞

1.8元素存储可以转换成红黑树，提高了，元素读取的效率；1.7是没有将链表转成红黑树的功能

因为 1.7 头插法扩容时，头插法会使链表发生反转，多线程环境下会产生环。

提高扩容效率

提高hash效率

外层

内层

存储过程

获取过程

外层

内层

存储

获取

1.7和1.8都存在的问题

在第一次put元素的时候创建的，也就是和懒加载机制很像

1.当前链表的长度大于8；

2.外层Hash桶的数组长度达到64个；

1.如果hash冲突严重，那么就会导致Hash槽下面的数据的链表长度过长；查询数据的复杂度就是0(n)，换成红黑树之后就变成了O(log)

扩容之后的hash槽计算？

什么情况下回触发扩容？

扩容之后的老数组中的数据怎么往新的数组里面迁移？

扩容因子为啥是0.75

代码截图

原因分析

1.如果key为null，那么hash值就是为1；

2.如果key不为null

static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);}public final int hashCode() { return Objects.hashCode(key) ^ Objects.hashCode(value);}

1.第一次put的时候，如果散列数组为空，那么就会进行扩容散列操作；

2.如果hash桶只要单个数据，那么先对比数据是否一样，一样就覆盖原来的值；

4.如果hash桶的数据是红黑树，如果key不重复，那么就把数据放在key的末尾；如果key重复了，那么就替代源码的value值；

3.如果hash桶的数据，是链表，如果key不重复，那么就把数据放在key的末尾；如果key重复了，那么就替代源码的value值；

capacity

loadFactor

当 size > threshold（capacity*loadFactor） 时，会触发 扩容

都是 size >= threshold

扩容倍数：Java 默认是 2 倍

新数组长度 = 旧数组长度 × 2

阈值也会相应调整 = 新容量 × loadFactor

jdk1.7

jdk1.8

monitorenter

monitorentexit

Synchronize 内部，有一个锁升级的过程；jdk1.6自动打开；1.jvm会偏向第一个执行的线程，给他加上偏向锁；

2.如果这个时候还有其他线程来竞争，这个偏向锁就会升级成轻量级锁，这轻量级锁，多数情况下是自旋锁;

3.如果并发程度高，这个自旋锁会自旋很多次，如果超过十次，还没有拿到锁对象，那么锁又会升级成重量级锁（悲观锁）；

线程第一次进入 synchronized 块时，JVM 会把 线程 ID 写入对象头 Mark Word

后续同一线程再进入时，只需检查 Mark Word 是否保存的是自己的线程 ID

线程竞争失败后，不立刻阻塞，而是 循环（自旋）一段时间，反复尝试获取锁：

一般情况：

优点：

缺点

示意图

无锁状态

偏向锁状态

轻量级锁状态

重量级锁状态

读操作

写操作

特点一个核心线程都没有

核心线程会一直存活，即使空闲。

当有新任务时，优先使用核心线程执行。

线程池能容纳的最大线程数。

当任务很多且队列满时，会启用非核心线程，直到达到最大值。

ArrayBlockingQueue

LinkedBlockingQueue

SynchronousQueue

丢弃任务并抛出RejectedExecutionException异常。
线程池默认的拒绝策略

丢弃任务，但是不抛出异常。
如果线程队列已满，则后续提交的任务都会被丢弃，且是静默丢弃。

由调用线程（提交任务的线程）处理该任务

该任务有提交这个任务的线程去执行。

自然运行状态

不接受新任务，执行已添加任务

不接受新任务，也不执行已添加任务

所有任务已终止，任务数量为0

线程彻底终止

示意图

NEW

RUNNABLE

BLOCKED

WAITING

TIMED_WAITING

TEMINATED

sleep

yield

currentThread

isAlive() 方法的功能是判断当前线程是否处于活动状态

getId() 方法的作用是取得线程的唯一标识

isDaeMon、setDaemon(boolean on) 方法，是否是守护线程，设置守护线程

start()

run()

getPriority()和setPriority(int newPriority)

interrupt()

join()

在终端开发中尤其明显

暂时无法理解这些

public class DiamondOperatorTest {
    public static void main(String[] args) {
        new DiamondOperatorTest().test();;
    }
 
    public void test() {
        Set<String> set = new HashSet<>(){
            @Override
            public boolean add(String s) {
                return super.add(s + "..");
            }
        };
 
 
        set.add("1");
        set.add("2");
        set.add("3");
        set.add("4");
 
 
        for (String s : set) {
            System.out.println(s);
        }
    }
}

对应结果

传统语句

优化后，jvm自动释放资源

一次性可以释放多个资源

底层是char 数组

底层是byte数组

只是做筛选，并不会修改list集合本身元素

只是做筛选，并不会修改list集合本身元素

类似下面代码

for (int i = 0; i < 5; i++) {
    System.out.println(i);
}

JDK10 给 InputStream 和 Reader 类中新增了 transferTo 方法

BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("a.txt")));
        long nums = reader.transferTo(new BufferedWriter(new OutputStreamWriter(new FileOutputStream("b.txt"))));
        System.out.println("一共复制的字节数量: "+nums);

JDK10给 ByteArrayOutputStream 新增重载 toString(Charset charset) 方法，通过指定的字符集编码字节，将缓冲区的内容转换为字符串

String s1 = "\t \n";
System.out.println(s1.isBlank()); // 判断是否为空白 true

s1 = "\t sss\n";
System.out.println(s1.trim().length()); // 去除首尾空白，不能去除全角空格
System.out.println(s1.strip().length()); // 去除首尾空白，可以去除全角空格
System.out.println(s1.stripLeading()); // 去除头部空白
System.out.println(s1.stripTrailing()); // 去除尾部空白

方法可以对字符串每一行进行流式处理

"asc\nccc\nwww".lines().map(str -> str.toUpperCase()).forEach(System.out::println);

System.out.println(Optional.ofNullable(null).orElse("b")); // 如果为空，返回"b"
System.out.println(Optional.ofNullable(null).orElseGet(() -> "b")); // 也可以使用函数式接口实现orElse()
System.out.println(Optional.ofNullable(null).orElseThrow()); // 如果为空，排除异常

try (var inputStream = new FileInputStream("D:/test.jar");
     var outputStream = new FileOutputStream("test2.jar")) {
    inputStream.transferTo(outputStream);
} catch (Exception e) {
    e.printStackTrace();
}

-XX:+AggressiveOpts、-XX:UnlockCommercialFeatures、-XX:+LogCommercialFeatures

性能测试（过滤GC引起的性能消耗，相当于控制变量）

内存压力测试（看看不回收的情况下，到底能不能消耗指定大小的内存）

执行非常短的任务（GC反而是浪费时间）

VM接口测试、延迟吞吐量的改进等实验性质的调优

不管堆内存多大，STW 时间不会超过10ms

public class Main {
    public static void main(String[] args) {
        Fruit f = Fruit.APPLE;
 
 
        switch (f) {
            case APPLE -> System.out.println(1);
            case ORANGE, GRAPE -> System.out.println(2);
            case PEAR, MANGO, WATERMALLON -> System.out.println(3);
            default ->
                System.out.println("No such fruit");
        }
    }
}
 
 
enum Fruit {
    APPLE, ORANGE, GRAPE, PEAR, MANGO, WATERMALLON
}

简化表达式

可以同时处理多个case

jdk12中的G1将在应用程序不活动期间定期生成或持续循环检测整体的java堆使用情况，以便更及时地将java堆中不使用的内存返回给OS。这一改进带来的优势在云平台的容器环境中更加明显，此时内存利用率的提高会直接降低经济成本

把回收集分为必须部分和可选部分，优先处理必须部分

必须部分主要包括G1不能递增处理的部分（如年轻代），也可以包含老年代以提高效率

优先处理必须部分时，会维护可选部分的一些数据，但产生的CPU开销不会超过1%，而且会增加本机内存使用率；处理完必须部分后，如果还有时间，就处理可选部分，如果剩下时间不够，就可能只处理可选部分的一个子集。处理完一个子集后，G1会根据剩余时间来决定是否继续收集

G1PeriodicGCInterval 

G1PeriodicGCSystemLoadThreshold

以上两个参数值都为0表示禁用此功能

G1PeriodicInvokesConcurrent

ZGC中的区域称之为ZPage，当ZGC压缩堆时，ZPage被释放，然后变成ZPageCache，最后使用LRU算法对PageCache区域进行定时清除。时间间隔默认为5分钟，用户自定义时间间隔尚未实现，而如果-Xms和-Xmx相等的话，这个功能就相当于没有

之前是不可以用于实时监控

jdk14之后可以实时获取到JVM的运行情况

Thread.suspend(),Thread.
resume(),ThreadGroup.suspend(),ThreadGroup.resume(),ThreadGroup.allowThreadSuspension(boolean)这些方法将在
将来的版本中删除。

仅考虑最大堆大小。旧的计算还考虑了初始堆大小，但是当未设置堆大小时，这可能会
产生意外的行为

区域大小四舍五入到最接近的2的幂，而不是减小。在最大堆大小不是2的幂的情况下，
这将返回更大的区域大小

不太懂ZGC回收过程?

不太懂ZGC回收过程?

好处是

Java 9中，我们通过利用模块来限制对JDK内部元素的访问，从而提高了JDK的安全性和可维护性。模块提供了强封装

强封装适用于编译时和运行时，包括已编译代码试图在运行时通过反射访问元素时。导出包的非公共元素和未导出包的所有元素都被称为是强封装的

public abstract sealed class Student
        permits NameChangeRecordService {

}

static String formatter(Object o) {
    String formatted = "unknown";
    if (o instanceof Integer i) {
        formatted = String.format("int %d", i);
    } else if (o instanceof Long l) {
        formatted = String.format("long %d", l);
    } else if (o instanceof Double d) {
        formatted = String.format("double %f", d);
    } else if (o instanceof String s) {
        formatted = String.format("String %s", s);
    }
    return formatted;
}

static String formatterPatternSwitch(Object o) {
    return switch (o) {
        case Integer i -> String.format("int %d", i);
        case Long l    -> String.format("long %d", l);
        case Double d  -> String.format("double %f", d);
        case String s  -> String.format("String %s", s);
        default        -> o.toString();
    };
}