java基础

概念

优缺点

应用场景

概念

优缺点

应用场景

概念

优缺点

应用场景

IO多路复用概述

IO多路复用实现方式

java-NIO

信号驱动式I/O是指进程预先告知内核，使得当某个描述符上发生某事时，内核使用信号通知相关进程。
  异步I/O是进程执行I/O系统调用（读或写）告知内核启动某个I/O操作，内核启动I/O操作后立刻返回到进程，进程在I/O操作发生期间继续执行，当操作完成或遭遇错误时，内核以进程在I/O系统调用中指定的某种方式通知进程，

概念

区别

概念

区别

读取和写入文件IO操作都是调用操作系统提供的接口；应用程序要访问磁盘必须要通过操作系统的调用才行；

1.标准访问文件方式

2.直接IO

3.同步访问文件方式

4.异步访问文件的方式

5.内存映射的方式

网络传输

磁盘读取

网络io优化

磁盘io优化

阻塞队列也是一种先进先出的队列

在并发包下

线程安全队列

带有阻塞功能

如果队列满，继续入队列时，入队列操作就会阻塞，直到队列不满才能完成入队列

如果队列空，继续出队列时，出队列操作就会阻塞，直到队列不空才能完成出队列

生产者消费者模型

1.对队列中元素的操作，都是基于 入列，出列这两个基本的方法

2.都会提供添加，取出的阻塞方法。

3.是否包含这个方法的实现都是通过遍历去比较的方式实现

4.toStirng的实现都是遍历，StringBuilder来实现的

5.clear的实现，都是遍历，为每个元素复制为null

6.都会引入迭代器作为内部类类实现一些功能

7.构造方法都可以传递一个集合来变成队列

LinkedBlockingDeque

SynchronousQueue

DelayQueue

PriorityBlockingQueue

LinkedBlockingQueue

TransferQueue

LinkedTransferQueue

阻塞队列继承实现关系图

阻塞队列概览

双端队列的父接口，BlockingDeque接口也是实现了BlockingQueue接口的，所以双端队列也是阻塞队列的一种。所以也能在存取的时候进行阻塞

主要就是定义：“取出元素”，“放入元素”是可以给定时间进行延迟的

并发的链表；

如果插入元素的时候，链表不为空，那么新添加进来的元素就会作为尾节点，而且就是如果该元素是第二个被加进来的元素，其实也是一样的，把新添加的元素替代第一个元素作为尾节点。

链表的每个节点在存储的时候，会存储自己的节点也会存储他的下一个节点

其实可以看做是一个能够排序的单列集合类，可以支持各种排序。其实本质就是一个方便排序的单列集合类。适用于排序场景下

如果不在比较器中实现排序的规则，那么就是默认排序的规则，也就是升序

利用cas命令实现的一个工具类。适用的场景是双列集合的排序操作。如果不指明排序的规则，就是自然排序，就是升序排序

也是针对集合做过滤，添加，删除的集合工具类，是利用CopyOnWriteArrayList 来实现的。添加删除的时候还是需要去创建一个新的数组来实现这个

主要就是对List集合的添加删除的工具类，实现还是使用的数组来实现，添加删除的时候还是使用lock锁来锁，每个添加删除都会创建一个新的数组来接受原来的数据

ArrayDeque

LinkedList

ConcurrentLinkedDeque

LinkedBlockingDeque

ConcurrentHashMap  （使用场景，修改多，读取多） ConcurrentSkipListMap ConcurrentSkipListMap CopyOnWriteArrayList （使用场景，迭代多，修改少） CopyOnWriteArraySet（使用场景，迭代多，修改少）

HashTable

Vector

Collections.synchronizedList(list)、（使用场景，修改多，读取多） Collections.synchronizedSet(set)、（使用场景，修改多，读取多） Collections.synchronizedMap(map)（使用场景，修改多，读取多）

BlockingQueue接口下的类：
LinkedBlockingQueue
ArrayBlockingQueue
PriorityBlockingQueue   
SynchronizedQueue     

ArrayDeque: LinkedBlockingDeque:

ConcurrentLinkedQueue     
ConcurrentLinkedDeque    

ConcurrentHashMap

ConcurrentSkipListMap

ConcurrentSkipListSet

拷贝集合

网络之间传输数据，做持久化；

