1. 单例模式
1.1 要求
当前类有且只有一个对象，一旦当前类存在一个对象之后，无法在重新创建当前类的对象。就算是你要创建，代码返回的对象依然是上一次创建的对象。
懒汉模式，饿汉模式
1.2 单例模式推导【懒汉】
package com.qfedu.a_single;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* SingleDog要求是一个单例类，整个代码运行周期内有且只有一个类对象
*
* 不可取方式:
* @全体成员 SingleDog类使用一个单例类，我创建过对象了，你们不要搞事情
* 红包
* 【期望】
* 从语法角度约束一些行为。
* 目前创建对象过于简单，new + 构成方法组合非常easy
* 【解决方案】
* private修饰构造方法
*
* 【问题】
* 构造方法私有化之后，类外没有操作构造方法的权限，没办法创建对象
* 【解决方案】
* 1. 暴力反射
* 暴力反射，给予构造方法操作权限，这里和没有使用private有什么区别
* 【不合适】
* 2. 期望
* 类外最起码有一个对象。
* a. 类外没有SingleDog类对象
* b. 期望获取到一个SingleDog对象
*
* 需要方法来完成
* 1. 该方法要求静态成员方法，没有对象，需要通过类名调用
* 2. 类外要求使用public修饰
* 3. 该方法需要得到一个SingleDog对象，返回值类型是SingleDog
* 4. 方法参数为无参数，构造方法也是无参
* 5. 方法名 getInstance
* public static SingleDog getInstance()
*
* 【问题】
* 依然是不同对象
*
* 【期望】
* 1. 调用该方法每一次调用都是new新的对象。
* 2. 这个new得有限制，如果之前创建过对象，你就不能再new了，没有对象可以new
* 3. 存在一个变量可以保存之前创建对象的空间首地址，并且可以持久性保存。
* 分析：
* a. 需要保存SingleDog类对象空间首地址
* SingleDog类型
* b. 该数据不能类外轻松获取
* private
* c.
* (1) 静态方法可以使用
* (2) 有一定的持久性
* static修饰成员变量
* private static SingleDog sd = null;
* 【getInstance方法】
* 需要判断
* 判断SingleDog类型的静态成员变量 sd是否保存有之前创建的空间首地址
*
* 【问题】
* 多线程情况下，存在线程抢占问题，极有可能导致当前方法被两个线程同时执行，同时
* 创建对象
* com.qfedu.a_single.SingleDog@22673956
* com.qfedu.a_single.SingleDog@6223c513
*
* 【期望】
* 在多线程情况下，也是安全的
* 【解决方案】
* 加锁
* 【墙裂推荐】synchronized同步代码块
* 使用同步代码块，用什么做锁对象?
* 最合适的锁对象依然是Single.class
*
* 【墙裂推荐】synchronized同步方法
* static修饰静态方法的情况下，什么是锁对象?
* 当前SingleDog类.class字节码文件
*
* 【不推荐】Lock锁对象
* 和以上两个方式对比?
* new ==> lock ==> 多出一个Lock锁空间
* (1) 在getInstance方法new lock是不合适，多个线程情况下
* 可能会出现不同锁情况
* (2) Lock做成静态成员变量
* 浪费空间了！！！
*
*
* @author Anonymous 2020/3/13 10:53
*/
public class SingleDog {
private static SingleDog sd = null;
private SingleDog() {}
// 同步方法
public static synchronized SingleDog getInstance() {
if (null == sd) {
sd = new SingleDog();
}
return sd;
}
}
public class SingleDog1 {
private static SingleDog1 sd = null;
private SingleDog1() {}
// 同步代码块
public static SingleDog1 getInstance() {
synchronized (SingleDog1.class) {
if (null == sd) {
sd = new SingleDog1();
}
}
return sd;
}
}
1.3 另一种单例模式【饿汉】
package com.qfedu.a_single;
/**
* 另一个单例模式
*
* @author Anonymous 2020/3/13 11:44
*/
public class SingleCat {
/*
static修饰，在代码的加载阶段创建完成
并且使用final修饰，保存当前指向不可以改变
private修饰类外无法直接获取，不能修改
*/
private static final SingleCat sc = new SingleCat();
private SingleCat() {}
/*
使用方法做的统一
*/
public static SingleCat getInstance() {
return sc;
}
}
2. NIO
2.1 BIO概述
BIO
BIO ==> Basic IO (基本IO), Block IO(阻塞IO)
Scanner操作，文件读写操作，Socket数据传输操作... 都是BIO
比如TPC群聊，私聊聊天室
Socket涉及到的IO，也是BIO
资源浪费：
1. 多线程，每一个Socket会对应一个线程，如果用户量巨大，会导致线程过
多，资源处理过多
2. 采用阻塞状态，一旦进入阻塞，代码无法执行其他操作。
3. 承载量一般，吞吐量比较小，同时可靠性不佳
2.2 NIO概述
NIO
NIO ==> New IO(新IO), Non-Block IO(非阻塞IO)
NIO非阻塞IO，运行当前程序在处理IO事务时，不会影响其他程序的运行，可以在不使用多线程的情况下，满足IO操作要求。
三大核心部分:
通道
Channel
文件操作，网络数据传递操作使用的通道
缓冲
Buffer
缓冲使用可以提供操作效率，减少不必要的读写次数
选择器
Selector
真·核心 老大 boss
2.3 Buffer Channel完成文件操作
2.3.1 常用API
java.nio.Buffer
Buffer缓冲区
ByteBuffer 字节缓冲 常用
ShortBuffer
IntBuffer
LongBuffer
CharBuffer 字节缓冲 常用
FloatBuffer
DoubleBuffer
常用方法:
public static ByteBuffer allocate(int capacity);
按照指定的字节数分配对应的缓冲区空间，保存字节数据
public byte get();
从字节缓冲区对象中读取一个byte类型数组
public final Buffer flip();
翻转缓冲区，回到缓冲区的开始位置。
public static ByteBuffer wrap(byte[] arr);
存入一个byte类型数组到缓冲区，会得到一个新的ByteBuffer
public static ByteBuffer put(byte[] b);
将字节数组存入缓冲去
Channel接口，通道接口
FileChannel 文件操作通道
DatagramChannel UDP协议数据包操作的Channel
ServerSocketChannel TCP服务端ServerSocket对应Channel
SocketChannel TCP客户端Socket对应Channel
首先操作文件，以FileChannel为例
public long read(ByteBuffer buffer);
从通道中读取数据到ByteBuffer中
public long write(ByteBuffer buffer);
从Buffer中写数据到通道中
public long transferFrom(ReadableByteChannel src, long position, long count)
从指定srcChannel中，指定位置position开始，读取count个元素，到当前通道中
文件复制操作。
public long transferTo(long position, long count, WritableByteChannel target)
将当前通道中的数据写入到target中，从当前通道的position位置开始，计数count
2.3.2 操作文件数据
package com.qfedu.b_niofile;
import org.junit.Test;
import java.io.*;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
/**
* @author Anonymous 2020/3/13 15:17
*/
public class FileNioTest {
/*
通过NIO写入数据到文件中的操作
*/
@Test
public void testNioFileWrite() throws IOException {
// 1. 文件操作字节输出流
FileOutputStream fos = new FileOutputStream("D:/aaa/1.txt");
// 2. 利用文件操作输出字节流对象获取对应的Channel通道
FileChannel foc = fos.getChannel();
// 3. 准备一个缓冲区 4KB缓冲区
ByteBuffer buffer = ByteBuffer.allocate(1024 * 4);
// 4. 准备数据，放入缓冲区
String str = "测试NIO";
buffer.put(str.getBytes());
// 5. 存在缓冲区数据放入之后，缓冲区指针发生改变，到达存入数据的末尾
// 如果此时调用写入操作，会从存入缓冲区之后开始保存
// 让缓冲区指针回到最初的起点,并且操作写入程序，只会保存缓冲区内的有效数据
buffer.flip();
// 6. 缓冲区数据写入到通道中
foc.write(buffer);
// 7. 关闭资源
fos.close();
}
@Test
public void testNioFileRead() throws IOException {
// 1. 文件字节操作输入流
FileInputStream fis = new FileInputStream("D:/aaa/1.txt");
// 2. FileChannel
FileChannel fic = fis.getChannel();
// 3. 准备缓冲
ByteBuffer buffer = ByteBuffer.allocate(1024);
// 4. 从Channel读取数据保存到缓冲区中
int read = fic.read(buffer);
System.out.println(read);
// 5. 展示数据
// String(byte[] arr, int off, int count)
System.out.println(new String(buffer.array(), 0, read));
// 6. 关闭资源
fis.close();
}
// 130
@Test
public void testCopyFile() throws IOException {
long start = System.currentTimeMillis();
// 1. 安排输出流和输入流
FileInputStream fis = new FileInputStream("D:/aaa/1.mp4");
FileOutputStream fos = new FileOutputStream("D:/aaa/2.mp4");
// 2. 准备两个Channel
FileChannel srcChannel = fis.getChannel();
FileChannel dstChannel = fos.getChannel();
// 3. 拷贝方法
srcChannel.transferTo(0, srcChannel.size(), dstChannel);
// dstChannel.transferFrom(srcChannel, 0, srcChannel.size());
// 4. 关闭资源
fos.close();
fis.close();
long end = System.currentTimeMillis();
System.out.println("Time:" + (end - start));
}
// 300
@Test
public void testCopyUseBuffer() throws IOException {
long start = System.currentTimeMillis();
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:/aaa/1.mp4"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:/aaa/3.mp4"));
int length = -1;
byte[] buf = new byte[4 * 1024];
while ((length = bis.read(buf)) != -1) {
bos.write(buf, 0, length);
}
bos.close();
bis.close();
long end = System.currentTimeMillis();
System.out.println("Time:" + (end - start));
}
}
2.4 网络编程使用NIO【重点】
2.4.1 Selector选择器老大
Selector
选择器，网络编程使用NIO的大哥！！！
服务器可以执行一个线程，运行Selector程序，进行监听操作。
新连接， 已经连接， 读取数据，写入数据
Selector常用方法：
public static Selector Open();
得到一个选择器对象
public int select(long timeout);
监听所有注册通道，存在IO流操作是，会将对应的信息SelectionKey存入到内部的集
合中，参数是一个超时时间
public Set selectionKeys();
返回当前Selector内部集合中保存的所有SelectionKey
2.4.2 SelectionKey
SelectionKey
表示Selector和网络通道直接的关系
int OP_ACCEPT; 16 需要连接
int OP_CONNECT; 8 已经连接
int OP_READ; 1 读取操作
int OP_WRITE; 4 写入操作
SelectionKey
public abstract Selector selector();
得到与之关联的 Selector 对象
public abstract SelectableChannel channel();
得到与之关联的通道
public final Object attachment();
得到与之关联的共享数据
public abstract SelectionKey interestOps(int ops);
设置或改变监听事件
public final boolean isAcceptable();
是否可以 accept
public final boolean isReadable();
是否可以读
public final boolean isWritable();
是否可以写
2.4.3 ServerSocketChannel
ServerSocketChannel
服务端Socket程序对应的Channel通道
常用方法:
public static ServerSocketChannel open();
开启服务器ServerSocketChannel通道，等于开始服务器程序
public final ServerSocketChannel bind(SocketAddress local);
设置服务器端端口号
public final SelectableChannel configureBlocking(boolean block);
设置阻塞或非阻塞模式， 取值 false 表示采用非阻塞模式
public SocketChannel accept();
[非阻塞]
获取一个客户端连接，并且得到对应的操作通道
public final SelectionKey register(Selector sel, int ops);
[重点方法]
注册当前选择器，并且选择监听什么事件
2.4.4 SocketChannel
SocketChannel
客户端Socket对应的Channel对象
常用方法:
public static SocketChannel open();
打卡一个Socket客户端Channel对象
public final SelectableChannel configureBlocking(boolean block)
这里可以设置是阻塞状态，还是非阻塞状态
false，表示非阻塞
public boolean connect(SocketAddress remote);
连接服务器
public boolean finishConnect();
如果connect连接失败，可以通过finishConnect继续连接
public int write(ByteBuffer buf);
写入数据到缓冲流中
public int read(ByteBuffer buf); 、
从缓冲流中读取数据
public final SelectionKey register(Selector sel, int ops, Object attechment);
注册当前SocketChannel，选择对应的监听操作，并且可以带有Object attachment参数
public final void close();
关闭SocketChannel
