大数据 NIO

最新推荐文章于 2021-03-06 19:26:09 发布
最新推荐文章于 2021-03-06 19:26:09 发布
阅读量296 收藏 1
点赞数
分类专栏： java基础 大数据 文章标签： 大数据 任务调度 计算机 内存 线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chou_out_man/article/details/79391326
版权

NIO

一、基础回顾

a 、 进程与线程

  1. 进程
    1. 进程： 程序加载到内存中之后被CPU所计算的过程 — 进程是计算机资源分配 、 任务调度的最小单位
    2. 三个维度考虑进程：
      1. 物理内存维度：每一个进程都要分配一块连续的内存空间（首地址 、 尾地址）
      2. 进程执行维度/逻辑维度： 每一个进程都能被CPU计算 ， 每一个进程都能挂起然后让另外的进程被CPU计算 — 对于单核CPU而言 ， 每一个时刻只能计算一个进程 。 对于windows而言 ， （即使是多核CPU）默认只用一个核处理 。 对于Linux而言 ， 有几个核就用几个。 — 从微观上 ， 计算机是串行处理进程 。 从宏观上而言 ， 是多个进程来并行执行 。 — 引入多道编程
      3. 时间维度： 在每一个时间段内 ， 进程一定是向前扑进的 。
    3. 为什么要引入进程模型？
      1. 减少程序响应时间 ， 提高使用效率 。
      2. 提高CPU利用率 。 IO事件（程序与硬件之间的交互）
    4. 进程的产生事件：
      1. 系统启动时 ， 会创建系统进程 。
      2. 用户请求创建进程时 ， 创建用户进程 。 （打开应用）
      3. 主进程自动启动子进程 。 （QQ等程序启动之后 ， 会自动启动安全守护进程 。 ）
    5. 进程的消亡事件
      1. 进程任务执行完毕 ， 自动销毁
      2. 进程执行过程中出现错误或异常， 导致进程退出 。 意外身亡
      3. 一个进程被另外的进程强制关闭 他杀
    6. 进程的状态 （除启动 、 消亡）
      1. 就绪 就绪->运行
      2. 运行 运行->阻塞 运行->就绪
      3. 阻塞 阻塞->就绪
  2. 线程
    1. 线程： 是进程中执行某一个具体的任务 。 线程本质上是简化版的进程 。 线程不具有进程资源分配 、 任务调度的资格 。 一个进程中至少有一个线程是在执行的 。 — 线程是任务执行的最小单位 。
  3. 进程的任务调度算法
    1. 时间片轮转算法
    2. 优先级调度算法
    3. 短任务优先算法
    4. FICS 先来先执行

b、 Socket

  1. BIO BlockingIO— 阻塞式IO — 阻塞在一些场景下会相对影响效率 ； 由于流具有方向性， 所以在传输数据时往往要创建多个流对象。 如果一些流长时间不使用 ， 却依然保持连接， 会造成资源的大量浪费 。 无法从流中准确的抽取一段数据
  2. 引入 NIO

二、 NIO

  1. NIO — NewIO — NonBlockingIO — 非阻塞式IO — 基于通道和缓冲区。
  2. Buffer类 — 一个基本数据类型的容器 。 缓冲区

  3. Buffer子类 ByteBuffer

    1. 底层是依靠字节数组来存储数据 理解 容量位capacity 、 position 操作位 、 limit限制位
    2. 在读取数据之前往往要做一次filp操作 ， 反转缓冲区 ， 先将限制位设置为操作位 ， 然后将操作位归0
    3. 重绕缓冲区 – 将操作位归0 ， 限制位不变

    4. 代码1

      import java.nio.ByteBuffer;

