IO Streams Overview#

IO stands for Input/Output, input and output. The process of data entering the computer memory is input, while the process of outputting to external storage (such as a database, files, or remote hosts) is output. The data transfer process is like a flow of water, hence called IO streams. In Java, IO streams are divided into input streams and output streams, and based on how data is processed they are divided into byte streams and character streams.

Java IO has more than 40 classes derived from the following four abstract base classes.

• InputStream/Reader: The base class for all input streams; the former is a byte input stream, the latter is a character input stream.
• OutputStream/Writer: The base class for all output streams; the former is a byte output stream, the latter is a character output stream.

Byte Streams#

1
try (InputStream fis = new FileInputStream("input.txt")) {
2
    System.out.println("Number of remaining bytes:"
3
            + fis.available());
4
    int content;
5
    long skip = fis.skip(2);
6
    System.out.println("The actual number of bytes skipped:" + skip);
7
    System.out.print("The content read from file:");
8
    while ((content = fis.read()) != -1) {
9
        System.out.print((char) content);
10
    }
11
} catch (IOException e) {
12
    e.printStackTrace();
13
}

1
// 新建一个 BufferedInputStream 对象
2
BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("input.txt"));
3
// 读取文件的内容并复制到 String 对象中
4
String result = new String(bufferedInputStream.readAllBytes());
5
System.out.println(result);

1
FileInputStream fileInputStream = new FileInputStream("input.txt");
2
//必须将fileInputStream作为构造参数才能使用
3
DataInputStream dataInputStream = new DataInputStream(fileInputStream);
4
//可以读取任意具体的类型数据
5
dataInputStream.readBoolean();
6
dataInputStream.readInt();
7
dataInputStream.readUTF();

1
ObjectInputStream input = new ObjectInputStream(new FileInputStream("object.data"));
2
MyClass object = (MyClass) input.readObject();
3
input.close();

1
try (FileOutputStream output = new FileOutputStream("output.txt")) {
2
    byte[] array = "Dreaife yy".getBytes();
3
    output.write(array);
4
} catch (IOException e) {
5
    e.printStackTrace();
6
}

1
FileOutputStream fileOutputStream = new FileOutputStream("output.txt");
2
BufferedOutputStream bos = new BufferedOutputStream(fileOutputStream)

1
// 输出流
2
FileOutputStream fileOutputStream = new FileOutputStream("out.txt");
3
DataOutputStream dataOutputStream = new DataOutputStream(fileOutputStream);
4
// 输出任意数据类型
5
dataOutputStream.writeBoolean(true);
6
dataOutputStream.writeByte(1);

1
ObjectOutputStream output = new ObjectOutputStream(new FileOutputStream("file.txt")
2
Person person = new Person("dreaife", "eroger");
3
output.writeObject(person);

Character Streams#

No matter whether reading/writing files or sending/receiving over the network, the smallest storage unit of information is bytes. Why do IO operations distinguish between byte streams and character streams?

I think there are two main reasons:

• Character streams are produced by the JVM by converting bytes, which can be quite time-consuming.
• If we don’t know the encoding, garbled characters can easily occur.

The garbled text issue is easy to reproduce: simply change the content of the input.txt in the FileInputStream example above to Chinese; the original code does not need to change, but the read content will clearly become garbled.

Therefore, IO streams provide a direct interface to operate on characters, making it convenient to handle character data. For media files like audio or images, byte streams are preferable; for character data, character streams are better.

Character streams default to Unicode encoding; we can customize encoding through constructors.

By the way, a previously encountered interview question: how many bytes do common character encodings use? utf8: English 1 byte, Chinese 3 bytes; unicode: any character 2 bytes; gbk: English 1 byte, Chinese 2 bytes.

1
// 字节流转换为字符流的桥梁
2
public class InputStreamReader extends Reader {
3
}
4
// 用于读取字符文件
5
public class FileReader extends InputStreamReader {
6
}

1
try (FileReader fileReader = new FileReader("input.txt");) {
2
    int content;
3
    long skip = fileReader.skip(3);
4
    System.out.println("The actual number of bytes skipped:" + skip);
5
    System.out.print("The content read from file:");
6
    while ((content = fileReader.read()) != -1) {
7
        System.out.print((char) content);
8
    }
9
} catch (IOException e) {
10
    e.printStackTrace();
11
}

1
// 字符流转换为字节流的桥梁
2
public class OutputStreamWriter extends Writer {
3
}
4
// 用于写入字符到文件
5
public class FileWriter extends OutputStreamWriter {
6
}

1
try (Writer output = new FileWriter("output.txt")) {
2
    output.write("你好，我是dreaife");
3
} catch (IOException e) {
4
    e.printStackTrace();
5
}

Byte Buffered Streams#

IO operations are performance-intensive; buffered streams load data into a buffer so that multiple bytes can be read or written at once, avoiding frequent IO operations and improving stream transfer efficiency.

Byte-buffered streams use the decorator pattern to enhance the functionality of InputStream and OutputStream subclasses.

For example, we can enhance FileInputStream with BufferedInputStream (byte buffered input stream).

1
// 新建一个 BufferedInputStream 对象
2
BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("input.txt"));

