[关闭]
@lemonguge 2015-07-03T08:23:53.000000Z 字数 6630 阅读 452

Java nio（四）

NIO

管道Pipe

在之前介绍了关于Socket流的通道和文件通道，这里将介绍nio的管道Pipe。查看API可以发现该类只有有三个方法，不过应该注意到，它具有两个嵌套类：Pipe.SinkChannel和Pipe.SourceChannel。

简单的说，数据会被写到sink 通道，从source 通道读取，以下是Pipe原理的图示：

管道的原理图

现在来明确使用管道的基本思路，首先我们需要创建管道，通过Pipe的静态open()方法打开管道。

向管道写入数据，需要访问Pipe.SinkChannel，通过管道的sink()获取可写入管道。我们可以通过该管道的write()方法将缓冲区的数据写入。

从管道读取数据，需要访问Pipe.SourceChannel，通过管道的source()获取可读取管道。可以通过该管道的read()方法将数据读取到缓冲区。当该通道已到达流的末尾，则返回-1。

以下是一个完整的管道示例：

  1. import java.io.IOException;
  2. import java.nio.ByteBuffer;
  3. import java.nio.channels.Pipe;
  5. public class PipeDemo {
  7.     public static void main(String[] args) throws IOException {
  8.         int length = 1024;
  9.         Pipe pipe = Pipe.open();
  10.         Pipe.SinkChannel sink = pipe.sink();
  11.         Pipe.SourceChannel source = pipe.source();
  12.         ByteBuffer buf = ByteBuffer.wrap("Hello World!".getBytes());
  13.         while (buf.hasRemaining())
  14.             sink.write(buf);
  15.         // 如果不关闭可写入管道，可读取管道的read方法会一直阻塞，不会返回-1
  16.         sink.close(); 
  17.         buf = ByteBuffer.allocate(length);
  18.         byte[] dst = new byte[length];
  19.         int size = 0;
  20.         while ((size = source.read(buf)) != -1) {
  21.             buf.flip();
  22.             buf.get(dst, 0, size);
  23.             System.out.println(new String(dst, 0, size));
  24.             buf.clear();
  25.         }
  26.         source.close();
  27.     }
  28. } /* Output:
  29. Hello World!
  30. *///:~

文件锁FileLock

文件锁就像是同步时的对象锁，它们是劝告式（advisory）的锁。劝告式的锁又称询问式的锁，这种类型的锁将拥有互斥的效果。锁的效果与操作系统有关，锁还有另一种效果，强制性（mandatory），当某个进程获得锁后，操作系统将保证其他进程无法操作共享资源。

对于文件锁FileLock的两种不同的锁定方式，可以文件锁分为两种：

通过查看关于FileChannel文件通道的API，发现有四种获取锁的方式：

lock()方法为阻塞式方法、tryLock()方法是非阻塞的方法，如果想通过tryLock()获取锁，可以放在do..while..进行循环判断。当拥有锁后，可以调用FileLock对象的release()释放锁，尝试获得锁的其他任何线程都有机会获得它。