public class BufferDemo {
     public static void main(String[] args) {
//       //创建缓冲区 ， 并指定了大小为1024个字节
         //当创建好缓冲区的时候 ， 就有了一下属性
         //1. capacity 容量位 --- 表示缓冲区容量
         //2. position 操作位 --- 表示要操作的位置 ---- 当缓冲区刚刚创建的时候 ， 操作位默认为0  ， 每添加一个字节的数据 ， position就会向后挪一位
         //3. limit 限制位 ---- 表示position 所能达到的最大位置 --- 当缓冲区刚刚创建的时候 ， limit就是容量位 。
         //获取数据时 ， 默认是从操作位开始获取的
//       ByteBuffer buffer = ByteBuffer.allocate(1024);//最多能存放1k数据
//       //向缓冲区添加数据
//       buffer.put("hello".getBytes());
         //以上方法存在资源浪费

        //******************************************************* 
//       //在已知具体数据的情况下 ， 建议使用这种方法创建缓冲区
         //使用wrap方式创建缓冲区 ， 参数实际上是一个字节数组  ， 底层实际上就是将参数字节数组复制给底层的实际存储数据的数组 ， 此时操作位并没有改变还是0 
         //为什么是数组使用复制 ， 而不是直接使用赋值？
         //保持数据的不变和唯一
//       ByteBuffer buffer = ByteBuffer.wrap("hello".getBytes());//创建与数据大小相对应的缓冲区
//       
//       //获取数据 ,   每一次获取  ， 只能获取一个字节
         byte b = buffer.get();
         System.out.println(b);
//       
//       //获取缓冲区所有数据
//       while(buffer.hasRemaining()) {//判断是否还有剩余数据
//       
//           byte b = buffer.get();
//           System.out.println(b);
//       }
         //*******************************************************
        //但是使用固定缓冲区大小的情况下获取数据会出现获取到0的情况 ， 需要将默认的操作位归0 ， 并且读取到有效数据结束即可 
         ByteBuffer buffer = ByteBuffer.allocate(10);
         buffer.put("hello".getBytes());

         //遍历方法一 ： 记录操作位位置后循环遍历
//       int position = buffer.position();
//       for(int i = 0 ;i < position ; i++) {
//           System.out.println(buffer.get(i));
//       }
         //遍历方法二： 设置限制位为操作位后  ， 操作位归0   遍历
//       buffer.limit(buffer.position());
//       buffer.position(0);
//       while(buffer.hasRemaining()) {
//           System.out.println(buffer.get());
//       }
         //遍历方法三： 反转缓冲区
         //先将限制位设置为当前的操作位 ， 然后把操作位归0
         buffer.flip();
//       buffer.hasRemaining()该方法  本质上就是判断操作位是否小于限制位
         while(buffer.hasRemaining()) {
             System.out.println(buffer.get());
         }

         //获取缓冲区中的底层数组
         byte[] array = buffer.array();//底层也是使用的数组复制 ， 返回的是整个底层数组 ， 而不是有效数据
         System.out.println(new String(array , 0 , buffer.position()));

         //如果使用过反转
         buffer.flip();
         System.out.println(new String(array , 0 , buffer.limit()));
    }
}

    5. 代码2

      import java.nio.ByteBuffer;

public class BufferDemo2 {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocate(10);
        buffer.put("hello".getBytes());

        System.out.println("操作位："+ buffer.position());
        System.out.println("限制位："+ buffer.limit());
//      buffer.flip();
//      System.out.println("操作位："+ buffer.position());
//      System.out.println("限制位："+ buffer.limit());
        //重绕缓冲区
        buffer.rewind(); //作用： 将操作位归0  ， 限制位不变 。 
        System.out.println("操作位："+ buffer.position());
        System.out.println("限制位："+ buffer.limit());
    }
}

  4. Channel 通道

    1. SocketChannel

      1. 客户端步骤
        1. 打开客户端通道 – open
        2. 将客户端通道设置为非阻塞
        3. 发起连接
        4. 人为阻塞 ， 防止产生无效连接 finishConnect()
        5. 写出数据
      2. 服务器端步骤
        1. 打开服务器端通道
        2. 绑定侦听的端口号
        3. 设置为非阻塞
        4. 接收连接
        5. 人为阻塞 ， 防止没有获取真正的连接
        6. 读取数据

      3. 代码示例： 

        客户端
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