The performance difference between byte streams and buffered byte streams mainly shows when we use the methods write(int b) and read() which read one byte at a time. Since buffered streams have an internal buffer (byte array), the buffered stream stores the read bytes in the buffer first, significantly reducing the number of IO operations and improving read efficiency.

I used the write(int b) and read() methods to copy a 524.9 mb PDF file with byte streams and buffered byte streams, and the timing comparison is as follows:

1
使用缓冲流复制PDF文件总耗时:15428 毫秒
2
使用普通字节流复制PDF文件总耗时:2555062 毫秒

The time difference is very large; buffered streams take about 1/165 of the time of byte streams.

Test code:

1
@Test
2
void copy_pdf_to_another_pdf_buffer_stream() {
3
    // 记录开始时间
4
    long start = System.currentTimeMillis();
5
    try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("深入理解计算机操作系统.pdf"));
6
         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("深入理解计算机操作系统-副本.pdf"))) {
7
        int content;
8
        while ((content = bis.read()) != -1) {
9
            bos.write(content);
10
        }
11
    } catch (IOException e) {
12
        e.printStackTrace();
13
    }
14
    // 记录结束时间
15
    long end = System.currentTimeMillis();
16
    System.out.println("使用缓冲流复制PDF文件总耗时:" + (end - start) + " 毫秒");
17
}
18

19
@Test
20
void copy_pdf_to_another_pdf_stream() {
21
    // 记录开始时间
22
    long start = System.currentTimeMillis();
23
    try (FileInputStream fis = new FileInputStream("深入理解计算机操作系统.pdf");
24
         FileOutputStream fos = new FileOutputStream("深入理解计算机操作系统-副本.pdf")) {
25
        int content;
26
        while ((content = fis.read()) != -1) {
27
            fos.write(content);
28
        }
29
    } catch (IOException e) {
30
        e.printStackTrace();
31
    }
32
    // 记录结束时间
33
    long end = System.currentTimeMillis();
34
    System.out.println("使用普通流复制PDF文件总耗时:" + (end - start) + " 毫秒");
35
}

If you call read(byte b[]) and write(byte b[], int off, int len) to write or read a byte array, as long as the byte array size is appropriate, the performance difference is not significant and can be basically ignored.

This time we use the methods read(byte b[]) and write(byte b[], int off, int len) to copy a 524.9 mb PDF file, comparing the times between byte streams and buffered streams:

1
使用缓冲流复制PDF文件总耗时:695 毫秒
2
使用普通字节流复制PDF文件总耗时:989 毫秒

The timing difference is not very large; buffered streams are a little faster.

Test code:

1
@Test
2
void copy_pdf_to_another_pdf_with_byte_array_buffer_stream() {
3
    // 记录开始时间
4
    long start = System.currentTimeMillis();
5
    try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("深入理解计算机操作系统.pdf"));
6
         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("深入理解计算机操作系统-副本.pdf"))) {
7
        int len;
8
        byte[] bytes = new byte[4 * 1024];
9
        while ((len = bis.read(bytes)) != -1) {
10
            bos.write(bytes, 0, len);
11
        }
12
    } catch (IOException e) {
13
        e.printStackTrace();
14
    }
15
    // 记录结束时间
16
    long end = System.currentTimeMillis();
17
    System.out.println("使用缓冲流复制PDF文件总耗时:" + (end - start) + " 毫秒");
18
}
19