以下是一个关于文件锁的示例：

  1. import java.io.BufferedReader;
  2. import java.io.File;
  3. import java.io.FileInputStream;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.io.RandomAccessFile;
  7. import java.nio.channels.FileChannel;
  8. import java.nio.channels.FileLock;
  10. class LockFile implements Runnable {
  11.     private FileLock lock;
  12.     private RandomAccessFile raf;
  13.     public LockFile(FileLock lock, RandomAccessFile raf) {
  14.         this.lock = lock;
  15.         this.raf = raf;
  16.     }
  17.     @Override
  18.     public void run() {
  19.         try {
  20.             // 判断锁的类型，true为共享锁
  21.             System.out.println(lock.isShared() ? "共享锁" : "独占锁");
  22.             Thread.sleep(3000);
  23.             System.out.println("释放锁");
  24.             // 释放锁
  25.             lock.release();
  26.             raf.close();
  27.         } catch (IOException e) {
  28.             e.printStackTrace();
  29.         } catch (InterruptedException e) {
  30.             e.printStackTrace();
  31.         }
  32.     }
  33. }
  34. // 普通的文件读取
  35. class FileRead implements Runnable {
  36.     private File file;
  37.     public FileRead(File file) {
  38.         this.file = file;
  39.     }
  40.     @Override
  41.     public void run() {
  42.         try {
  43.             System.out.println("读取文件");
  44.             FileInputStream fis = new FileInputStream(file);
  45.             BufferedReader br = new BufferedReader(new InputStreamReader(fis));
  46.             String line = null;
  47.             while ((line = br.readLine()) != null)
  48.                 System.out.println(line);
  49.             br.close();
  50.         } catch (IOException e) {
  51.             e.printStackTrace();
  52.         }
  54.     }
  56. }
  58. public class FileLockDemo {
  60.     public static void main(String[] args) throws InterruptedException, IOException {
  61.         // 在当前项目下有file.txt文件，文件有两行内容
  62.         // 分别为“abc123”和“你好”
  63.         File file = new File("file.txt");
  64.         RandomAccessFile raf = new RandomAccessFile(file, "rw");
  65.         // 查看传入共享锁和独占锁的输出结果
  66.         new Thread(new LockFile(getLock(raf, false), raf)).start();
  67.         // 当传入独占锁时，设置睡眠时间为1000和4000的输出结果
  68.         Thread.sleep(1000);
  69.         new Thread(new FileRead(file)).start();
  70.     }
  72.     // 设置isShared为true将获得共享锁、false获得独占锁
  73.     private static FileLock getLock(RandomAccessFile raf, boolean isShared) throws IOException {
  74.         FileChannel fileChnl = raf.getChannel();
  75.         if (isShared)
  76.             return fileChnl.lock(0, fileChnl.size(), true); // 同样锁定整个文件
  77.         else
  78.             // 获取独占锁，必须为可写入通道
  79.             return fileChnl.lock();
  80.     }
  81. } /* Output:
  82. 独占锁
  83. 读取文件
  84. java.io.IOException: 另一个程序已锁定文件的一部分，进程无法访问。
  85.     at java.io.FileInputStream.readBytes(Native Method)
  86.     at java.io.FileInputStream.read(FileInputStream.java:272)
  87.     at sun.nio.cs.StreamDecoder.readBytes(StreamDecoder.java:283)
  88.     at sun.nio.cs.StreamDecoder.implRead(StreamDecoder.java:325)
  89.     at sun.nio.cs.StreamDecoder.read(StreamDecoder.java:177)
  90.     at java.io.InputStreamReader.read(InputStreamReader.java:184)
  91.     at java.io.BufferedReader.fill(BufferedReader.java:154)
  92.     at java.io.BufferedReader.readLine(BufferedReader.java:317)
  93.     at java.io.BufferedReader.readLine(BufferedReader.java:382)
  94.     at nio.FileRead.run(FileLockDemo.java:50)
  95.     at java.lang.Thread.run(Thread.java:744)
  96. 释放锁
  97. *///:~

当传入共享锁，睡眠时间为1000ms时，会显示以下输出结果：

  1. 共享锁
  2. 读取文件
  3. abc123
  4. 你好
  5. 释放锁

当传入独占锁，睡眠时间为4000ms时，则会显示以下输出结果：

  1. 独占锁
  2. 释放锁
  3. 读取文件
  4. abc123
  5. 你好

如果获取一个独占锁，那么其他人就不能获得同一个文件或者文件的一部分上的锁。如果获得一个共享锁，那么其他人可以获得同一个文件或者文件一部分上的共享锁，但是不能获得独占锁。

