Zebra1

进程

• 进程
  • 程序加载到内存中之后被cpu所计算的过程，进程是计算机资源分配和任务调度的最小单位
• 三个维度
  • 进程
    1. 物理内存维度：每一个进程都要分配一个连续的内存空间【首尾地址】
    2. 执行角度/逻辑角度：每个进程都可以被cpu计算，每一个进程都能挂起然后让另外的进程被cpu计算--对于单核cpu而言，每一个时刻只能执行一个进程【对于Windows而言，默认是一个核处理，对于linux而言，有几个核就可以用几个核】【微观：串行】【宏观：并行--多道编程】
    3. 时间角度：在每一个时间角度而言，进程是向前扑进的
• 为什么要有进程
  1. 不引进进程，每个时刻只能有一个任务在执行，效率低下----减少响应时间，提高使用效率、
  2. IO事件发生时，cpu是不进行计算的【cpu的利用率=1-cpu的利用率ⁿ】,理论上来说，进程越多，cpu的利用率越高----提高cpu的利用率
• 进程的生命周期
  • 产生
    1. 系统启动，会创建系统进程
    2. 用户请求创建进程
    3. 父进程（主进程）自动去启动子进程
  • 进程的消亡
    1. 正常消亡：进程正常结束
    2. 意外消亡：进程执行过程中出现错误或异常
    3. 他杀：一个进程被另外的进程强制关闭
• 进程的状态
  • 就绪
  • 运行
  • 阻塞
• 进程的状态转化
  • 就绪->运行
  • 运行->阻塞
  • 运行->就绪
  • 阻塞->就绪
• 进程的任务调度算法
  1. 时间片轮询算法
  2. 优先级调度算法
  3. 短任务优先算法
  4. FIFS，先来先服务

线程

• 线程
  • 是进程中执行的任务，线程本质上也是在完成任务、是简化版的进程
  • 一个进程中，至少有一线程在执行
  • 线程是任务执行的最小单位

Socket/ServerSocket

• Bio（BlockingIO）：阻塞式IO--阻塞在一些场景会相对影响效率，因为流有方向性，所以在数据传输的时候往往创建多个流对象，如果流长时间不关闭的话，会造成资源的大量的浪费，无法从流中抽取一段数据
• Nio（NewIO）（NonBlockingIO）：非阻塞式IO，基于通道和缓冲区
  • 通道【道路】
    • 没有方向性--即双向
  • 缓冲区【车】
    • 实际来传输数据的
• Buffer
  • 一个用于特定基本类型的基本数据
  • 一般ByteBuffer居多
  • 图示
    • 