20
@Test
21
void copy_pdf_to_another_pdf_with_byte_array_stream() {
22
    // 记录开始时间
23
    long start = System.currentTimeMillis();
24
    try (FileInputStream fis = new FileInputStream("深入理解计算机操作系统.pdf");
25
         FileOutputStream fos = new FileOutputStream("深入理解计算机操作系统-副本.pdf")) {
26
        int len;
27
        byte[] bytes = new byte[4 * 1024];
28
        while ((len = fis.read(bytes)) != -1) {
29
            fos.write(bytes, 0, len);
30
        }
31
    } catch (IOException e) {
32
        e.printStackTrace();
33
    }
34
    // 记录结束时间
35
    long end = System.currentTimeMillis();
36
    System.out.println("使用普通流复制PDF文件总耗时:" + (end - start) + " 毫秒");
37
}

1
public
2
class BufferedInputStream extends FilterInputStream {
3
    // 内部缓冲区数组
4
    protected volatile byte buf[];
5
    // 缓冲区的默认大小
6
    private static int DEFAULT_BUFFER_SIZE = 8192;
7
    // 使用默认的缓冲区大小
8
    public BufferedInputStream(InputStream in) {
9
        this(in, DEFAULT_BUFFER_SIZE);
10
    }
11
    // 自定义缓冲区大小
12
    public BufferedInputStream(InputStream in, int size) {
13
        super(in);
14
        if (size <= 0) {
15
            throw new IllegalArgumentException("Buffer size <= 0");
16
        }
17
        buf = new byte[size];
18
    }
19
}

1
try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("output.txt"))) {
2
    byte[] array = "dreaifeICU".getBytes();
3
    bos.write(array);
4
} catch (IOException e) {
5
    e.printStackTrace();
6
}

Character Buffered Streams#

BufferedReader (Character Buffered Input Stream) and BufferedWriter (Character Buffered Output Stream) are similar to BufferedInputStream (Byte Buffered Input Stream) and BufferedOutputStream (Byte Buffered Output Stream); both maintain an internal buffer. However, the former is mainly used to handle character information.

Print Streams#

You probably use this code often, right?

1
System.out.print("Hello！");
2
System.out.println("Hello！");

System.out is actually used to obtain a PrintStream object; the print method actually calls the write method of the PrintStream object.

PrintStream is a byte-based print stream, and its counterpart is PrintWriter (character print stream). PrintStream is a subclass of OutputStream, and PrintWriter is a subclass of Writer.

1
public class PrintStream extends FilterOutputStream
2
    implements Appendable, Closeable {
3
}
4
public class PrintWriter extends Writer {
5
}

Random Access Streams#

The random access stream we will discuss here refers to RandomAccessFile, which supports jumping to any position in a file for reading and writing.

RandomAccessFile constructors are as follows; you can specify mode (read/write).

1
// openAndDelete 参数默认为 false 表示打开文件并且这个文件不会被删除
2
public RandomAccessFile(File file, String mode)
3
    throws FileNotFoundException {
4
    this(file, mode, false);
5
}
6
// 私有方法
7
private RandomAccessFile(File file, String mode, boolean openAndDelete)  throws FileNotFoundException{
8
  // 省略大部分代码
9
}

There are four main modes:

• r: Read-only mode.
• rw: Read/write mode
• rws: In relation to rw, synchronously updates to external storage device for modifications to both the file’s content and metadata.
• rwd: In relation to rw, synchronously updates to external storage device for modifications to the file’s content.

File content refers to the actual data stored in the file; metadata describes attributes such as file size, creation and modification times.

RandomAccessFile has a file pointer that indicates the position of the next byte to be read or written. You can set the file pointer offset with seek(long pos) (pos bytes from the beginning). If you want to get the current position, use getFilePointer().

RandomAccessFile code example:

1
RandomAccessFile randomAccessFile = new RandomAccessFile(new File("input.txt"), "rw");
2
System.out.println("读取之前的偏移量：" + randomAccessFile.getFilePointer() + ",当前读取到的字符" + (char) randomAccessFile.read() + "，读取之后的偏移量：" + randomAccessFile.getFilePointer());
3
// 指针当前偏移量为 6
4
randomAccessFile.seek(6);
5
System.out.println("读取之前的偏移量：" + randomAccessFile.getFilePointer() + ",当前读取到的字符" + (char) randomAccessFile.read() + "，读取之后的偏移量：" + randomAccessFile.getFilePointer());
6
// 从偏移量 7 的位置开始往后写入字节数据
7
randomAccessFile.write(new byte[]{'H', 'I', 'J', 'K'});
8
// 指针当前偏移量为 0，回到起始位置
9
randomAccessFile.seek(0);
10
System.out.println("读取之前的偏移量：" + randomAccessFile.getFilePointer() + ",当前读取到的字符" + (char) randomAccessFile.read() + "，读取之后的偏移量：" + randomAccessFile.getFilePointer());

If the target position already contains data, the write method of RandomAccessFile will overwrite it.

1
RandomAccessFile randomAccessFile = new RandomAccessFile(new File("input.txt"), "rw");
2
randomAccessFile.write(new byte[]{'H', 'I', 'J', 'K'});

Suppose the contents of input.txt are ABCD before running the program above; after running it, the file becomes HIJK.

A common use case of RandomAccessFile is implementing resumable uploads for large files. In short, after an upload is paused or fails (for example, due to network issues), you do not need to re-upload the entire file; you only upload the chunks that were not successfully uploaded. Chunked upload (splitting a file into multiple chunks first) is the foundation of resumable uploads.

RandomAccessFile is implemented based on FileDescriptor (file descriptor) and FileChannel (file channel).

Decorator Pattern#

The Decorator pattern can extend the functionality of an existing object without modifying the object itself.

The decorator pattern uses composition instead of inheritance to extend the functionality of the original class, and it is particularly useful in scenarios with complex inheritance hierarchies (IO features many inheritance relationships).

For byte streams, FilterInputStream (for input streams) and FilterOutputStream (for output streams) are the core of the decorator pattern, used to enhance the functionality of InputStream and OutputStream subclasses respectively.

Common examples like BufferedInputStream (byte buffered input stream) and DataInputStream etc. are subclasses of FilterInputStream, while BufferedOutputStream (byte buffered output stream) and DataOutputStream etc. are subclasses of FilterOutputStream.

For example, we can enhance FileInputStream with BufferedInputStream (byte buffered input stream).

BufferedInputStream constructor is as follows:

1
public BufferedInputStream(InputStream in) {
2
    this(in, DEFAULT_BUFFER_SIZE);
3
}
4

5
public BufferedInputStream(InputStream in, int size) {
6
    super(in);
7
    if (size <= 0) {
8
        throw new IllegalArgumentException("Buffer size <= 0");
9
    }
10
    buf = new byte[size];
11
}

As you can see, one of the constructor parameters of BufferedInputStream is an InputStream.

BufferedInputStream code example:

1
try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("input.txt"))) {
2
    int content;
3
    long skip = bis.skip(2);
4
    while ((content = bis.read()) != -1) {
5
        System.out.print((char) content);
6
    }
7
} catch (IOException e) {
8
    e.printStackTrace();
9
}

At this point you may wonder: why not just make a BufferedFileInputStream (character buffered file input stream) directly?

1
BufferedFileInputStream bfis = new BufferedFileInputStream("input.txt");

If there are only a few InputStream subclasses, this would be fine. However, there are many InputStream subclasses, and the inheritance is quite complex. If we tailor a buffered input stream for every subclass, that would be quite a hassle.

If you are familiar with IO streams, you will notice that ZipInputStream and ZipOutputStream can also enhance the capabilities of BufferedInputStream and BufferedOutputStream respectively.

1
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(fileName));
2
ZipInputStream zis = new ZipInputStream(bis);
3

4
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(fileName));
5
ZipOutputStream zipOut = new ZipOutputStream(bos);

ZipInputStream and ZipOutputStream extend InflaterInputStream and DeflaterOutputStream, respectively.

1
public
2
class InflaterInputStream extends FilterInputStream {
3
}
4

5
public
6
class DeflaterOutputStream extends FilterOutputStream {
7
}

This is also an important feature of the decorator pattern: you can nest multiple decorators around the original class.

To achieve this, decorator classes need to extend the same abstract class or implement the same interface as the original class. The IO-related decorators mentioned above share the common base classes of InputStream and OutputStream with the original classes.