public class SocketChannelDemo {
    public static void main(String[] args) throws IOException, InterruptedException {
        //打开通道
        //SocketChannel 默认为阻塞连接  此时和Socket基本一样
        SocketChannel s = SocketChannel.open();
        //设置SoceketChannel为非阻塞的
        s.configureBlocking(false);
        //发起连接
        s.connect(new InetSocketAddress("localhost", 8090));
        //由于SoceketChannel为非阻塞的 ， 所以不能保证连接的真正建立
        //在实际开发中往往会认为的设置阻塞 ， 来保证连接的建立
        //判断连接是否成功 ， 如果没有连接成功finishConnect()底层会试图再次建立连接
        //如果多次试图连接没有成功 ， 则报错
        while(!s.finishConnect()) ;

        //写出数据
        s.write(ByteBuffer.wrap("hello".getBytes()));

        //获取服务器端的响应
        Thread.sleep(100);
        ByteBuffer b = ByteBuffer.allocate(100);
        s.read(b);
        b.flip();
        System.out.println(new String(b.array() , 0 , b.limit()));
//      关闭通道  
        s.close();

    }


服务端
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;

public class ServerSocketChannelDemo {
    public static void main(String[] args) throws IOException, InterruptedException {
        //打开服务器通道
        ServerSocketChannel s=  ServerSocketChannel.open();

        //绑定侦听的端口
        s.bind(new InetSocketAddress( 8090));
        //设置非阻塞
        s.configureBlocking(false);

        //接收连接
        SocketChannel accept = s.accept();

        //由于ServerSocketChannel是非阻塞的 ， 所以可能出现还没有客户端联入 但是服务器已经结束的现象
        //所以需要人为的设置为阻塞的 。 
        while(accept == null) {
            accept = s.accept();
        }
        //将socketChannel设置为非阻塞
        accept.configureBlocking(false);
        //读取数据
        ByteBuffer buffer = ByteBuffer.allocate(100);
        accept.read(buffer);
        buffer.flip();
        System.out.println(new String(buffer.array() , 0 , buffer.limit()));

        //向客户端做出响应
        accept.write(ByteBuffer.wrap("服务器端接收成功！".getBytes()));
        Thread.sleep(1000);//如果不加延时 ， 服务器端写出数据立即结束 ， 此时客户端还没有接收完数据会报错
    }
}

    2. 通道特点 ：

      1. 能够进行数据的双向传输 ， 减少流的数量 ， 降低服务器的内存消耗
      2. 由于数据时存储在缓冲区的 ， 所以我们可以根据缓冲区的数据做定向操作 **
      3. 能够利用一个或者少量的服务器来完成大量的用户的请求处理（一个服务器能够接受多个客户端的请求） — NIO适用于短任务场景 ， BIO适用于长任务场景

  5. Selector 选择器

    1. 每一个客户端 或者服务器端都需要注册到选择器上 ， 让这个选择器进行管理 ， 选择器管理的时候需要监听事件：
      1. 可连接事件 — 一般是客户端
      2. 可接受事件 — 一般是服务器端
      3. 可读事件
      4. 可写事件

    2. 代码：