1.实现序列化后，可以把这个对象可以从一个虚拟机传递到另外一个虚拟机上（序列化就是将类的字段和他当前对应的字段值以序列化的格式生成一个数据流（这个数据流的格式不是字节码），这个数据流持久化到硬盘上）

jdk自带Serializable

json序列化

xml序列化

message pack

Protocol Buffers

Marshalling

IncompatibleClassChangeError

AbstractMethodError.

NoSuchFieldError

IllegalAccessError

InstantiationError

VirtualMachineError

OutOfMemoryError

ZipError

InternalError

StackOverflowError

UnknownError

LinkageError

VerifyError

ClassCircularityError

ExceptionInInitializerError

UnsatisfiedLinkError

ClassFormatError

UnsupportedClassVersionError

BootstrapMethodError

ExceptionInInitializerError

NoClassDefFoundError

sleep

yield

currentThread

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

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

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

start()

run()

getPriority()和setPriority(int newPriority)

interrupt()

join()

示意图

NEW

RUNNABLE

BLOCKED

WAITING

TIMED_WAITING

TEMINATED

继承Thread类，重写run方法

实现runnable接口，重写run方法

线程池类

抢占式

协同式

线程相当于于一个轻量级进程，一个轻量级进程对应一个内核

线程的切换调度完全依赖内核

用户实现对线程的创建消耗，和内核没有关系

线程和进程的比例为1：n

轻量级进程是线程和内核之间沟通的桥梁

线程创建消耗会是由用户来控制

也就是被final修饰的字段或者对象，他们都是不可变，即使是通过被他们修饰的字段或者对象引申出其他的字段或者对象，原来的字段，对象还是不变的，只是新返回去了一个字段或者是对象。这类情况，保证字段和对象的绝对不会变化。

线程绝对安全，指的是一些类中所有的字段和方法都添加了同步的synchronized来进行修饰；

我们在单个调用这些类的某个方法的时候，这个时候线程是安全的，但是如果我们在一个类中使用了这个类的多个所谓线程安全的方法的时候，就很可能导致线程不安全。在很多条件下是无法将这多个所谓的线程安全的方法都同一起来让他们变得线程安全。我们需要通过额外的方法添加同步修饰来确保线程安全。

相对线程安全，就是我们传统意义上的线程安全。

就是对某个对象单独的操作是线程安全的。调用的时候不需要额外的添加保障措施。

这段代码本身不是线程安全的，但是可以通过调用添加同步的方式来保证这个段代码的执行时线程安全的。

无论调用端是否采用了同步措施，都无法在多线程环境下使用并发的代码。就是那些中断线程suspend()，恢复线程resume()的方法，不管怎样，调用了就会存在死锁风险，这两个方法已经被弃用了。类似的还用System类的setIn(),setOut(),runFinalieersOnExit()这类方法。都是线程对立的。

互斥同步（阻塞同步，可以理解为：悲观锁）

具体实现

子主题

newFixedThreadPool

newWorkStealingPool

newCachedThreadPool

newSingleThreadScheduledExecutor

newScheduledThreadPool

newSingleThreadExecutor

使用ForkJoinPool 可以将数据计算分配到多个cpu上进行计算。

和其他线程类一样，就是将任务都放入线程池类种， 该类是的入参是ForkJoinTask 的子类，有返回值的是RecursiveTask，没有返回值的是RecursiveAction。   工作窃取算法，就是一个线程对应一个双端队列，一个线程一个使用双端队列，将任务放在双端队列中，一个线程从另外一个任务的队列的末尾取出任务。 并发包也提供了，开多个线程跑任务的方式

除非创建线程池后，调用了prestartAllCoreThreads()，prestartCoreThread()，也就是创建线程池后会创建核心线程数量

阻塞队列中传递Runnable

线程工厂，主要用来创建线程；

AbortPolicy

DiscardPolicy

CallerRunsPolicy

DiscardOldestPolicy

自定义

表示当拒绝处理任务时的策略

RUNNING

SHUTDOWN

STOP

TIDYING

TERMINATED

示意图

计算公式

计算公式说明

实际过程中线程数量

计算公式

计算公式说明

计算demo

实际过程中线程数量

同一个时刻，允许访问资源的线程是有限的