For character streams, BufferedReader can be used to augment the functionality of Reader (character input streams), and BufferedWriter can augment the functionality of Writer (character output streams).

1
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(fileName), "UTF-8"));

There are many examples of applying the decorator pattern in IO streams; you don’t need to memorize them all. Once you grasp the decorator pattern’s core, you’ll naturally know where it applies when using IO streams.

Adapter Pattern#

The Adapter Pattern is mainly used to coordinate classes with incompatible interfaces; you can think of it as the power adapter we use in daily life.

In the adapter pattern, the object or class being adapted is called the Adaptee, and the object or class that adapts is called the Adapter. Adapters can be class adapters (using inheritance) or object adapters (using composition).

The interfaces of character streams and byte streams in IO are different; adapters allow them to work together, more precisely as object adapters. Through the adapter, we can adapt a byte stream object into a character stream object, so we can directly read or write character data through the byte stream object.

InputStreamReader and OutputStreamWriter are two adapters, and they are also bridges between byte streams and character streams. InputStreamReader uses StreamDecoder (a stream decoder) to decode bytes, implementing conversion from byte streams to character streams, while OutputStreamWriter uses StreamEncoder (a stream encoder) to encode characters, implementing conversion from character streams to byte streams.

InputStream and OutputStream subclasses are the adaptees, while InputStreamReader and OutputStreamWriter are the adapters.

1
// InputStreamReader 是适配器，FileInputStream 是被适配的类
2
InputStreamReader isr = new InputStreamReader(new FileInputStream(fileName), "UTF-8");
3
// BufferedReader 增强 InputStreamReader 的功能（装饰器模式）
4
BufferedReader bufferedReader = new BufferedReader(isr);

java.io.InputStreamReader partial source code:

1
public class InputStreamReader extends Reader {
2
    //用于解码的对象
3
    private final StreamDecoder sd;
4
    public InputStreamReader(InputStream in) {
5
        super(in);
6
        try {
7
            // 获取 StreamDecoder 对象
8
            sd = StreamDecoder.forInputStreamReader(in, this, (String)null);
9
        } catch (UnsupportedEncodingException e) {
10
            throw new Error(e);
11
        }
12
    }
13
    // 使用 StreamDecoder 对象做具体的读取工作
14
    public int read() throws IOException {
15
        return sd.read();
16
    }
17
}

java.io.OutputStreamWriter partial source code:

1
public class OutputStreamWriter extends Writer {
2
    // 用于编码的对象
3
    private final StreamEncoder se;
4
    public OutputStreamWriter(OutputStream out) {
5
        super(out);
6
        try {
7
           // 获取 StreamEncoder 对象
8
            se = StreamEncoder.forOutputStreamWriter(out, this, (String)null);
9
        } catch (UnsupportedEncodingException e) {
10
            throw new Error(e);
11
        }
12
    }
13
    // 使用 StreamEncoder 对象做具体的写入工作
14
    public void write(int c) throws IOException {
15
        se.write(c);
16
    }
17
}

What is the difference between the Adapter pattern and the Decorator pattern?

• The Decorator pattern focuses more on dynamically enhancing the functionality of the original class; decorator classes must extend the same abstract class or implement the same interface as the original class. It also supports nesting multiple decorators around the original class.
• The Adapter pattern focuses on making otherwise incompatible interfaces work together; when we call the adapter’s corresponding method, the adapter will internally call the adaptee’s method or related classes’ methods, in a transparent way. For example, StreamDecoder (stream decoder) and StreamEncoder (stream encoder) are based on InputStream and OutputStream to obtain a FileChannel object and call the corresponding read and write methods to read and write byte data.

1
StreamDecoder(InputStream in, Object lock, CharsetDecoder dec) {
2
    // 省略大部分代码
3
    // 根据 InputStream 对象获取 FileChannel 对象
4
    ch = getChannel((FileInputStream)in);
5
}

• Adapter and adaptee do not need to share the same abstract class or interface.

Additionally, the FutureTask class uses the Adapter pattern; the internal class RunnableAdapter in Executors is an adapter that adapts a Runnable to a Callable.

FutureTask constructor with a Runnable parameter:

1
public FutureTask(Runnable runnable, V result) {
2
    // 调用 Executors 类的 callable 方法
3
    this.callable = Executors.callable(runnable, result);
4
    this.state = NEW;
5
}