      客户端
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;


public class ClientDemo {
    public static void main(String[] args) throws IOException {

        //打开客户端的通道
        SocketChannel sc = SocketChannel.open();
        //设置为非阻塞
        sc.configureBlocking(false);
        //获取选择器
        Selector selc  = Selector.open();
        //将通道注册到选择器上
        sc.register(selc, SelectionKey.OP_CONNECT);//并给予连接权限
        //发起连接
        sc.connect(new InetSocketAddress("localhost", 8080));

        while(true) {
            //进行选择 ， 筛选出有用的连接
            selc.select();
            //获取筛选之后有用的事件
            Set<SelectionKey> keys = selc.selectedKeys();
            Iterator<SelectionKey> iterator = keys.iterator();
            while(iterator.hasNext()) {
                //将遍历到的事件读取出来
                SelectionKey next = iterator.next();
                //可能向服务器发起连接
                //可能向服务器写数据
                //可能接收服务器的数据
                if(next.isConnectable()) {//判断是否是一个连接事件
                    //从该事件中获取到对应的通道
                    SocketChannel scx = (SocketChannel) next.channel();
                    //判断之前的连接是否成功
                    while(!scx.finishConnect());
                    //连接成功之后   进行读写操作
                    scx.register(selc, SelectionKey.OP_READ | SelectionKey.OP_WRITE);
                }
                if(next.isWritable()) {
                    //从该事件中获取到对应的通道
                    SocketChannel scx = (SocketChannel) next.channel();

                    //写数据
                    scx.write(ByteBuffer.wrap("读取数据成功！".getBytes()));
                    //执行完写操作之后 ， 需要将这个通道的写权限注销掉  ，防止不停地向服务器写数据
                    scx.register(selc, next.interestOps() ^ SelectionKey.OP_WRITE);//可用^ 或& ~
                }
                if(next.isReadable()) {
                    //从该事件中获取到对应的通道
                    SocketChannel scx = (SocketChannel) next.channel();

                    //读数据
                    ByteBuffer buffer = ByteBuffer.allocate(100);
                    scx.read(buffer);
                    buffer.flip();
                    System.out.println(new String(buffer.array() , 0 , buffer.limit()));

                    //移除可读事件
                    scx.register(selc, next.interestOps() & ~SelectionKey.OP_READ);
                }

                //为了防止事件移除失败 ， 处理完成后将事件移除
                iterator.remove();

            }
        }


    }
}


服务器端
import java.io.IOException;
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 javax.swing.plaf.SliderUI;

public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //打开服务器端通道
        ServerSocketChannel ssc = ServerSocketChannel.open();
        //绑定侦听的端口号
        ssc.bind(new InetSocketAddress(8080));//接收任何IP客户端8080端口传来的数据
        //将通道设置为非阻塞
        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 sscx = (ServerSocketChannel) key.channel();
                    //接受连接
                    SocketChannel sc = sscx.accept();
                    while(sc == null) {
                        sscx.accept();
                    }
                    //设置为非阻塞
                    sc.configureBlocking(false);
                    //注册一个可读事件
                    sc.register(selc, SelectionKey.OP_READ | SelectionKey.OP_WRITE);

                }
                if(key.isReadable()) {
                    //获取事件的通道
                    SocketChannel scx = (SocketChannel) key.channel();
                    //读取数据
                    ByteBuffer buffer = ByteBuffer.allocate(100); 
                    scx.read(buffer);
                    buffer.flip();
                    System.out.println(new String (buffer.array() , 0 , buffer.limit()));
                    //消除可读事件
                    scx.register(selc, key.interestOps() ^ SelectionKey.OP_READ);
                }
                if(key.isWritable()) {
                    //获取事件的通道
                    SocketChannel scx = (SocketChannel) key.channel();
                    //写出数据
                    scx.write(ByteBuffer.wrap("hello".getBytes()));
                    //消除可以写事件
                    scx.register(selc, key.interestOps() & ~SelectionKey.OP_WRITE);

                }

                it.remove();
            }
        }

    }
}

三 、 考虑 ： 数据粘包怎么处理？

  1. 数据定长 — 如果数据长度不够 ， 填充无用数据 — 怎样区分无用数据
  2. 约定数据结尾符号 — 结尾符号可能会和实际的数据内容冲突
  3. 约定协议 — 序列化/反序列化 — 底层实际上是约束了起始和结束的协议