实现都是通过AQS,来实现的，共享锁和独占锁的区别就是，资源在同一个时刻能否被多个线程所共享。

AQS实现共享锁的原理，就是：当队列中的一个线程获取到了这个共享锁，那么这个线程将唤醒和他一起共享当前锁资源的其他线程节点。 这种是实现闭锁，栅栏，信号量，读锁的基础类

和闭锁，栅栏的功能类似，但是比闭锁，栅栏的功能更加强大，可以支持等待其他线程，也可以不等待其他线程

阻塞唤醒的实现还是基于 LockSupport的，在java这层实现最底层还是Unsfae

作用

CountDownLantch使用要点

使用demo

特点

CyclicBarrier使用的要点

CyclicBarrier使用demo

默认 的是非公平的获取执行许可，非公平比公平的情况，效率会更高； 我们也可以在构造的时候设置这个是否是公平的。

对信号量的占用可以设置占用时间，底层还是通过AQS来实现的，信号量过多的时候，被阻塞，其实也就是在AQS中被迫的休眠了。等释放一个信号量的时候，就会唤醒一个线程（默认非公平，可以设置公平）

读写锁

锁降级

不可升级

对读写锁的一种优化，避免写锁一直被阻塞

当读线程执行的时候，如果有些线程在操作，那么读线程如果发现了数据不对，就会再执行一次读。避免了读写线程之间的相互阻塞，但是写和写线程之间还是阻塞的

该类的方法都是静态方法，直接使用类名来调用。用来阻塞线程的。park阻塞线程，unpark，解除阻塞。可以用用来让线程阻塞，阻塞多久

是让其他线程来唤醒这个线程。以下方法是在参数中传递一个需要被唤醒的那个线程的名称。

Condition和Object唤醒，休眠的区别

AtomicIntegerArray，int数组
AtomicLongArray，long数组
AtomicReference，对象
AtomicReferenceArray，数组对象

AtomicStampedReference 维护对象引用以及可以原子更新的标记位。 AtomicMarkableReference 维护对象引用以及整数“印记”，可以原子更新

AtomicLongFieldUpdater  对指定类的的指定Integer类型字段（字段必须是volatile修饰）进行原子操作的托管。 AtomicIntegerFieldUpdater 对指定类的指定的Long类型字段（字段必须是volatile修饰的）进行原子操作的托管。 AtomicReferenceFieldUpdater 对指定类中的某个字段（字段必须是volatile修饰）进行原子操作托管。

DoubleAccumulator LongAccumulator 同时托管多个数据，对这些数据进行原子性求和 DoubleAdder LongAdder 同时托管多个数据，这几个数据的初始化和值为0。对这些进行求和

使用场景

问题：

AtomicInteger原子性的原理

自增

这个两个类区别就是，AbstractQueuedSynchronizer 这个主要是针对int类型的数据操作的，
AbstractQueuedLongSynchronizer 是针对int 数据类型的做操作的

就是将线程放入队列当中，去维护线程的状态。根据线程的状态去调用这个原子操作的方法。其实还是一利用队列进行分流的思想。

调用Unsafe 类的比较与交换方法是否能执行成功；成功，加锁；不成功，加锁失败

加锁操作过程

释放锁，如果持有锁的线程刚好就是当前线程，那么就可以释放锁

解锁操作过程

1.初始化状态，如果传入的状态值和初始化状态值不一样，那么就不能执行比较与交换的方法；

2.需要有一个队列能够保存被阻塞在锁的线程

3.持有锁的线程是哪个；

子主题

1.使用lockSupport的park,unpark lockSupport调用的也是Unsafe 类的park,unpark本地方法

并发的链表；

如果插入元素的时候，链表不为空，那么新添加进来的元素就会作为尾节点，而且就是如果该元素是第二个被加进来的元素，其实也是一样的，把新添加的元素替代第一个元素作为尾节点。

链表的每个节点在存储的时候，会存储自己的节点也会存储他的下一个节点

其实可以看做是一个能够排序的单列集合类，可以支持各种排序。其实本质就是一个方便排序的单列集合类。适用于排序场景下

如果不在比较器中实现排序的规则，那么就是默认排序的规则，也就是升序

利用cas命令实现的一个工具类。适用的场景是双列集合的排序操作。如果不指明排序的规则，就是自然排序，就是升序排序