The corresponding methods and adapters inside Executors:

1
// 实际调用的是 Executors 的内部类 RunnableAdapter 的构造方法
2
public static <T> Callable<T> callable(Runnable task, T result) {
3
    if (task == null)
4
        throw new NullPointerException();
5
    return new RunnableAdapter<T>(task, result);
6
}
7
// 适配器
8
static final class RunnableAdapter<T> implements Callable<T> {
9
    final Runnable task;
10
    final T result;
11
    RunnableAdapter(Runnable task, T result) {
12
        this.task = task;
13
        this.result = result;
14
    }
15
    public T call() {
16
        task.run();
17
        return result;
18
    }
19
}

Factory Pattern#

The factory pattern is used to create objects; in NIO there are many factory patterns, such as the static factory method in Files to create an InputStream object via newInputStream, the Paths class’s get method to create Path objects (static factory), and ZipFileSystem’s getPath method to create Path objects (simple factory) in internal implementations under the sun.nio package related to java.nio.

1
InputStream is = Files.newInputStream(Paths.get(generatorLogoPath))

Observer Pattern#

The file directory monitoring service in NIO uses the observer pattern.

The file directory monitoring service in NIO is based on the WatchService interface and the Watchable interface. WatchService is the observer, and Watchable is the observed.

Watchable interface defines a method to register an object with a WatchService (monitoring service) and bind the events to listen for, via register.

1
public interface Path
2
    extends Comparable<Path>, Iterable<Path>, Watchable{
3
}
4

5
public interface Watchable {
6
    WatchKey register(WatchService watcher,
7
                      WatchEvent.Kind<?>[] events,
8
                      WatchEvent.Modifier... modifiers)
9
        throws IOException;
10
}

WatchService is used to monitor changes to directories, and a single WatchService object can listen to multiple directories.

1
// 创建 WatchService 对象
2
WatchService watchService = FileSystems.getDefault().newWatchService();
3

4
// 初始化一个被监控文件夹的 Path 类:
5
Path path = Paths.get("workingDirectory");
6
// 将这个 path 对象注册到 WatchService（监控服务） 中去
7
WatchKey watchKey = path.register(
8
watchService, StandardWatchEventKinds...);

The second parameter of the Path class’s register method, events (events to listen for), is a varargs parameter, meaning we can listen for multiple events at once.

1
WatchKey register(WatchService watcher,
2
                  WatchEvent.Kind<?>... events)
3
    throws IOException;

Common events include three types:

• StandardWatchEventKinds.ENTRY_CREATE: File creation.
• StandardWatchEventKinds.ENTRY_DELETE : File deletion.
• StandardWatchEventKinds.ENTRY_MODIFY : File modification.

The register method returns a WatchKey object, through which you can obtain specific information about the event, such as whether a file was created, deleted, or modified, and the exact name of the file.

1
WatchKey key;
2
while ((key = watchService.take()) != null) {
3
    for (WatchEvent<?> event : key.pollEvents()) {
4
      // 可以调用 WatchEvent 对象的方法做一些事情比如输出事件的具体上下文信息
5
    }
6
    key.reset();
7
}

The internals of WatchService implement a daemon thread that periodically polls for file changes; a simplified version is shown below.

1
class PollingWatchService
2
    extends AbstractWatchService
3
{
4
    // 定义一个 daemon thread（守护线程）轮询检测文件变化
5
    private final ScheduledExecutorService scheduledExecutor;
6

7
    PollingWatchService() {
8
        scheduledExecutor = Executors
9
            .newSingleThreadScheduledExecutor(new ThreadFactory() {
10
                 @Override
11
                 public Thread newThread(Runnable r) {
12
                     Thread t = new Thread(r);
13
                     t.setDaemon(true);
14
                     return t;
15
                 }});
16
    }
17

18
  void enable(Set<? extends WatchEvent.Kind<?>> events, long period) {
19
    synchronized (this) {
20
      // 更新监听事件
21
      this.events = events;
22

23
        // 开启定期轮询
24
      Runnable thunk = new Runnable() { public void run() { poll(); }};
25
      this.poller = scheduledExecutor
26
        .scheduleAtFixedRate(thunk, period, period, TimeUnit.SECONDS);
27
    }
28
  }
29
}

I/O#

Three Common IO Models in Java#