Java高级知识

深藏阁楼爱情的钟 2023-05-21 08:42 7阅读 0赞

# 一.线程 #

### 1.线程 ###

**进程**：是代码在数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位。

**线程**：是进程的一个执行路径，一个进程中至少有一个线程，进程中的多个线程共享进程的 资源。

**1、继承Thread类**

重写run方法：使用继承方式的好处是，在run（）方法内获取当前线程直接使用this就可以了，无须使用Thread.currentThread（）方法；不好的地方是Java不支持多继承，如果继承了Thread类，那么就不能再继承其他类。另外任务与代码没有分离，当多个线程执行一样的任务时需要多份任务代码。

public class ThreadRuning extends Thread{
    
        public ThreadRuning(String name){  
    //重写构造，可以对线程添加名字
            super(name);
        }
        @Override
        public void run() {
            while(true){
                System.out.println("good time");
    //在run方法里，this代表当前线程
                System.out.println(this);
            }
        }
        public static void main(String[] args){
            ThreadRuning threadRuning = new ThreadRuning("1111");
            threadRuning.start();
        }
    }

**2、实现Runable接口**

实现run方法：解决继承Thread的缺点，没有返回值

public class RunableTest implements Runnable {
        @Override
        public void run() {
            while (true) {
                System.out.println("good time");
            }
        }
        public static void main(String[] args) {
            RunableTest runableTest1 = new RunableTest();
            RunableTest runableTest2 = new RunableTest();
            new Thread(runableTest1).start();
            new Thread(runableTest1).start();
            new Thread(runableTest2).start();
        }
    }

**3、实现Callable接口**

public class CallTest implements Callable {
        @Override
        public Object call() throws Exception {
            return "hello world";
        }
     