也是针对集合做过滤，添加，删除的集合工具类，是利用CopyOnWriteArrayList 来实现的。添加删除的时候还是需要去创建一个新的数组来实现这个

主要就是对List集合的添加删除的工具类，实现还是使用的数组来实现，添加删除的时候还是使用lock锁来锁，每个添加删除都会创建一个新的数组来接受原来的数据

BlockingDeque

阻塞队列特点

阻塞队列具体实现

双端，意味着从头节点开始查找也行，从尾节点查找也行。

ClassFile {
u4 magic;                                                                               //模数
u2 minor_version;                                                             //次版本号
u2 major_version;                                                             //主版本号
u2 constant_pool_count;                                                 //常量池大小
cp_info constant_pool[constant_pool_count-1];    //常量池
u2 access_flags;                                                                   //类和接口层次的访问标志（通过|运算得到）
u2 this_class;                                                                        //类索引（指向常量池中的类常量）
u2 super_class;                                                                   //父类索引（指向常量池中的类常量）
u2 interfaces_count;                                                         //接口索引计数器
u2 interfaces[interfaces_count];                                  //接口索引集合
u2 fields_count;                                                                  //字段数量计数器
field_info fields[fields_count];                                      //字段表集合
u2 methods_count;                                                           //方法数量计数器
method_info methods[methods_count];                  //方法表集合
u2 attributes_count;                                                          //属性个数
attribute_info attributes[attributes_count];             //属性表
}

所以此时，这个compareTo(Object o)这个方法应该写在这个Object对象中，才能使对象调用compareTo(Object o)去比较的是相同属性的对象。

Comaprator接口的compare(Object  o1, Object o2);方法传递的是两个对象，两个拥有相同属性的对象，所以这里就不存在和上面

Comparable接口中的比较方法的问题。这里只需要新建立一个比较的算法类去实现compare(Object o1,Object 02);这个方法就行了。

ConcurrentHashMap

HashMap

LinkedHashMap

SkipList

LinkedList，ArrayList

Stack

TreeSet

HashSet

Vector

Copy集合

当一个线程在修改某个值得时候，从取值到写入值之间没有其他线程对这个值进行操作。可以通过锁机制或者CAS机制（后期再做解释）

单例设计模式，其实就是为了在一个域中只有一个该类的对象，节约内存空间，方法对对象进行统一管理；

一种饿汉式，一种懒汉式，区别在于，饿汉式在该类被加载的时候就创建了该类的对象；懒汉式，是需要用到的时候才会去创建这个类的对象；在不主动使用同步的情况下， 因为类只会被加载一次，所以饿汉式也只会创建一次这个类的对象；而懒汉式，就有可能在同时判断为null的时候去创建这个类的对象；

1.将构造方法私有化； 2.提供一个对外的静态获取该类对象的方法，

饿汉式

懒汉式

把一个类对象的构造过程交给一个专门构建对象的类去处理

实现

特点

缺点

实现 

动态代理的两种方式对比

1.静态代理是静态编译，动态代理是动态编译

2.静态代理，只能代理一个类；动态代理，可以代理多个

中介作用

增加了可扩展性

对原有的对象代码无侵入性

享元模式其实就是为了最大程度的降低内存的消耗，而设计的，最大程度上减少对象的创建，

最底层的实现类可以比他继承的接口，父类获取到更多的可以执行的方法。并且装饰类在实现接口功能的时候，可以借用相同接口下另外一个类的的实现来实现这个接口；

1.装饰者和被装饰者都必须要实现同一个接口；

2.被装饰者的有参构造器的参数必须是这个顶层接口这个类，这样因为装饰者实现了这个顶层接口，那么传入装饰者作为这个有参构造的话，就可以拿到被装饰者的对象，从而使用被装饰者的方法。

编译后生成了加锁，解锁指令

jvm调用了操作系统提供的同步方法；

操作系统本身有一些同步的操作

Synchronized 锁升级过程

锁状态转换过程

锁状态

编译器发现某段代码有连续的加锁解锁操作就会进行锁粗化，将连续的加锁解锁变成一个加锁解锁，提高代码执行效率；

编译器发现某段代码不存在多线程竞争共享资源，编译之后就会把锁消除掉，减少加锁解锁的性能消耗

