Java NIO之通道Channel代码实例

喜欢ヅ旅行 2023-06-10 11:29 85阅读 0赞

文章目录

    • 代码实例
    • 控制台输出结果

相关Java NIO详解： Java NIO详解

代码实例

  1. import java.io.*;
  2. import java.nio.ByteBuffer;
  3. import java.nio.MappedByteBuffer;
  4. import java.nio.channels.FileChannel;
  5. import java.nio.file.Paths;
  6. import java.nio.file.StandardOpenOption;
  7. import java.util.concurrent.ExecutorService;
  8. import java.util.concurrent.Executors;
  10. /** * 通道channel： * 用于源节点与目标节点的连接，本身不负责存储数据，主要是配合缓冲区，负责数据的运输。 * 1.主要的实现类： * java.nio.channels.Channel接口 * --用于本地文件： * -FileChannel * --用于网络 * -SocketChannel一般用于客户端,TCP协议 * -ServerSocketChannel一般用于服务端，TCP协议 * -DatagramChannel基于UDP协议，主要用于发送和接收数据包 * 2.获取通道Channel的方法 * （1）java针对支持通道的类提供了getChannel()方法 * --本地文件 * FileInputStream/FileOutoutStream * RandomAccessFile * --网络传输 * Socket * ServerSocket * DatagramSocket * (2)在JDK1.7中的NIO2针对各个通道提供了静态方法open() * (3)在JDK1.7中的NIO2中Files工具类newByteChannel() * 3.通道之间的传输,两种方法 * transferForm() * transferTo() * */
  11. public class ChannelDome { 
  13.     /** * main测试,利用线程池进行创建线程并运行。 */
  15.     public static void main(String[] args)  { 
  16.         //1.创建可重用固定线程数量的线程池
  17.         ExecutorService executorService= Executors.newFixedThreadPool(10);
  18.         //System.out.println(executorService.getClass());//查看调用了那个接口的对应实现类。
  19.         //2.执行指定的线程的操作，需要提供的是Runnable接口或Callable接口实现类的对象
  20.         copyFileThread1 thread1=new copyFileThread1();
  21.         copyFileThread2 thread2=new copyFileThread2();
  22.         channelWriteAndRead thread3=new channelWriteAndRead();
  23.         channelTransfer thread4=new channelTransfer();
  24.         executorService.execute(thread1);
  25.         executorService.execute(thread2);
  26.         executorService.execute(thread3);
  27.         executorService.execute(thread4);
  28.         //executorService.submit();
  29.         executorService.shutdown();
  31.     }
  32.     /** * 1.利用通道进行本地文件的复制功能（非直接缓冲区） * @param copyFrom * @param copyTo * @return boolean */
  33.     public boolean copyFileByChannel(String copyFrom,String copyTo) throws IOException { 
  34.         long start=System.currentTimeMillis();
  35.         boolean result=false;
  36.         FileInputStream inputStream=null;
  37.         FileOutputStream outputStream=null;
  38.         FileChannel inputChannel=null;
  39.         FileChannel outputChannel=null;
  40.         try { 
  41.             //1.获取本地输入输出流
  42.             inputStream = new FileInputStream(copyFrom);
  43.             outputStream = new FileOutputStream(copyTo);
  45.             //2.获取本地对应输入输出通道
  46.             inputChannel = inputStream.getChannel();
  47.             outputChannel = outputStream.getChannel();
  49.             //3.分配指定大小的缓冲区
  50.             ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
  52.             //4.将输入通道中的数据存入缓冲区
  53.             while (inputChannel.read(byteBuffer) != -1) { //从当前通道position读取数据到缓冲区，若到达末尾，返回-1
  54.                 byteBuffer.flip();//切换到读取数据模式
  55.                 //5.将缓冲区的数据写入到输出通道中
  56.                 outputChannel.write(byteBuffer);
  57.                 byteBuffer.clear();//清空缓冲区
  58.                 result=true;
  59.             }
  61.         }finally { 
  62.             if(inputStream !=null){ 
  63.                 inputStream.close();
  64.             }
  65.             if(inputChannel !=null){ 
  66.                 inputChannel.close();
  67.             }
  68.             if(outputChannel !=null){ 
  69.                 outputChannel.close();
  70.             }
  71.             if(outputStream !=null){ 
  72.                 outputStream.close();
  73.             }
  74.         }
  75.         long end=System.currentTimeMillis();
  76.         System.out.println("非缓冲区复制文件耗时："+(end-start));
  77.         return  result;
  78.     }
  80.     /** * 2.利用通道进行本地文件的复制功能（直接缓冲区，利用内存映射文件） * @param copyFrom * @param copyTo * @return boolean */
  81.     public boolean copyFileByChannel2Direct(String copyFrom,String copyTo) throws IOException { 
  82.         long start=System.currentTimeMillis();
  83.         //1.获取输入输出通道
  84.         FileChannel inputChannel= FileChannel.open(Paths.get(copyFrom), StandardOpenOption.READ);
  85.         FileChannel outputChannel=FileChannel.open(Paths.get(copyTo),StandardOpenOption.WRITE,StandardOpenOption.READ,StandardOpenOption.CREATE);
  86.         //2.获取内存映射文件
  87.         MappedByteBuffer inMappedBuf=inputChannel.map(FileChannel.MapMode.READ_ONLY,0,inputChannel.size());
  88.         MappedByteBuffer outMappedBuf=outputChannel.map(FileChannel.MapMode.READ_WRITE,0,inputChannel.size());
  89.         //3.直接对缓冲区进行读写操作
  90.         byte[] dst=new byte[inMappedBuf.limit()];
  91.         inMappedBuf.get(dst);
  92.         outMappedBuf.put(dst);
  93.         //4.关闭输入输出通道
  94.         inputChannel.close();
  95.         outputChannel.close();
  96.         long end =System.currentTimeMillis();
  97.         System.out.println("直接缓冲区复制的耗时："+(end-start));
  98.         return true;
  99.     }
  101.     /** * 3.通道之间的数据传输（直接缓冲区） * @param copyFrom * @param copyTo * @return boolean */
  102.     public boolean copyFileByChannel2Transfer(String copyFrom,String copyTo) throws IOException { 
  103.         FileChannel inChannel=FileChannel.open(Paths.get(copyFrom),StandardOpenOption.READ);
  104.         FileChannel outChannel=FileChannel.open(Paths.get(copyTo),StandardOpenOption.WRITE,StandardOpenOption.READ,StandardOpenOption.CREATE);
  105.         //1.将通道中的字节数据传输到指定通道，transferTo()
  106.         inChannel.transferTo(0,inChannel.size(),outChannel);
  107.         //2.从指定通道中获取自己数据到通道中，transferFrom()
  108.         //outChannel.transferFrom(inChannel,0,inChannel.size());
  109.         return true;
  110.     }
  112.     /** * 4.通道的分散和聚合 *分散读取：将通道的数据读取到多个缓冲区Bufer中 * 聚集写入：将多个缓冲区的数据聚集写到通道Channel中 * @param writeFlie * @param readFlie */
  113.     public void channelWriteAndRead(String writeFlie,String readFlie) throws IOException { 
  114.         //1.读取指定文件
  115.         RandomAccessFile randomAccessFile=new RandomAccessFile(readFlie,"rw");
  116.         //2.获取本地文件通道
  117.         FileChannel fileChannel=randomAccessFile.getChannel();
  119.         //3.分配指定大小的缓冲区
  120.         ByteBuffer buf1=ByteBuffer.allocate(1024);//设置多大就缓存多大
  121.         ByteBuffer buf2=ByteBuffer.allocate(1024);
  122.         //4.分散读取
  123.         ByteBuffer[] bufs={ buf1,buf2};
  124.         fileChannel.read(bufs);
  126.         for(ByteBuffer byteBuffer:bufs){ 
  127.             byteBuffer.flip();
  128.             System.out.println("每个缓冲区的数据如下：");
  129.             System.out.println(new String(byteBuffer.array(),0,byteBuffer.limit()));
  131.         }
  132.         //5.聚集写入(指定文件)
  133.         RandomAccessFile randomAccessFile1=new RandomAccessFile(writeFlie,"rw");//指定写到那个文件下
  134.         FileChannel fileChannel1=randomAccessFile1.getChannel();
  135.         fileChannel1.write(bufs);
  136.     }
  139. }
  141. //创建线程1测试,非缓冲区文件复制
  142. class copyFileThread1 implements Runnable{ 
  143.     ChannelDome channelDome=new ChannelDome();
  144.     String copyFrom="G:\\copyFromFile\\copyForm.log";
  145.     String copyTo="H:\\copyToFile\\NoDirect\\copyTo1.log";
  146.     @Override
  147.     public void run() { 
  148.         try { 
  149.             System.out.println(Thread.currentThread() +"当前线程正在执行利用非缓冲区本地文件复制功能");
  150.             channelDome.copyFileByChannel(copyFrom,copyTo);
  151.         } catch (IOException e) { 
  152.             e.printStackTrace();
  153.         }
  154.     }
  155. }
  157. //创建线程2测试，
  158. class copyFileThread2 implements Runnable{ 
  159.     ChannelDome channelDome =new ChannelDome();
  160.     String copyFrom="G:\\copyFromFile\\copyForm.log";
  161.     String copyTo="H:\\copyToFile\\Direct\\copyTo2.log";
  162.     @Override
  163.     public void run() { 
  164.         try { 
  165.             System.out.println(Thread.currentThread() +"当前线程正在执行利用缓冲区本地文件复制功能");
  166.             channelDome.copyFileByChannel2Direct(copyFrom,copyTo);
  168.         } catch (IOException e) { 
  169.             e.printStackTrace();
  170.         }
  171.     }
  172. }
  174. //通道的分散读取和聚集写入线程测试
  175. class channelWriteAndRead implements Runnable{ 
  177.     ChannelDome channelDome=new ChannelDome();
  178.     String writeFile="G:\\copyFromFile\\copyForm.log";
  179.     String readFile="H:\\copyToFile\\Read\\read.log";
  181.     @Override
  182.     public void run() { 
  183.         try { 
  184.             System.out.println(Thread.currentThread() +"当前线程正在执行通道的分散读取和聚集写入线程功能");
  185.             channelDome.channelWriteAndRead(readFile,writeFile);
  186.         } catch (IOException e) { 
  187.             e.printStackTrace();
  188.         }
  189.     }
  190. }
  191. //通道之间的传输线程测试
  192. class channelTransfer implements Runnable{ 
  193.     ChannelDome channelDome=new ChannelDome();
  194.     String copyForm="G:\\copyFromFile\\copyForm.log";
  195.     String copyTo="H:\\copyToFile\\transfer\\transfer.log";
  196.     @Override
  197.     public void run() { 
  198.         try { 
  199.             System.out.println(Thread.currentThread() +"当前线程正在执行通道之间的传输线程功能");
  200.             channelDome.copyFileByChannel2Transfer(copyForm,copyTo);
  201.         } catch (IOException e) { 
  202.             e.printStackTrace();
  203.         }
  204.     }
  205. }

控制台输出结果

在这里插入图片描述

发表评论

表情：
评论列表 （有 0 条评论，85人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Java NIO 之Channel

    定义 用于源节点和目标节点之间的连接。nio中负责缓冲区中数据传输，Channel本地并不存储数据，而是配合缓冲区进行数据传输。你可以把它理解成io中的流。 结

    偏执的太偏执、偏执的太偏执、/ 0 赞/ 346 阅读