chou_out_man
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
大数据基础（一）：Java NIO概述及简单示例
khxu666的博客
07-04 2076
1. IO与NIO的区别：为什么需要NIO？ 1.1 java IO中的socket连接 在最初的java版本中，对于接受socket连接的服务器，其基本的处理步骤是： 1、实例化一个ServerSocket对象； 2、将实例化后的Serversocket对象绑定到某个端口上； 3、使用accept( )方法监听通过此端口的socket连接，这是accept( )方法会一直阻塞直到有...
大数据学习之旅——NIO源码
01-10
对应文章https://blog.csdn.net/qq_39188039/article/details/86216204
大数据之NIO
qq_38815481的博客
04-20 278
五种IO模型—运维 聊聊Linux5种IO模型 1.五种IO模型 IO (Input/Output，输入/输出)即数据的读取（接收）或写入（发送）操作，通常用户进程中的一个完整IO分为两阶段：用户进程空间<–>内核空间、内核空间<–>设备空间（磁盘、网络等）。IO有内存IO、网络IO和磁盘IO三种，通常我们说的IO指的是后两者。 LINUX中进程无法直接操作I...
大数据-高并发——NIO
READLEAF的博客
07-27 229
NIO: NIO是non-blocking IO,又称为New IO.即：同步非阻塞式IO. NIO是非阻塞式IO也是一种能够提供多路复用的IO.可以实现双向通信。 NIO主要涉及到三部分： Buffer, Channel, Selector Buffer, 缓冲区：底层使用数组实现的。用于存储数据的容器。Buffer在java中提供了一些基本数据类型的缓冲区。 ByteBuffer Channel通道。 用于传输数据的。 实现双向传输的基础。 基于文件传输：FileChannel 基于UDP协议传输:D
大数据-基础NIO-什么是NIO？NIO三大组件Buffer、Channel、Selector的特点
weixin_47055922的博客
08-20 5815
一、NIO简介 1、Java中的IO介绍 BIO：BlockingIO，同步式阻塞式IO，即传统的IO，是Java中最早期的流 NIO：Non-BlockingIO，又称New IO，同步式非阻塞式IO，是JDK1.4提供的流 AIO：AsynchronousIO，异步式非阻塞式IO，可以认为是NIO的二代版本，是JDK1.8提供的流 2、概述 NIO是JDK1.4出现的一个新的用于进行数据传输的流 全称是Non-Blocking IO，是一种同步式非阻塞式的IO，也是一种能供进行多路复用的I
使用nio导出千万大数据
最新发布
06-07
使用nio导出千万大数据
大数据面试题
10-22
例如： 77、 hive如何从hbase中读取数据？ 78、 zookeeper相关知识介绍 79、 flume的扇入扇出 80、 hive的建表语句， hive如何存储数据 81、 hadoop版本 ...83、 Java nio nio组成部分（channel buffer selector）
Java NIO 中文版.pdf
06-28
深入解析YARN结构设计与实现原理，适合于有兴趣深入了解hadoop结构设计的童靴。
java NIO 写文件
11-26
java nio 写文件样例，java写大数据文件时提高性能
36.大数据之旅——[高并发系列] NIO
零零天
01-22 380
说明：36章开始应该在大数据前面的内容，放在35章后面来说了 BIO网络通信 概述 网络编程的基本模型是Client/Server模型，也就是两个进程之间进行相互通信，其中服务端提供位置信息（绑定的IP地址和监听端口），客户端通过连接操作向服务端监听的地址发起连接请求，通过三次握手建立连接，如果连接建立成功，双方就可以通过网络套接字（Socket）进行通信。 在基于传统同步阻塞模型开发中，Ser...
大数据处理之java NIO框架Grizzly2.2
happy_boys_的专栏
03-05 1027
Grizzly框架的2.2版本带来了相当多的特性和该进，而且加入了最新WebSocket规范的实现。Grizzly是一个应用程序框架，专门用于解决海量用户访问服务器时产生的各种问题。Grizzly框架诞生于GlassFish项目，能够帮助开发人员利用java NIO API构建可扩展、高性能、健壮的服务器以及可伸缩的服务器端应用。   摘自《程序员》2012.02
Java nio 读取数据代码_Java的; NIO - 从SocketChannel读取大量数据
weixin_34180753的博客
03-06 315
我正在编写一个非常简单的网络库，以便将来可以用于其他项目。现在，我无法处理阅读操作。我有一个负责处理来自SocketChannels的事件的类，它还包含输入和输出缓冲区。要初始化缓冲区，您需要定义它的大小。所以默认情况下，所有缓冲区的大小都是1024字节。我遇到的问题是，如果我读取的数据包大于1024字节，我会得到一个异常。这可以通过默认分配更大的缓冲区来解决(例如2048字节，而不是1024)，...
大数据成神之路-JVM&NIO基础入门
weixin_44386969的博客
02-17 211
大家不要怕~  今天的推文只有1条~  因为我发现~ 微信编辑太慢了~ 还有条数限制~  于是乎我在Github搞事情了开始~ 不要怕 后面我会逐渐更新到公众号~ 再把目录放出来~ 方便阅读~ GitHub地址： https://github.com/wangzhiwubigdata/God-Of-BigData 在这里相信有许多想要学习大数据的同学，大家可以+下大数据学习裙： ...
大数据互联网架构阶段 QuartZ定时任务+RabbitMQ消息队列
热门推荐
chou_out_man的博客
02-02 1万+
QuartZ定时任务+RabbitMQ消息队列 一 、QuartZ定时任务解决订单系统遗留问题 情景分析: 在电商项目中 ， 订单生成后 ， 数据库商品数量-1 ， 但是用户迟迟不进行支付操作 ， 这样不仅导致没有生成效益， 而且导致后来的用户无法购买的问题 。 这种情况的订单成为恶意订单 解决方案： 早期： 虚拟商品数量 ， 数量减到0时 ，仍然可以减。 但是这种办法显然没有根本的...
大数据 互联网架构阶段 电商项目简介
chou_out_man的博客
01-11 6580
电商项目简介零、目录 电商项目特点 电商项目技术难点 电商项目简介 开发工具 电商项目架构 开发环境 一、电商项目特点 分布式 数十台服务器，甚至百台、千台、万台，包括：Nigix负载均衡集群、Tomcat集群、Redis缓存集群、RabbitMQ消息队列集群、MySQL主从、Solr全文检索集群等。 分布式集群 分布式:单个任务拆分成众多的子任务,单个实例完成其中之一,众多实例合作完成一个任务
使用Redis 实现消息队列
chou_out_man的博客
03-23 6412
一 、为什么要用Redis实现轻量级MQ？ MQ的主要作用： 应用解耦 异步化消息 流量削峰填谷 目前使用比较多的是ActiveMQ 、 RabbitMQ 、 ZeroMQ 、 Kafka 、 MetaMQ 、 RocketMQ等 在业务实现过程中 ， 就算没有大量的流量 ， 解耦和异步化也是处处可用 ， 此时MQ就显得尤为重要 。 但与此同时MQ也是一个蛮重的组件，例如我们如果用Rab...
大数据互联网架构阶段 全文检索技术
chou_out_man的博客
02-02 6181
全文检索一、 全文检索的引出 我们生活中的数据总体分为两种：结构化数据 和非结构化数据 。 结构化数据： 指具有固定格式或有限长度的数据，如数据库，元数据等。 非结构化数据： 指不定长或无固定格式的数据，如邮件，word文档等。 当然有的地方还会提到第三种，半结构化数据，如XML，HTML等，当根据需要可按结构化数据来处理，也可抽取出纯文本按非结构化数据来处理。 非结构化数据又一种叫法叫全文数据。
大数据互联网架构阶段 大型电商项目数据库设计时应该注意的点
chou_out_man的博客
02-03 3937
大型电商项目数据库设计时应该注意的点 一、 id的设计 int（int）类型： 性能高 ， 但是分布式数据库时 ， id易重复 long（bigint）类型：性能高 ， 比int类型容纳的数据更多 ， 但是还是会重复 String（varchar） ： 使用UUID ， 几乎不会重复 ， 但是性能略低 大型电商的数据库是分布式的么？ 究其原因 ， 数据库分布式设计就是为了提高数据库
Java8如何读取一个大数据的csv文件，并取其前N个字段生成新文件
05-18
Java8可以使用Stream API来读取大数据的csv文件，并使用Stream的操作来筛选出前N个字段。以下是一个简单的示例代码： ```java import java.nio.charset.StandardCharsets; import java.nio.file.Files; import java...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值