锁优化，都是针对锁的优化技术，都是为了在线程之间能够高效的共享数据，解决竞争问题。

给字段加上了ACC_volatile标记

编译后给该字段加上读写屏障

翻译成对应的汇编指令，然后给读写加锁

公平锁是指多个线程按照申请锁的顺序来获取锁

非公平锁是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁。有可能，会造成优先级反转或者饥饿现象

Synchronized 非公平锁； ReentrantLock 默认也是非公平锁，可以设置成公平锁

可重入锁又名递归锁，是指在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。说的有点抽象，下面会有一个代码的示例

Synchronized ； ReentrantLock 都是可重入锁；

独享锁是指该锁一次只能被一个线程所持有。共享锁是指该锁可被多个线程所持有。

Synchronized ； ReentrantLock 独占锁；ReadWriteLock 读操作是共享锁，写操作是独占锁；

互斥锁

读写锁

从并发角度来给锁分类

悲观锁

乐观锁

锁的一种设计理念

ConcurrentHashMap 就是这种设计理念

偏向锁

轻量级锁

概述

为何需要自选

自旋锁本身是避免了线程之间切换的开销，这个和阻塞还是有区别的。我们可以设置根据获取锁的等待的自旋的次数，合理的调节等待的时间，如果自旋次数晚完了，还没有获取到锁对象，那么就会将线程挂起。

1.6的jdk中加入了自适应的自旋锁，自旋的时间不再是固定了，是由之前自旋在这个锁上的时间，以及锁的拥有者的状态来决定的。就是有一个不断修正自旋时间的过程。

interface IMyInterface {
    public void test0();
}

interface IMyInterface {
    public static void test1 () {
        System.out.println("静态方法");
    }
    default void test2() { // 可以被实现类覆写
        System.out.println("默认方法");
    }
    public void test0();
}

interface IMyInterface {
    private void test() {
        System.out.println("接口中的私有方法");
    }
    public static void test1 () {
        System.out.println("静态方法");
    }
    default void test2() {
        System.out.println("默认方法");
    }
    public void test0();
}

1、jvm启动的需要加载整个jra包，导致不需要使用的类，模块也被加在到内存中，浪费不必要浪费的内存；

不同版本的类库交叉依赖；每个公共类可以被类路径下任何其他的公共类所访问到，会导致使用并不想开放的api；类路径可能重复等

降低启动所需要的内存，按需加载对应的包

简化类库，方便开发维护

模块化实际上就是包外面在包一层，来管理包。

可以在dos窗口，终端中进行编程

mac系统已经支持

引入轻量级的JSON API

新的货币api

具体解释

对应的demo

jdk8

jdk9

jdk8

jdk9

提高编码效率

所创建的集合都只能是做读取操作，无法做添加删除操作

List<Integer> list = Arrays.asList(11, 32, 44, 29, 52, 72, 82, 64, 4, 19);
list.stream().takeWhile(integer -> integer < 50).forEach(System.out::println);

List<Integer> list = Arrays.asList(11, 32, 44, 29, 52, 72, 82, 64, 4, 19);
list.stream().dropWhile(x -> x < 50).forEach(System.out::println);

Stream.ofNullable(null).forEach(System.out::println);

Stream.iterate(0, x -> x < 5, x -> x + 1).forEach(System.out::println);

Optional.ofNullable(list).stream().forEach(System.out::println);

jdk9中提出来，jdk10正式发布该新特性

替换了jdk7,8  Parallel Scavenge（新生代）+Parallel Old（老年代）

var str = "abc"; // 推断为 字符串类型 
var l = 10L; // 推断为long 类型 
var flag = true; // 推断为 boolean 类型 
var list = new ArrayList<String>(); // 推断为 ArrayList<String> 
var stream = list.stream(); // 推断为 Stream<String> 

但是不可以作为全局变量，还有参数，已经方法返回值

jdk9的时候单线程回收

减少不必要的内存消耗

class Main {
    public static void main(String[] args) {
        List<Integer> list=new ArrayList<Integer>(3);
        list.add(1);
        list.add(2);
        list.add(3);
        List<Integer> temp = List.copyOf(list);
    }
}

transferTo方法复制文件

IO流大家族添加Charset参数的方法

ByteArrayOutputStream新增toString方法