以下是一个线程获得了共享锁后，另一个线程想获得独占锁的示例：

  1. import java.io.File;
  2. import java.io.FileInputStream;
  3. import java.io.IOException;
  4. import java.io.RandomAccessFile;
  5. import java.nio.channels.FileLock;
  7. class ShareLock implements Runnable {
  8.     private File file;
  9.     public ShareLock(File file) {
  10.         this.file = file;
  11.     }
  12.     @Override
  13.     public void run() {
  14.         FileInputStream fis;
  15.         try {
  16.             fis = new FileInputStream(file);
  17.             System.out.println("获取共享锁");
  18.             FileLock lock = fis.getChannel().lock(0, fis.available(), true);
  19.             Thread.sleep(3000);
  20.             lock.release();
  21.             System.out.println("释放共享锁");
  22.         } catch (IOException e) {
  23.             e.printStackTrace();
  24.         } catch (InterruptedException e) {
  25.             e.printStackTrace();
  26.         }
  27.     }
  28. }
  30. public class SharedLockDemo {
  32.     public static void main(String[] args) throws IOException, InterruptedException {
  33.         File file = new File("file.txt");
  34.         new Thread(new ShareLock(file)).start();
  35.         RandomAccessFile raf = new RandomAccessFile(file, "rw");
  36.         // 保证会先获得共享锁
  37.         Thread.sleep(1000);
  38.         System.out.println("获取独占锁");
  39.         // 获得独占锁
  40.         raf.getChannel().lock();
  41.         // 关闭文件通道，也会使FileLock的生命周期结束
  42.         raf.close();
  43.     }
  44. } /* Output:
  45. 获取共享锁
  46. 获取独占锁
  47. Exception in thread "main" java.nio.channels.OverlappingFileLockException
  48.     at sun.nio.ch.SharedFileLockTable.checkList(FileLockTable.java:255)
  49.     at sun.nio.ch.SharedFileLockTable.add(FileLockTable.java:152)
  50.     at sun.nio.ch.FileChannelImpl.lock(FileChannelImpl.java:1011)
  51.     at java.nio.channels.FileChannel.lock(FileChannel.java:1052)
  52.     at nio.SharedLockDemo.main(SharedLockDemo.java:44)
  53. 释放共享锁
  54. *///:~

文件锁定并不总是出于保护数据的目的，可能临时锁定一个文件以保证特定的写操作成为原子的，而不会有其他程序的干扰。

字符集Charset

在我的Java I/O系列的第三篇文章中转换流部分，曾经提到nio中的字符集Charset类，当时通过该类获得系统的默认编码。接下来我要讲述的类都在java.nio.charset包中，查看API可以发现是这么描述字符集的：

16位的Unicode代码单元序列（字符序列）和字节序列之间的指定映射关系。

Java语言被定义为基于Unicode，即使你把类名写成中文也同样能运行。

  1. public class 你好 {
  2.     public static void main(String[] args) {
  3.         System.out.println("你好");
  4.     }
  5. } /* Output:
  6. 你好
  7. *///:~

解码与编码

在Java I/O中提到过解码与编码，转换流InputStreamReader和OutputStreamWriter就分别对应着解码和编码。不过在Java的一切都是对象的思想下，编码和解码也变成了对象，我们把编码称为CharsetEncoder编码器，解码称为CharsetDecoder解码器。简单的来说，解码用于读取，编码用于写入。

我们可以通过字符集Charset类的静态forName()方法获取指定字符集名称的字符集。

通过此字符集，可以通过newDecoder()创建一个解码器，通过newEncoder()方法创建一个编码器。

可以通过CharsetDecoder解码器的decode()方法将字节缓冲区解码到新分配的字符缓冲区，然后我们可以处理字符了。

如果想要写好数据，必须使用CharsetEncoder编码器的encode()方法将字符缓冲区编码到新分配的字节缓冲区。

解码器和编码器一般可以和标准I/O流结合使用，即在构造转换流时当作参数传入。

后记：nio库有大量的特性，它为我们最熟悉的标准I/O过程也带来了新的活力，通道和缓冲区可以做的事情几乎都可以用原来的面向流的类来完成。但是通道和缓冲区可以以接近系统所允许的最大速度完成这些相同的旧操作。知识点挺多的，不过终于写完啦，写于2015年7月3日。

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注