大数据正式Zebra1

红太狼 2022-05-31 14:51 168阅读 0赞

# Zebra1 #

### 进程 ###

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

### 线程 ###

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

### Socket/ServerSocket ###

*  Bio（BlockingIO）：阻塞式IO--阻塞在一些场景会相对影响效率，因为流有方向性，所以在数据传输的时候往往创建多个流对象，如果流长时间不关闭的话，会造成资源的大量的浪费，无法从流中抽取一段数据
 *  Nio（NewIO）（NonBlockingIO）：非阻塞式IO，基于通道和缓冲区
    
     *  通道【道路】
        
         *  没有方向性--即双向
     *  缓冲区【车】
        
         *  实际来传输数据的
 *  Buffer
    
     *  一个用于特定基本类型的基本数据
     *  一般ByteBuffer居多
     *  图示
        
         *  ![ayk7koy.png][]
 *  ByteBuffer
    
     *  抽象类
        
         *  allocate--获取ByteBuffer对象
         *  get取值
         *  put设置值
         *  flip反转缓冲区
         *  limit限制位
         *  position操作位
     *  例
        
        #  #
        
            package com.peng.socket;
            
            import java.nio.ByteBuffer;
            
            import org.junit.Test;
            
            public class TestByteBuffer {
            
                @Test
                public 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选择器 ###

*  ![CeIY7A6.png][]
 *  例子
    
    #  #
    
        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 {
            @Test
            public 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();
                    }
                }
            }
        
            /**
             * 服务器端
             * 
             */
            @Test
            public 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();
                    }
                }
            }
        }
 *  执行结果
    
     *  一个服务端，处理多个客户端的请求
     *  ![Mb1q2JR.png][]
 *  监听事件
    
    1.  连接一般是客户端
    2.  接受一般是服务器
    3.  读写--客户端和服务端都有

### NIO ###

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

### 比较【bio（Socket）与Nio】 ###