        public static void main(String[] args){
            FutureTask<String> futureTask = new FutureTask<String>(new CallTest());
            new Thread(futureTask).start();
            try {
                String result = futureTask.get();
                System.out.println(result);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    }

**线程的生命周期：**

**新建状态（New）：**当线程对象对创建后，即进入了新建状态，如：Thread thread1 = new MyThread();

**就绪状态（Runnable）：**当调用线程对象的start()方法\[ 如:thread1 .start(); \]，线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了thread1 .start()此线程立即就会执行；

**运行状态（Running）：**当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。注：就     绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中；

**阻塞状态（Blocked）：**处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才 有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同，阻塞状态又可以分为三种：

**1.等待阻塞：**运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；（wait()会释放持有的锁）

**2.同步阻塞 --** 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状**态；**

**3.其他阻塞 --** 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。（注意：sleep()是不会释放持有的锁）

**死亡状态（Dead）：**线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

**2.线程池**

1、线程池管理器（ThreadPool）：用于创建并管理线程池，包括 创建线程池，销毁线程池，添加新任务；  
2、工作线程（PoolWorker）：线程池中线程，在没有任务时处于等待状态，可以循环的执行任务；  
3、任务接口（Task）：每个任务必须实现的接口，以供工作线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等；  
4、任务队列（taskQueue）：用于存放没有处理的任务。提供一种缓冲机制。

*  减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
 *  可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因线程过多消耗内存，也避免了因线程过少，浪费系统资源。

**newSingleThreadExecutor**  
说明：初始化只有一个线程的线程池，内部使用LinkedBlockingQueue作为阻塞队列。  
特点：相当于单线程串行执行所有任务如果该线程异常结束，会重新创建一个新的线程继续执行任务，唯一的线程可以保证所提交任务的顺序执行

public class MyThread extends Thread {
        private int i;
        public MyThread(int in) {
            this.i = in;
        }
        public void run() {
            try {
                this.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(currentThread().getName()+"正在打印："+i);
        }
    }
    
    
    
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class MyThreadText {
        public static void main(String[] args) {
            ExecutorService executorService = Executors.newSingleThreadExecutor();
            for (int i = 0; i < 10; i++) {
                executorService.execute(new MyThread(i));
            }
            executorService.shutdown();
        }
    }

**newFixedThreadPool**  
说明：初始化一个指定线程数的线程池，其中corePoolSize == maxiPoolSize，使用LinkedBlockingQuene作为阻塞队列  
特点：每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，即使当线程池没有可执行任务时，也不会释放线程。如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class MyThreadText {
        public static void main(String[] args) {
            ExecutorService executorService = Executors.newFixedThreadPool(5);
            for (int i = 0; i < 10; i++) {
                executorService.execute(new MyThread(i));
            }
            executorService.shutdown();
        }
    }

**newCachedThreadPool**  
说明：初始化一个可以缓存线程的线程池，此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。线程池的线程数可达到Integer.MAX\_VALUE，即2147483647，内部使用SynchronousQueue作为阻塞队列；  
特点：在没有任务执行时，当线程的空闲时间超过keepAliveTime，默认为60s，会自动释放线程资源；当提交新任务时，如果没有空闲线程，则创建新线程执行任务，会导致一定的系统开销；  
因此，使用时要注意控制并发的任务数，防止因创建大量的线程导致而降低性能。

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class MyThreadText {
        public static void main(String[] args) {
            ExecutorService executorService = Executors.newCachedThreadPool();
            for (int i = 0; i < 10; i++) {
                executorService.execute(new MyThread(i));
            }
            executorService.shutdown();
        }
    }

**newScheduledThreadPool**  
特定：初始化的线程池可以在指定的时间内周期性的执行所提交的任务，在实际的业务场景中可以使用该线程池定期的同步数据。  
总结：除了newScheduledThreadPool的内部实现特殊一点之外，其它线程池内部都是基于ThreadPoolExecutor类（Executor的子类）实现的。

import java.text.SimpleDateFormat;
    import java.util.Date;
    
    public class ScheduledThread extends Thread {
        private int i;
    
        public ScheduledThread(int in) {
            this.i = in;
        }
    
        @Override
        public void run() {
            while (true) {
                try {
                    this.sleep(2000);
                } catch (InterruptedException E) {
                    E.printStackTrace();
                }
                //SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                Date date = new Date();
                System.out.println(currentThread().getName()+"打印编号："+i+"======>"+date);//答应当前时间
            }
        }
    }
    
    
    
    import java.util.concurrent.ScheduledThreadPoolExecutor;
    
    public class ScheduledThreadTest {
        public static void main(String[] args) {
            ScheduledThreadPoolExecutor atpe = new ScheduledThreadPoolExecutor(5);//设置线程个数
            for (int i = 0; i < 5; i++) {
                atpe.execute(new ScheduledThread(i));//普通的提交方式，只提交一次，执行结束，线程不会退出。
            }
        }
    }

# 二.锁 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F4aWFvYm9nZQ_size_16_color_FFFFFF_t_70][]

## 1. 乐观锁 VS 悲观锁 ##

乐观锁与悲观锁是一种广义上的概念，体现了看待线程同步的不同角度。在Java和数据库中都有此概念对应的实际应用。

先说概念。对于同一个数据的并发操作，悲观锁认为自己在使用数据的时候一定有别的线程来修改数据，因此在获取数据的时候会先加锁，确保数据不会被别的线程修改。Java中，synchronized关键字和Lock的实现类都是悲观锁。

而乐观锁认为自己在使用数据时不会有别的线程修改数据，所以不会添加锁，只是在更新数据的时候去判断之前有没有别的线程更新了这个数据。如果这个数据没有被更新，当前线程将自己修改的数据成功写入。如果数据已经被其他线程更新，则根据不同的实现方式执行不同的操作（例如报错或者自动重试）。

乐观锁在Java中是通过使用无锁编程来实现，最常采用的是CAS算法，Java原子类中的递增操作就通过CAS自旋实现的。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F4aWFvYm9nZQ_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F4aWFvYm9nZQ_size_16_color_FFFFFF_t_70 2][]

## **[Java锁的介绍][Java]** ##

package lock;
    
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class ThreadTest {
    
        private int j;
    
        private Lock lock = new ReentrantLock();
        
        public static void main(String[] args){
            ThreadTest tt = new ThreadTest();
            for (int i=0; i<2; i++){
                new Thread(tt.new Adder()).start();
                new Thread(tt.new Subtractor()).start();
            }
        }
        
        private class Subtractor implements Runnable{
    
            public void run(){
                while (true){
                    
                    lock.lock();
                    
                    try{
                        System.out.println("j--=" + j--);
                    }finally{
                        lock.unlock();
                    }
                }
            }
        }
        
        private class Adder implements Runnable{
    
            public void run(){
                while(true){
                    
                    lock.lock();
                    try{
                        System.out.println("j++" + j++);
                    }finally{
                        lock.unlock();
                    }
                }
            }
        }
    }

# 三.JDK #

**安装目录介绍：**

bin：主要存放的是java的编译器、解析器等工具

jre：java runtime environment ——java运行时环境

jre/bin：java平台所使用的的工具或者可执行程序

jre/lib：jre在运行的时候需要的一些类库、属性设置、资源文件

lib：java开发工具要是用的一些类库，包含了支持JDK工具的核心类库，tools.jar、dt.jar……

src.zip：源码

![20171213093746446][]

# 四.反射 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2_size_16_color_FFFFFF_t_70][]

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。  
要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象.  
![20170513133210763][]

### 1、什么是反射？ ###

Java反射就是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；并且能改变它的属性。而这也是Java被视为动态（或准动态，为啥要说是准动态，因为一般而言的动态语言定义是程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言。从这个观点看，Perl，Python，Ruby是动态语言，C++，Java，C\#不是动态语言。）语言的一个关键性质。

### 2、反射能做什么？ 　　 ###

我们知道反射机制允许程序在运行时取得任何一个已知名称的class的内部信息，包括包括其modifiers(修饰符)，fields(属性)，methods(方法)等，并可于运行时改变fields内容或调用methods。那么我们便可以更灵活的编写代码，代码可以在运行时装配，无需在组件之间进行源代码链接，降低代码的耦合度；还有动态代理的实现等等；但是需要注意的是反射使用不当会造成很高的资源消耗！

EG:

package com.ys.reflex;
    public class Person {
        //私有属性
        private String name = "Tom";
        //公有属性
        public int age = 18;
        //构造方法
        public Person() {    
        }
        //私有方法
        private void say(){
            System.out.println("private say()...");
        }
        //公有方法
        public void work(){
            System.out.println("public work()...");
        }
    }

//1、通过对象调用 getClass() 方法来获取,通常应用在：比如你传过来一个 Object
    //  类型的对象，而我不知道你具体是什么类，用这种方法
    　　Person p1 = new Person();
    　　Class c1 = p1.getClass();
            
    //2、直接通过 类名.class 的方式得到,该方法最为安全可靠，程序性能更高
    //  这说明任何一个类都有一个隐含的静态成员变量 class
    　　Class c2 = Person.class;
            
    //3、通过 Class 对象的 forName() 静态方法来获取，用的最多，
    //   但可能抛出 ClassNotFoundException 异常
    　　Class c3 = Class.forName("com.ys.reflex.Person");

//获得类完整的名字
    String className = c2.getName();
    System.out.println(className);//输出com.ys.reflex.Person
            
    //获得类的public类型的属性。
    Field[] fields = c2.getFields();
    for(Field field : fields){
       System.out.println(field.getName());//age
    }
            
    //获得类的所有属性。包括私有的
    Field [] allFields = c2.getDeclaredFields();
    for(Field field : allFields){
        System.out.println(field.getName());//name    age
    }
            
    //获得类的public类型的方法。这里包括 Object 类的一些方法
    Method [] methods = c2.getMethods();
    for(Method method : methods){
        System.out.println(method.getName());//work waid equls toString hashCode等
    }
            
    //获得类的所有方法。
    Method [] allMethods = c2.getDeclaredMethods();
    for(Method method : allMethods){
        System.out.println(method.getName());//work say
    }
            
    //获得指定的属性
    Field f1 = c2.getField("age");
    System.out.println(f1);
    //获得指定的私有属性
    Field f2 = c2.getDeclaredField("name");
    //启用和禁用访问安全检查的开关，值为 true，则表示反射的对象在使用时应该取消 java 语言的访问检查；反之不取消
    f2.setAccessible(true);
    System.out.println(f2);
                    
    //创建这个类的一个对象
    Object p2 =  c2.newInstance();
    //将 p2 对象的  f2 属性赋值为 Bob，f2 属性即为 私有属性 name
    f2.set(p2,"Bob");
    //使用反射机制可以打破封装性，导致了java对象的属性不安全。 
    System.out.println(f2.get(p2)); //Bob
            
    //获取构造方法
    Constructor [] constructors = c2.getConstructors();
    for(Constructor constructor : constructors){
        System.out.println(constructor.toString());//public com.ys.reflex.Person()
    }

# 五.JVM #

![在这里插入图片描述][70]

**JVM虚拟机将其内存分为 程序计数器、虚拟机栈、本地方法栈、java堆、方法区。**

程序计数器：是一块私有的内存空间，比较小。主要记录下一条要运行的命令。

虚拟机栈：也是线程私有的内存空间，和java线程同一时间创建，主要用来保存局部变量、部分结果、并参与方法的调用和返回。(虚拟机栈运行时使用一种叫“栈帧”的数据结构保存上下文数据。)

本地方法栈：虚拟机栈用于管理java函数的调用，本地方法栈用于管理本地方法的调用(用C实现的方法)

java堆：所有的对象、数组都是在堆中分配空间。

堆分为：新生代、老年代。

新生代：存放刚刚产生的对象和年轻对象。新生代分为：e'den(对象刚创建时)、survivor space()、1(至少被GC一次)。

方法区(永久区)：被JVM中的所有线程共享(独立于java堆的内存空间)。主要保存的是类的元数据(类的类型信息、常量池、域信息、方法信息：存放常量和类的定义信息)。GC回收时，只回收永久区中常量池的回收(未被引用的常量)，再就是对类元数据的回收。

![JVM的简单结构][JVM]

### [JVM性能调优][JVM 1] ###

# 六.GC #

**1、需要GC的内存区域**

jvm 中，程序计数器、虚拟机栈、本地方法栈都是随线程而生随线程而灭，栈帧随着方法的进入和退出做入栈和出栈操作，实现了自动的内存清理，因此，我们的内存垃圾回收主要集中于 java 堆和方法区中，在程序运行期间，这部分内存的分配和使用都是动态的。

![format_png][]

**2、GC的对象**

需要进行回收的对象就是已经没有存活的对象，判断一个对象是否存活常用的有两种办法：引用计数和可达分析。

（1）引用计数：每个对象有一个引用计数属性，新增一个引用时计数加1，引用释放时计数减1，计数为0时可以回收。此方法简单，无法解决对象相互循环引用的问题。

（2）可达性分析（Reachability Analysis）：从GC Roots开始向下搜索，搜索所走过的路径称为引用链。当一个对象到GC Roots没有任何引用链相连时，则证明此对象是不可用的。不可达对象。

在Java语言中，GC Roots包括：

虚拟机栈中引用的对象。

方法区中类静态属性实体引用的对象。

方法区中常量引用的对象。

本地方法栈中JNI引用的对象。

**3、什么时候触发GC**

(1)程序调用System.gc时可以触发

(2)系统自身来决定GC触发的时机（根据Eden区和From Space区的内存大小来决定。当内存大小不足时，则会启动GC线程并停止应用线程）

GC又分为 minor GC 和 Full GC (也称为 Major GC )

Minor GC触发条件：当Eden区满时，触发Minor GC。

Full GC触发条件：

a.调用System.gc时，系统建议执行Full GC，但是不必然执行

b.老年代空间不足

c.方法去空间不足

d.通过Minor GC后进入老年代的平均大小大于老年代的可用内存

e.由Eden区、From Space区向To Space区复制时，对象大小大于To Space可用内存，则把该对象转存到老年代，且老年代的可用内存小于该对象大小

**4、GC做了什么事**

主要做了清理对象，整理内存的工作。Java堆分为新生代和老年代，采用了不同的回收方式。

**[GC常用算法][GC]**

# 七.IO和NIO、AIO #

## 一、IO流（同步、阻塞） ##

## 1、概述 ##

IO流简单来说就是input和output流，IO流主要是用来处理设备之间的数据传输，Java IO对于数据的操作都是通过流实现的，而java用于操作流的对象都在IO包中。

![format_png 1][]

# 二、NIO（同步、非阻塞） #

**NIO之所以是同步，是因为它的accept/read/write方法的内核I/O操作都会阻塞当前线程**

首先，我们要先了解一下NIO的三个主要组成部分：Channel（通道）、Buffer（缓冲区）、Selector（选择器）

## （1）Channel（通道） ##

Channel（通道）：Channel是一个对象，可以通过它读取和写入数据。可以把它看做是IO中的流，不同的是：

*  Channel是双向的，既可以读又可以写，而流是单向的
 *  Channel可以进行异步的读写
 *  对Channel的读写必须通过buffer对象

正如上面提到的，所有数据都通过Buffer对象处理，所以，您永远不会将字节直接写入到Channel中，相反，您是将数据写入到Buffer中；同样，您也不会从Channel中读取字节，而是将数据从Channel读入Buffer，再从Buffer获取这个字节。

因为Channel是双向的，所以Channel可以比流更好地反映出底层操作系统的真实情况。特别是在Unix模型中，底层操作系统通常都是双向的。

在Java NIO中的Channel主要有如下几种类型：

*  FileChannel：从文件读取数据的
 *  DatagramChannel：读写UDP网络协议数据
 *  SocketChannel：读写TCP网络协议数据
 *  ServerSocketChannel：可以监听TCP连接

## （2）Buffer ##

Buffer是一个对象，它包含一些要写入或者读到Stream对象的。应用程序不能直接对 Channel 进行读写操作，而必须通过 Buffer 来进行，即 Channel 是通过 Buffer 来读写数据的。

在NIO中，所有的数据都是用Buffer处理的，它是NIO读写数据的中转池。Buffer实质上是一个数组，通常是一个字节数据，但也可以是其他类型的数组。但一个缓冲区不仅仅是一个数组，重要的是它提供了对数据的结构化访问，而且还可以跟踪系统的读写进程。

使用 Buffer 读写数据一般遵循以下四个步骤：

1.写入数据到 Buffer；

2.调用 flip() 方法；

3.从 Buffer 中读取数据；

4.调用 clear() 方法或者 compact() 方法。

当向 Buffer 写入数据时，Buffer 会记录下写了多少数据。一旦要读取数据，需要通过 flip() 方法将 Buffer 从写模式切换到读模式。在读模式下，可以读取之前写入到 Buffer 的所有数据。

一旦读完了所有的数据，就需要清空缓冲区，让它可以再次被写入。有两种方式能清空缓冲区：调用 clear() 或 compact() 方法。clear() 方法会清空整个缓冲区。compact() 方法只会清除已经读过的数据。任何未读的数据都被移到缓冲区的起始处，新写入的数据将放到缓冲区未读数据的后面。

Buffer主要有如下几种：

*  ByteBuffer
 *  CharBuffer
 *  DoubleBuffer
 *  FloatBuffer
 *  IntBuffer
 *  LongBuffer
 *  ShortBuffer

### copyFile实例（NIO） ###

CopyFile是一个非常好的读写结合的例子，我们将通过CopyFile这个实力让大家体会NIO的操作过程。CopyFile执行三个基本的操作：创建一个Buffer，然后从源文件读取数据到缓冲区，然后再将缓冲区写入目标文件。

public static void copyFileUseNIO(String src,String dst) throws IOException{
    //声明源文件和目标文件
            FileInputStream fi=new FileInputStream(new File(src));
            FileOutputStream fo=new FileOutputStream(new File(dst));
            //获得传输通道channel
            FileChannel inChannel=fi.getChannel();
            FileChannel outChannel=fo.getChannel();
            //获得容器buffer
            ByteBuffer buffer=ByteBuffer.allocate(1024);
            while(true){
                //判断是否读完文件
                int eof =inChannel.read(buffer);
                if(eof==-1){
                    break;  
                }
                //重设一下buffer的position=0，limit=position
                buffer.flip();
                //开始写
                outChannel.write(buffer);
                //写完要重置buffer，重设position=0,limit=capacity
                buffer.clear();
            }
            inChannel.close();
            outChannel.close();
            fi.close();
            fo.close();
    }

## （三）Selector（选择器对象） ##

首先需要了解一件事情就是线程上下文切换开销会在高并发时变得很明显，这是同步阻塞方式的低扩展性劣势。

Selector是一个对象，它可以注册到很多个Channel上，监听各个Channel上发生的事件，并且能够根据事件情况决定Channel读写。这样，通过一个线程管理多个Channel，就可以处理大量网络连接了。

### selector优点 ###

有了Selector，我们就可以利用一个线程来处理所有的channels。线程之间的切换对操作系统来说代价是很高的，并且每个线程也会占用一定的系统资源。所以，对系统来说使用的线程越少越好。

### 1.如何创建一个Selector ###

Selector 就是您注册对各种 I/O 事件兴趣的地方，而且当那些事件发生时，就是这个对象告诉您所发生的事件。

Selector selector = Selector.open();

### 2.注册Channel到Selector ###

为了能让Channel和Selector配合使用，我们需要把Channel注册到Selector上。通过调用 channel.register（）方法来实现注册：

channel.configureBlocking(false);
    SelectionKey key =channel.register(selector,SelectionKey.OP_READ);

注意，注册的Channel 必须设置成异步模式 才可以,否则异步IO就无法工作，这就意味着我们不能把一个FileChannel注册到Selector，因为FileChannel没有异步模式，但是网络编程中的SocketChannel是可以的。

### 3.关于SelectionKey ###

请注意对register()的调用的返回值是一个SelectionKey。 SelectionKey 代表这个通道在此 Selector 上注册。当某个 Selector 通知您某个传入事件时，它是通过提供对应于该事件的 SelectionKey 来进行的。SelectionKey 还可以用于取消通道的注册。

SelectionKey中包含如下属性：

*  The interest set
 *  The ready set
 *  The Channel
 *  The Selector
 *  An attached object (optional)

（1）Interest set

就像我们在前面讲到的把Channel注册到Selector来监听感兴趣的事件，interest set就是你要选择的感兴趣的事件的集合。你可以通过SelectionKey对象来读写interest set:

int interestSet = selectionKey.interestOps();
    boolean isInterestedInAccept  = interestSet & SelectionKey.OP_ACCEPT;
    boolean isInterestedInConnect = interestSet & SelectionKey.OP_CONNECT;
    boolean isInterestedInRead    = interestSet & SelectionKey.OP_READ;
    boolean isInterestedInWrite   = interestSet & SelectionKey.OP_WRITE;

通过上面例子可以看到，我们可以通过用AND 和SelectionKey 中的常量做运算，从SelectionKey中找到我们感兴趣的事件。

（2）Ready Set

ready set 是通道已经准备就绪的操作的集合。在一次选Selection之后，你应该会首先访问这个ready set。Selection将在下一小节进行解释。可以这样访问ready集合：

int readySet = selectionKey.readyOps();

可以用像检测interest集合那样的方法，来检测Channel中什么事件或操作已经就绪。但是，也可以使用以下四个方法，它们都会返回一个布尔类型：

selectionKey.isAcceptable();
    selectionKey.isConnectable();
    selectionKey.isReadable();
    selectionKey.isWritable();

（3）Channel 和 Selector

我们可以通过SelectionKey获得Selector和注册的Channel：

Channel  channel  = selectionKey.channel();
    Selector selector = selectionKey.selector();

（4）Attach一个对象

可以将一个对象或者更多信息attach 到SelectionKey上，这样就能方便的识别某个给定的通道。例如，可以附加 与通道一起使用的Buffer，或是包含聚集数据的某个对象。使用方法如下：

selectionKey.attach(theObject);
    Object attachedObj = selectionKey.attachment();

还可以在用register()方法向Selector注册Channel的时候附加对象。如：

SelectionKey key = channel.register(selector, SelectionKey.OP_READ, theObject);

### 4.关于SelectedKeys() ###

**生产系统中一般会额外进行就绪状态检查**

一旦调用了select()方法，它就会返回一个数值，表示一个或多个通道已经就绪，然后你就可以通过调用selector.selectedKeys()方法返回的SelectionKey集合来获得就绪的Channel。请看演示方法：

Set<SelectionKey> selectedKeys = selector.selectedKeys();

当你通过Selector注册一个Channel时，channel.register()方法会返回一个SelectionKey对象，这个对象就代表了你注册的Channel。这些对象可以通过selectedKeys()方法获得。你可以通过迭代这些selected key来获得就绪的Channel，下面是演示代码：

Set<SelectionKey> selectedKeys = selector.selectedKeys();
    Iterator<SelectionKey> keyIterator = selectedKeys.iterator();
    while(keyIterator.hasNext()) { 
    SelectionKey key = keyIterator.next();
    if(key.isAcceptable()) {
    // a connection was accepted by a ServerSocketChannel.
    } else if (key.isConnectable()) {
    // a connection was established with a remote server.
    } else if (key.isReadable()) {
    // a channel is ready for reading
    } else if (key.isWritable()) {
    // a channel is ready for writing
    }
    keyIterator.remove();
    }

这个循环遍历selected key的集合中的每个key，并对每个key做测试来判断哪个Channel已经就绪。

请注意循环中最后的keyIterator.remove()方法。Selector对象并不会从自己的selected key集合中自动移除SelectionKey实例。我们需要在处理完一个Channel的时候自己去移除。当下一次Channel就绪的时候，Selector会再次把它添加到selected key集合中。

SelectionKey.channel()方法返回的Channel需要转换成你具体要处理的类型，比如是ServerSocketChannel或者SocketChannel等等。

## （4）NIO多路复用 ##

主要步骤和元素：

*  首先，通过 Selector.open() 创建一个 Selector，作为类似调度员的角色。
 *  然后，创建一个 ServerSocketChannel，并且向 Selector 注册，通过指定 SelectionKey.OP\_ACCEPT，告诉调度员，它关注的是新的连接请求。
 *  注意，为什么我们要明确配置非阻塞模式呢？这是因为阻塞模式下，注册操作是不允许的，会抛出 IllegalBlockingModeException 异常。
 *  Selector 阻塞在 select 操作，当有 Channel 发生接入请求，就会被唤醒。
 *  在 具体的 方法中，通过 SocketChannel 和 Buffer 进行数据操作

IO 都是同步阻塞模式，所以需要多线程以实现多任务处理。而 NIO 则是利用了单线程轮询事件的机制，通过高效地定位就绪的 Channel，来决定做什么，仅仅 select 阶段是阻塞的，可以有效避免大量客户端连接时，频繁线程切换带来的问题，应用的扩展能力有了非常大的提高

## 三、NIO2(异步、非阻塞) ##

AIO是异步IO的缩写，虽然NIO在网络操作中，提供了非阻塞的方法，但是NIO的IO行为还是同步的。对于NIO来说，我们的业务线程是在IO操作准备好时，得到通知，接着就由这个线程自行进行IO操作，IO操作本身是同步的。

但是对AIO来说，则更加进了一步，它不是在IO准备好时再通知线程，而是在IO操作已经完成后，再给线程发出通知。因此AIO是不会阻塞的，此时我们的业务逻辑将变成一个回调函数，等待IO操作完成后，由系统自动触发。

与NIO不同，当进行读写操作时，只须直接调用API的read或write方法即可。这两种方法均为异步的，对于读操作而言，当有流可读取时，操作系统会将可读的流传入read方法的缓冲区，并通知应用程序；对于写操作而言，当操作系统将write方法传递的流写入完毕时，操作系统主动通知应用程序。 即可以理解为，read/write方法都是异步的，完成后会主动调用回调函数。 在JDK1.7中，这部分内容被称作NIO.2，主要在Java.nio.channels包下增加了下面四个异步通道：

*  AsynchronousSocketChannel
 *  AsynchronousServerSocketChannel
 *  AsynchronousFileChannel
 *  AsynchronousDatagramChannel

在AIO socket编程中，服务端通道是AsynchronousServerSocketChannel，这个类提供了一个open()静态工厂，一个bind()方法用于绑定服务端IP地址（还有端口号），另外还提供了accept()用于接收用户连接请求。在客户端使用的通道是AsynchronousSocketChannel,这个通道处理提供open静态工厂方法外，还提供了read和write方法。

在AIO编程中，发出一个事件（accept read write等）之后要指定事件处理类（回调函数），AIO中的事件处理类是CompletionHandler<V,A>，这个接口定义了如下两个方法，分别在异步操作成功和失败时被回调。

void completed(V result, A attachment);

void failed(Throwable exc, A attachment);

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F4aWFvYm9nZQ_size_16_color_FFFFFF_t_70]: /images/20230521/05852c2e51424ea3bb5a6d2b87ecfb63.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F4aWFvYm9nZQ_size_16_color_FFFFFF_t_70 1]: /images/20230521/9b9b1f880b6e4d8fa4e7a185d0cbefcd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F4aWFvYm9nZQ_size_16_color_FFFFFF_t_70 2]: /images/20230521/c8374bc61f474d64b49f8ccfa1d25eca.png
[Java]: https://www.cnblogs.com/jyroy/p/11365935.html
[20171213093746446]: /images/20230521/4f7d82a7ccfb49159a62e1512f529168.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2_size_16_color_FFFFFF_t_70]: /images/20230521/34de2094bdd741a0972976a47f5413bb.png
[20170513133210763]: /images/20230521/67a0fea3a5ca473e81510b17a0ed9f92.png
[70]: /images/20230521/b5c3935c341844339646c516105a905c.png
[JVM]: /images/20230521/83b3245d4ccc4196ae8d07ac4d940179.png
[JVM 1]: https://www.jianshu.com/p/5c3feb163d9a
[format_png]: /images/20230521/8e263358dbe74f3f92a2f79008dd69cb.png
[GC]: https://blog.csdn.net/laomo_bible/article/details/83112622
[format_png 1]: /images/20230521/7fcf586d74644fc18918a82b77316c1f.png