判断是否是空白字符串

去除首尾空白

lines()

Optional方法增强

transferTo()方法

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();
}

jvm参数

废弃 Nashorn js引擎，可以考虑使用GraalVM

废弃 pack200和unpack200，这是以前压缩jar包的工具

com.sun.awt.AWTUtilities、sum.misc.Unsafe.defineClass(被java.lang.invoke.MethodHandles.Lookup.defineClass替代)、Thread.destroy()、Thread.stop(Throwable)、sun.nio.disableSystemWideOverlappingFileLockCheck属性、sun.locale.formatasdefault属性、jdk.snmp模块、javafx模块、javaMissionControl等

JavaEE和CORBA模块

Java 层面的事件，如线程事件、锁事件，以及 Java 虚拟机内部的事件，如新建对象，垃圾回收和即时编译事件

处理内存分配但不负责内存回收的垃圾回收器，堆内存用完，JVM即刻OOM退出

EpsilonGC使用场景

ZGC是一个并发、基于区域(region)、标记压缩算法的GC

特性

启用ZGC的方法：-XX:+UnlockExperimentalVMOptions -XX:+UseZGC

目前ZGC只能用于64位的linux操作系统下

其工作周期如下：
1）、初始标记，并启动并发标记阶段
2）、并发标记遍历堆阶段
3）、并发标记完成阶段
4）、并发整理回收无活动区域阶段
5）、并发疏散，整理内存区域
6）、初始化更新引用阶段
7）、并发更新引用
8）、完成引用更新阶段
9）、并发回收无引用区域阶段

demo

改进点

空闲时候G1回收器会自动将java堆内存返回给操作系统

G1 垃圾回收器的回收超过暂停目标，则能中止垃圾回收过程.

参数设置

ZGC在jdk11中引入的收集器，jdk13中使能了向OS提交未使用的堆内存

过程

Object obj = "kuaidi100";
if(obj instanceof String){
    String str = (String) obj;
}

Object obj = "kuaidi100";
if(obj instanceof String str){
    //直接使用str
}

if (obj instanceof String s) {
    // can use s here
} else {
    // can't use s here
}

MacOs windows 实现 ZGC

NUMA是啥?

这段话怎么理解

对飞行记录器功能升级

涉及的线程挂起Thread的方法已经在jdk14版本种废弃

security-libs / javax.crypto,已过时的旧椭圆曲线去除

默认的堆区域大小计算已更改为默认情况下返回较大的区域,计算仍以2048个区域为目标

两点改进

使用-XX:+UseZGC命
令行选项启用ZGC

一个低暂停时间的垃圾收集器

简化了编写 Java 程序的任务，同时避免了常见情况下的转义序列

增强 Java 程序中表示用非 Java 语言编写的代码的字符串的可读性。

二次优化

引入隐藏类，即不能被其他类的字节码直接使用的类

隐藏类旨在供在运行时生成类并通过反射间接使用它们的框架使用。隐藏类可以定义为访问控制嵌套的成员，并且可以独立于其他类卸载

使用密封的类和接口增强 Java 编程语言。密封的类和接口限制了哪些其他类或接口可以扩展或实现它们。

弹性的元空间

元空间中未使用的 class 元数据内存更及时地返回给操作系统，以减少元空间的内存占用空间

ZGC 支持并发栈处理

把 ZGC 中的线程栈处理从安全点移到了并发阶段

HotSpot 子系统可以通过该机制延迟处理线程栈

默认对内存的操作的api需要使用强封装的类来调用,提高系统的安全性

说明

在jdk15,16中是预览版本，17正式上线

demo

类 Student 被 sealed 修饰，说明它是一个密封类，并且只允许指定的 3 个子类继承

新的api Apple Metal 

老的api  Apple OpenGL

通过配置过滤器，通过一个 JVM 范围的过滤器工厂，用来为每个单独的反序列化操作选择一个过滤器。

老代码写法

新代码写法

直接在 switch 上支持 Object 类型，这就等于同时支持多种类型，简化代码

API 可以调用本地库和处理本地数据，与java环境之外的代码和数据交互

改进14,15引进的一些api

增强的 API 允许以一种在运行时，可靠地编译为支持的 CPU 架构上的最佳向量指令的方式表达向量计算