<table style="margin-top:15px;margin-right:0px;margin-bottom:15px;margin-left:0px;padding-top:0px;padding-right:0px;padding-bottom:0px;padding-left:0px;border-top-width:0px;border-right-width:0px;border-bottom-width:0px;border-left-width:0px;"> 
 <thead style="margin-top:0px;margin-right:0px;margin-bottom:0px;margin-left:0px;padding-top:0px;padding-right:0px;padding-bottom:0px;padding-left:0px;border-top-width:0px;border-right-width:0px;border-bottom-width:0px;border-left-width:0px;"> 
  <tr style="margin-top:0px;margin-right:0px;margin-bottom:0px;margin-left:0px;padding-top:0px;padding-right:0px;padding-bottom:0px;padding-left:0px;border-top-width:1px;border-right-width:0px;border-bottom-width:0px;border-left-width:0px;border-top-style:solid;border-top-color:rgb(204,204,204);background-color:rgb(255,255,255);"> 
   <th style="margin-top:0px;margin-right:0px;margin-bottom:0px;margin-left:0px;padding-top:6px;padding-right:13px;padding-bottom:6px;padding-left:13px;border-top-width:1px;border-right-width:1px;border-bottom-width:1px;border-left-width:1px;font-weight:bold;border-top-style:solid;border-right-style:solid;border-bottom-style:solid;border-left-style:solid;border-top-color:rgb(204,204,204);border-right-color:rgb(204,204,204);border-bottom-color:rgb(204,204,204);border-left-color:rgb(204,204,204);">bio</th> 
   <th style="margin-top:0px;margin-right:0px;margin-bottom:0px;margin-left:0px;padding-top:6px;padding-right:13px;padding-bottom:6px;padding-left:13px;border-top-width:1px;border-right-width:1px;border-bottom-width:1px;border-left-width:1px;font-weight:bold;border-top-style:solid;border-right-style:solid;border-bottom-style:solid;border-left-style:solid;border-top-color:rgb(204,204,204);border-right-color:rgb(204,204,204);border-bottom-color:rgb(204,204,204);border-left-color:rgb(204,204,204);">nio</th> 
  </tr> 
 </thead> 
 <tbody style="margin-top:0px;margin-right:0px;margin-bottom:0px;margin-left:0px;padding-top:0px;padding-right:0px;padding-bottom:0px;padding-left:0px;border-top-width:0px;border-right-width:0px;border-bottom-width:0px;border-left-width:0px;"> 
  <tr style="margin-top:0px;margin-right:0px;margin-bottom:0px;margin-left:0px;padding-top:0px;padding-right:0px;padding-bottom:0px;padding-left:0px;border-top-width:1px;border-right-width:0px;border-bottom-width:0px;border-left-width:0px;border-top-style:solid;border-top-color:rgb(204,204,204);background-color:rgb(255,255,255);"> 
   <td style="margin-top:0px;margin-right:0px;margin-bottom:0px;margin-left:0px;padding-top:6px;padding-right:13px;padding-bottom:6px;padding-left:13px;border-top-width:1px;border-right-width:1px;border-bottom-width:1px;border-left-width:1px;border-top-style:solid;border-right-style:solid;border-bottom-style:solid;border-left-style:solid;border-top-color:rgb(204,204,204);border-right-color:rgb(204,204,204);border-bottom-color:rgb(204,204,204);border-left-color:rgb(204,204,204);">流有方向</td> 
   <td style="margin-top:0px;margin-right:0px;margin-bottom:0px;margin-left:0px;padding-top:6px;padding-right:13px;padding-bottom:6px;padding-left:13px;border-top-width:1px;border-right-width:1px;border-bottom-width:1px;border-left-width:1px;border-top-style:solid;border-right-style:solid;border-bottom-style:solid;border-left-style:solid;border-top-color:rgb(204,204,204);border-right-color:rgb(204,204,204);border-bottom-color:rgb(204,204,204);border-left-color:rgb(204,204,204);">通道，在一个通道上可以进行数据的输入和输出</td> 
  </tr> 
  <tr style="margin-top:0px;margin-right:0px;margin-bottom:0px;margin-left:0px;padding-top:0px;padding-right:0px;padding-bottom:0px;padding-left:0px;border-top-width:1px;border-right-width:0px;border-bottom-width:0px;border-left-width:0px;border-top-style:solid;border-top-color:rgb(204,204,204);background-color:rgb(248,248,248);"> 
   <td style="margin-top:0px;margin-right:0px;margin-bottom:0px;margin-left:0px;padding-top:6px;padding-right:13px;padding-bottom:6px;padding-left:13px;border-top-width:1px;border-right-width:1px;border-bottom-width:1px;border-left-width:1px;border-top-style:solid;border-right-style:solid;border-bottom-style:solid;border-left-style:solid;border-top-color:rgb(204,204,204);border-right-color:rgb(204,204,204);border-bottom-color:rgb(204,204,204);border-left-color:rgb(204,204,204);">流的数据数连续不断地，不能很灵活的操作数据</td> 
   <td style="margin-top:0px;margin-right:0px;margin-bottom:0px;margin-left:0px;padding-top:6px;padding-right:13px;padding-bottom:6px;padding-left:13px;border-top-width:1px;border-right-width:1px;border-bottom-width:1px;border-left-width:1px;border-top-style:solid;border-right-style:solid;border-bottom-style:solid;border-left-style:solid;border-top-color:rgb(204,204,204);border-right-color:rgb(204,204,204);border-bottom-color:rgb(204,204,204);border-left-color:rgb(204,204,204);">Buffer传输数据的载体，是一个缓冲区，本质上是一个数组结构，缓冲区的大小可以自由控制（注意：实际大小不要超过32GB）</td> 
  </tr> 
  <tr style="margin-top:0px;margin-right:0px;margin-bottom:0px;margin-left:0px;padding-top:0px;padding-right:0px;padding-bottom:0px;padding-left:0px;border-top-width:1px;border-right-width:0px;border-bottom-width:0px;border-left-width:0px;border-top-style:solid;border-top-color:rgb(204,204,204);background-color:rgb(255,255,255);"> 
   <td style="margin-top:0px;margin-right:0px;margin-bottom:0px;margin-left:0px;padding-top:6px;padding-right:13px;padding-bottom:6px;padding-left:13px;border-top-width:1px;border-right-width:1px;border-bottom-width:1px;border-left-width:1px;border-top-style:solid;border-right-style:solid;border-bottom-style:solid;border-left-style:solid;border-top-color:rgb(204,204,204);border-right-color:rgb(204,204,204);border-bottom-color:rgb(204,204,204);border-left-color:rgb(204,204,204);">阻塞通信模型--一个请求产生一个线程</td> 
   <td style="margin-top:0px;margin-right:0px;margin-bottom:0px;margin-left:0px;padding-top:6px;padding-right:13px;padding-bottom:6px;padding-left:13px;border-top-width:1px;border-right-width:1px;border-bottom-width:1px;border-left-width:1px;border-top-style:solid;border-right-style:solid;border-bottom-style:solid;border-left-style:solid;border-top-color:rgb(204,204,204);border-right-color:rgb(204,204,204);border-bottom-color:rgb(204,204,204);border-left-color:rgb(204,204,204);">非阻塞性通讯模型--一个线程或几个线程处理多用户的请求</td> 
  </tr> 
  <tr style="margin-top:0px;margin-right:0px;margin-bottom:0px;margin-left:0px;padding-top:0px;padding-right:0px;padding-bottom:0px;padding-left:0px;border-top-width:1px;border-right-width:0px;border-bottom-width:0px;border-left-width:0px;border-top-style:solid;border-top-color:rgb(204,204,204);background-color:rgb(248,248,248);"> 
   <td style="margin-top:0px;margin-right:0px;margin-bottom:0px;margin-left:0px;padding-top:6px;padding-right:13px;padding-bottom:6px;padding-left:13px;border-top-width:1px;border-right-width:1px;border-bottom-width:1px;border-left-width:1px;border-top-style:solid;border-right-style:solid;border-bottom-style:solid;border-left-style:solid;border-top-color:rgb(204,204,204);border-right-color:rgb(204,204,204);border-bottom-color:rgb(204,204,204);border-left-color:rgb(204,204,204);">不适合高并发和高访问，适合长请求</td> 
   <td style="margin-top:0px;margin-right:0px;margin-bottom:0px;margin-left:0px;padding-top:6px;padding-right:13px;padding-bottom:6px;padding-left:13px;border-top-width:1px;border-right-width:1px;border-bottom-width:1px;border-left-width:1px;border-top-style:solid;border-right-style:solid;border-bottom-style:solid;border-left-style:solid;border-top-color:rgb(204,204,204);border-right-color:rgb(204,204,204);border-bottom-color:rgb(204,204,204);border-left-color:rgb(204,204,204);">适合做高并发和高访的场景，短请求的场景</td> 
  </tr> 
  <tr style="margin-top:0px;margin-right:0px;margin-bottom:0px;margin-left:0px;padding-top:0px;padding-right:0px;padding-bottom:0px;padding-left:0px;border-top-width:1px;border-right-width:0px;border-bottom-width:0px;border-left-width:0px;border-top-style:solid;border-top-color:rgb(204,204,204);background-color:rgb(255,255,255);"> 
   <td style="margin-top:0px;margin-right:0px;margin-bottom:0px;margin-left:0px;padding-top:6px;padding-right:13px;padding-bottom:6px;padding-left:13px;border-top-width:1px;border-right-width:1px;border-bottom-width:1px;border-left-width:1px;border-top-style:solid;border-right-style:solid;border-bottom-style:solid;border-left-style:solid;border-top-color:rgb(204,204,204);border-right-color:rgb(204,204,204);border-bottom-color:rgb(204,204,204);border-left-color:rgb(204,204,204);">&nbsp;</td> 
   <td style="margin-top:0px;margin-right:0px;margin-bottom:0px;margin-left:0px;padding-top:6px;padding-right:13px;padding-bottom:6px;padding-left:13px;border-top-width:1px;border-right-width:1px;border-bottom-width:1px;border-left-width:1px;border-top-style:solid;border-right-style:solid;border-bottom-style:solid;border-left-style:solid;border-top-color:rgb(204,204,204);border-right-color:rgb(204,204,204);border-bottom-color:rgb(204,204,204);border-left-color:rgb(204,204,204);">关键技术：buffer，channel</td> 
  </tr> 
 </tbody> 
</table>

### 问题 ###

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

[ayk7koy.png]: https://i.imgur.com/ayk7koy.png
[CeIY7A6.png]: https://i.imgur.com/CeIY7A6.png
[Mb1q2JR.png]: https://i.imgur.com/Mb1q2JR.png