• ByteBuffer

  • 抽象类
    • allocate--获取ByteBuffer对象
    • get取值
    • put设置值
    • flip反转缓冲区
    • limit限制位
    • position操作位

  • 例

    package com.peng.socket;import java.nio.ByteBuffer;import org.junit.Test;public class TestByteBuffer {@Testpublic void testByteBuffer() {// 属性// 1.capacity容量位--表示缓冲区的容量// 2.position操作位--表示要操作的位--当缓冲区刚刚创建的时候，默认为0--每添加一个字节的数据的时候，就 向后移一位// 3.limit限制位--表示position所能达到的最大位置--当缓冲区刚刚创建的时候，limit设置为何容量的大小一样// 创建缓存区，并且指定了 大小：1024字节ByteBuffer bb = ByteBuffer.allocate(1024);// 向缓冲区添加数据bb.put("hello".getBytes());System.err.println("当前的位置：" + bb.position());bb.position(0);// 操作位移到最前面System.err.println("第一个字节：" + bb.get());// 方法--翻转缓冲区flip:先将限制位设置为操作位，再将操作位设置为0// bb.flip();// 方法--rewind：重绕缓冲区--只是将操作位归零// 分界System.err.println("============分解符=============");// 如果知道具体的数据，建议使用这种方法ByteBuffer bb2 = ByteBuffer.wrap("hello".getBytes());System.err.println(bb2.get());while (bb2.hasRemaining()) {// 是否还有剩余数据System.err.println(bb2.get());}}
    }
    

数组复制--保持数据的不变性--副本，不改变原数据

Channel

• 用于I/O操作的连接
  • FileChannel
  • DataChannel
  • ServerSocketChannel
  • SocketChannel
• 支持非阻塞连接
• 抽象类
  • 创建：open函数
• 双向通讯

Channel的连接步骤

• 客户端
  1. 打开客户端通道
  2. 设置为非阻塞通讯
  3. 连接
  4. 人为阻塞--防止无效的连接
  5. 写出数据
• 服务器端
  1. 打开服务器端的通道
  2. 绑定要监听的端口号
  3. 设置为非阻塞
  4. 接收连接
  5. 人为阻塞--防止没有获取的真正的连接
  6. 读取数据
• 例子【客户端】

  @Test
  public void test() throws Exception {// 打开通道--默认为阻塞连接SocketChannel s = SocketChannel.open();// 设置为非阻塞s.configureBlocking(false);// 发起连接s.connect(new InetSocketAddress("localhost", 8090));// 人为阻塞--连接失败则会继续连接while (!s.finishConnect()) {}// 写数据s.write(ByteBuffer.wrap("hello".getBytes()));System.out.println("写出成功！");
  }
  

• 例子【服务端】

  @Test
  public void testServerSocketChannel() throws Exception {// 打开通道--默认为阻塞连接ServerSocketChannel ss = ServerSocketChannel.open();// 设置为非阻塞ss.configureBlocking(false);// 绑定监听的端口ss.bind(new InetSocketAddress(8090));SocketChannel channel = ss.accept();// 人为阻塞while (channel == null) {channel = ss.accept();}// 设置为非阻塞// channel.configureBlocking(false);// 准备缓冲区ByteBuffer buffer = ByteBuffer.allocate(100);// 读出数据channel.read(buffer);// 反转缓冲区--方便之后处理数据buffer.flip();System.out.println("数据：" + new String(buffer.array(), 0, buffer.limit()));System.out.println("接收成功！");
  }
  

Selector选择器

• 

• 例子

  package com.peng.socket;import java.net.InetSocketAddress;
  import java.nio.ByteBuffer;
  import java.nio.channels.SelectionKey;
  import java.nio.channels.Selector;
  import java.nio.channels.ServerSocketChannel;
  import java.nio.channels.SocketChannel;
  import java.util.Iterator;
  import java.util.Set;import org.junit.Test;public class TestSelect {@Testpublic void test1() throws Exception {// 打开客户端通道SocketChannel sc = SocketChannel.open();// 非阻塞sc.configureBlocking(false);// 获取选择器Selector selc = Selector.open();// 将通道注册到选择器上sc.register(selc, SelectionKey.OP_CONNECT);// 注册connect权力// 发起连接sc.connect(new InetSocketAddress("localhost", 8090));while (true) {// 筛选--进行选择--是否包含发放的权力selc.select();// 获取筛选之后的 有用的事件Set<SelectionKey> keys = selc.selectedKeys();// 获取迭代器Iterator<SelectionKey> it = keys.iterator();// 遍历while (it.hasNext()) {// 将遍历到的这个事件获取出来SelectionKey key = it.next();// 可能会发起连接if (key.isConnectable()) {// 获取到对应的通道SocketChannel scx = (SocketChannel) key.channel();// 判断连接是否成功while (!scx.finishConnect()) {}// 重新注册写的权限scx.register(selc, SelectionKey.OP_WRITE | SelectionKey.OP_READ);// 将会将原来的权限覆盖掉}// 可能会写数据if (key.isWritable()) {// 从事件身上获取通道SocketChannel scx = (SocketChannel) key.channel();// 写数据String msg = "hello,hello";scx.write(ByteBuffer.wrap(msg.getBytes()));// 将权限进行修改scx.register(selc, key.interestOps() & ~SelectionKey.OP_WRITE);// 取消写的权限}// 可能从服务器获取数据if (key.isReadable()) {// 从事件身上获取通道SocketChannel scx = (SocketChannel) key.channel();// 读数据ByteBuffer buffer = ByteBuffer.allocate(1024);scx.read(buffer);buffer.flip();System.out.println(new String(buffer.array(), 0, buffer.limit()));// 将读的事件scx.register(selc, key.interestOps() & ~SelectionKey.OP_READ);// 取消读的权限}// 防止事件处理失败--防止重复事件it.remove();}}}/*** 服务器端* */@Testpublic void serverTest() throws Exception {// 打开服务器的通道ServerSocketChannel ssc = ServerSocketChannel.open();// 绑定端口号ssc.bind(new InetSocketAddress(8090));// 设置为非阻塞ssc.configureBlocking(false);// 打开选择器Selector selc = Selector.open();// 注册到选择器上ssc.register(selc, SelectionKey.OP_ACCEPT);while (true) {// 进行选择selc.select();// 将时间获取出来Set<SelectionKey> keys = selc.selectedKeys();// 获取到迭代器Iterator<SelectionKey> it = keys.iterator();// 遍历while (it.hasNext()) {SelectionKey key = it.next();// 可能是接受事件if (key.isAcceptable()) {// 从事件身上获取通道ServerSocketChannel scx = (ServerSocketChannel) key.channel();// 判断连接是否成功SocketChannel sc = scx.accept();while (sc == null) {sc = scx.accept();}sc.configureBlocking(false);// 注册写的权限sc.register(selc, SelectionKey.OP_WRITE | SelectionKey.OP_READ);// 将会将原来的权限覆盖掉}}// 可能是可写事件if (key.isWritable()) {// 从事件身上获取通道SocketChannel scx = (SocketChannel) key.channel();// 写数据String msg = "hello,hello---------I'm Server ";scx.write(ByteBuffer.wrap(msg.getBytes()));// 将权限进行修改scx.register(selc, key.interestOps() & ~SelectionKey.OP_WRITE);// 取消写的权限}// 可能是可读事件if (key.isReadable()) {// 从事件身上获取通道SocketChannel scx = (SocketChannel) key.channel();// 读数据ByteBuffer buffer = ByteBuffer.allocate(1024);scx.read(buffer);buffer.flip();System.out.println(new String(buffer.array(), 0, buffer.limit()));// 修改权限scx.register(selc, key.interestOps() & ~SelectionKey.OP_READ);// 取消读的权限}// 防止事件处理失败--防止重复事件it.remove();}}}
  }
  

• 执行结果
  • 一个服务端，处理多个客户端的请求
  • 
• 监听事件
  1. 连接一般是客户端
  2. 接受一般是服务器
  3. 读写--客户端和服务端都有

NIO

• 数据可以双向传输-- 减少了流的数量，降低服务器的内存消耗
• 由于数据是在缓冲区的，所以可以针对缓冲区的数据做定向操作【视频剪切后加头后还能进行小段播放】
• 能够用一个或少量的服务器来完成大量的用户的请求处理，适用于短任务请求【长任务适用于Socket，点对点】

比较【bio（Socket）与Nio】

问题

• A和B同时发送大量的数据，产生了数据粘包，如何处理
  • 思路
    1. 定长--如果数据长度不够，填充无用数据--无用数据的区分
    2. 约定结尾的符号--结束符号可能会与实际内容冲突、
    3. 序列化/反序列化【一般用这个】--【约定了起始和结束的协议】