Java IO流关闭问题的深入研究

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Java IO流关闭问题的深入研究，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含6130字，纯文字阅读大概需要9分钟。

内容图文

转自:https://blog.csdn.net/maxwell_nc/article/details/49151005

前几天看了一篇文章（见参考文章），自己动手试了下，发现有些不一样结论，作博客记录下，本文主要研究两个问题：

包装流的close方法是否会自动关闭被包装的流？
关闭流方法是否有顺序？
包装流的close方法是否会自动关闭被包装的流？
平时我们使用输入流和输出流一般都会使用buffer包装一下，
直接看下面代码（这个代码运行正常，不会报错）

             1
            import
             java.io.BufferedOutputStream;

             2
            import
             java.io.FileOutputStream;

             3
            import
             java.io.IOException;

             4
             5
             6
            public
            class
             IOTest {

             7
             8
            public
            static
            void main(String[] args) throws IOException {
 910 FileOutputStream fileOutputStream = new FileOutputStream("c:\\a.txt");
11 BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
1213 bufferedOutputStream.write("test write something".getBytes());
14bufferedOutputStream.flush();
1516//从包装流中关闭流17bufferedOutputStream.close();
18}
1920 }

下面我们来研究下这段代码的bufferedOutputStream.close();方法是否调用了fileOutputStream.close();

先看BufferedOutputStream源代码：

public class BufferedOutputStream extends FilterOutputStream { ...
1
可以看到它继承FilterOutputStream，并且没有重写close方法，
所以直接看FilterOutputStream的源代码：

            1
            public
            void close() throws IOException {
2try {
3flush();
4 } catch (IOException ignored) {
5}
6out.close();
7 }

跟踪out（FilterOutputStream中）：

            1
            protected
             OutputStream out;

            2
            3
            public
             FilterOutputStream(OutputStream out) {

            4
            this.out = out;
5 }

再看看BufferedOutputStream中：

             1
            public
             BufferedOutputStream(OutputStream out) {

             2
            this(out, 8192);
 3}
 4 5public BufferedOutputStream(OutputStream out, int size) {
 6super(out);
 7if (size <= 0) {
 8thrownew IllegalArgumentException("Buffer size <= 0");
 9}
10 buf = newbyte[size];
11 }

可以看到BufferedOutputStream调用super(out);，也就是说，out.close();调用的是通过BufferedOutputStream传入的被包装的流，这里就是FileOutputStream。

我们在看看其他类似的，比如BufferedWriter的源代码：

             1
            public
            void close() throws IOException {
 2synchronized (lock) {
 3if (out == null) {
 4return;
 5}
 6try {
 7flushBuffer();
 8 } finally {
 9out.close();
10 out = null;
11 cb = null;
12}
13}
14 }

通过观察各种流的源代码，可得结论：包装的流都会自动调用被包装的流的关闭方法，无需自己调用。

关闭流方法是否有顺序？
由上面的结论，就会产生一个问题：如果手动关闭被包装流会怎么样，这个关闭流有顺序吗？而实际上我们习惯都是两个流都关闭的。

首先我们来做一个简单的实验，基于第一个问题的代码上增加手动增加关闭流的代码，那么就有两种顺序：
1.先关闭被包装流（正常没异常抛出）

             1
            import
             java.io.BufferedOutputStream;

             2
            import
             java.io.FileOutputStream;

             3
            import
             java.io.IOException;

             4
             5
             6
            public
            class
             IOTest {

             7
             8
            public
            static
            void main(String[] args) throws IOException {
 910 FileOutputStream fileOutputStream = new FileOutputStream("c:\\a.txt");
11 BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
1213 bufferedOutputStream.write("test write something".getBytes());
14bufferedOutputStream.flush();
1516 fileOutputStream.close();//先关闭被包装流17bufferedOutputStream.close();
18}
1920 }

2.先关闭包装流（正常没异常抛出）

             1
            import
             java.io.BufferedOutputStream;

             2
            import
             java.io.FileOutputStream;

             3
            import
             java.io.IOException;

             4
             5
             6
            public
            class
             IOTest {

             7
             8
            public
            static
            void main(String[] args) throws IOException {
 910 FileOutputStream fileOutputStream = new FileOutputStream("c:\\a.txt");
11 BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
1213 bufferedOutputStream.write("test write something".getBytes());
14bufferedOutputStream.flush();
151617 bufferedOutputStream.close();//先关闭包装流18fileOutputStream.close();
1920}
2122 }

上述两种写法都没有问题，我们已经知道bufferedOutputStream.close();会自动调用fileOutputStream.close();方法，那么这个方法是怎么执行的呢？我们又看看

             1
            FileOutputStream的源码：

             2
             3
            public
            void close() throws IOException {
 4synchronized (closeLock) {
 5if (closed) {
 6return;
 7}
 8 closed = true;
 9}
1011 ...

可以看出它采用同步锁，而且使用了关闭标记，如果已经关闭了则不会再次操作，所以多次调用不会出现问题。
如果没有看过参考文章，我可能就会断下结论，关闭流不需要考虑顺序

我们看下下面的代码（修改自参考文章）：

             1
            import
             java.io.BufferedWriter;

             2
            import
             java.io.FileOutputStream;

             3
            import
             java.io.IOException;

             4
            import
             java.io.OutputStreamWriter;

             5
             6
            public
            class
             IOTest {

             7
             8
            public
            static
            void main(String[] args) throws IOException {
 910 FileOutputStream fos = new FileOutputStream("c:\\a.txt");
11 OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
12 BufferedWriter bw = new BufferedWriter(osw);
13 bw.write("java IO close test");
1415// 从内带外顺序顺序会报异常16fos.close();
17osw.close();
18bw.close();
1920}
2122 }

会抛出Stream closed的IO异常：

            1 Exception in thread "main" java.io.IOException: Stream closed
2 at sun.nio.cs.StreamEncoder.ensureOpen(StreamEncoder.java:45)
3 at sun.nio.cs.StreamEncoder.write(StreamEncoder.java:118)
4 at java.io.OutputStreamWriter.write(OutputStreamWriter.java:207)
5 at java.io.BufferedWriter.flushBuffer(BufferedWriter.java:129)
6 at java.io.BufferedWriter.close(BufferedWriter.java:264)
7 at IOTest.main(IOTest.java:18)

而如果把bw.close();放在第一，其他顺序任意，即修改成下面两种：

            1
            bw.close();

            2
            osw.close();

            3 fos.close();

            1
            bw.close();

            2
            fos.close();

            3 osw.close();

都不会报错，这是为什么呢，我们立即看看BufferedWriter的close源码：

             1
            public
            void close() throws IOException {
 2synchronized (lock) {
 3if (out == null) {
 4return;
 5}
 6try {
 7flushBuffer();
 8 } finally {
 9out.close();
10 out = null;
11 cb = null;
12}
13}
14 }

里面调用了flushBuffer()方法，也是抛异常中的错误方法：

            1
            void flushBuffer() throws IOException {
2synchronized (lock) {
3ensureOpen();
4if (nextChar == 0)
5return;
6 out.write(cb, 0, nextChar);
7 nextChar = 0;
8}
9 }

可以看到很大的一行

            1 out.write(cb, 0, nextChar);

这行如果在流关闭后执行就会抛IO异常，
有时候我们会写成：

            1
            fos.close();

            2 fos = null;
3osw.close();
4 osw = null;
5bw.close();
6 bw = null;

这样也会抛异常，不过是由于flushBuffer()中ensureOpen()抛的，可从源码中看出：

             1
            private
            void ensureOpen() throws IOException {
 2if (out == null)
 3thrownew IOException("Stream closed");
 4}
 5 6 7void flushBuffer() throws IOException {
 8synchronized (lock) {
 9ensureOpen();
10if (nextChar == 0)
11return;
12 out.write(cb, 0, nextChar);
13 nextChar = 0;
14}
15 }

如何防止这种情况？
直接写下面这种形式就可以：

            1
            bw.close();

            2 bw = null;

结论：一个流上的close方法可以多次调用，理论上关闭流不需要考虑顺序，但有时候关闭方法中调用了write等方法时会抛异常。

由上述的两个结论可以得出下面的建议：
关闭流只需要关闭最外层的包装流，其他流会自动调用关闭，这样可以保证不会抛异常。如：

            1
            bw.close();

            2
            //
            下面三个无顺序
            3 osw = null;
4 fos = null;
5 bw = null;

注意的是，有些方法中close方法除了调用被包装流的close方法外还会把包装流置为null，方便JVM回收。bw.close()中的：

             1
            public
            void close() throws IOException {
 2synchronized (lock) {
 3if (out == null) {
 4return;
 5}
 6try {
 7flushBuffer();
 8 } finally {
 9out.close();
10 out = null;
11 cb = null;
12}
13}
14 }

finally中就有把out置为null的代码，所以有时候不需要自己手动置为null。（个人建议还是写一下，不差多少执行时间）

原文：https://www.cnblogs.com/fnlingnzb-learner/p/10132540.html

内容总结

以上是互联网集市为您收集整理的Java IO流关闭问题的深入研究全部内容，希望文章能够帮你解决Java IO流关闭问题的深入研究所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1335241.html

来源：【匿名】

【上一篇】Java流程控制（1）【下一篇】JAVA/JSP学习系列之五

更多 ►

【Java IO流关闭问题的深入研究】教程文章相关的互联网学习教程文章

转自:https://blog.csdn.net/maxwell_nc/article/details/49151005前几天看了一篇文章（见参考文章），自己动手试了下，发现有些不一样结论，作博客记录下，本文主要研究两个问题：包装流的close方法是否会自动关闭被包装的流？关闭流方法是否有顺序？包装流的close方法是否会自动关闭被包装的流？平时我们使用输入流和输出流一般都会使用buffer包装一下，直接看下面代码（这个代码运行正常，不会报错） 1import java.io.Buffered...

黑马程序员——java IO流

java中，IO流需要操作系统资源，使用完毕后要释放资源。IO流根据操作的数据的类型的不同，可以分为字节流和字符流，字符流是基于字节流的。字符流的顶层基类是Reader和Writer字节流的顶层基类是InputStream和OutputStream流是用来操作数据的，数据的最常见形式是文件，字符流针对的是文本文件，字节流针对的是二进制文件(如图片文件)。1.FileWriter是Writer的一个子类，创建FileWriter对象后，如果源文件不存在则创建新文件；如果源...

Java基础知识强化之IO流笔记36：FileReader/FileWriter（转换流的子类）复制文本文件案例02【代码】【图】

1. 转换流的简化写法：由于我们常见的操作都是使用本地默认编码，所以，不用指定编码。而转换流的名称有点长，所以，Java就提供了其子类供我们使用：FileReader / FileWriterOutputStreamWriter = FileOutputStream + 编码表(GBK)FileWriter = FileOutputStream + 编码表(GBK)InputStreamReader = FileInputStream + 编码表(GBK)FileReader = FileInputStream + 编码表(GBK)2. FileReader / FileWriter两者的构造方法：（1）FileR...

【java】io流之字符输入流：java.io.Reader类及子类的子类java.io.FileReader【代码】

1package 文件操作;2 3import java.io.File;4import java.io.FileReader;5import java.io.IOException;6import java.io.Reader;7 8publicclass TestReader {9publicstaticvoid main(String[] args) throws IOException { 10 File file=new File("D:"+File.separator+"test.txt"); 11/*File*/Reader reader=new FileReader(file);//也可以直接用FileReader类型的变量接收实例化对象，而无需使用向上转型。12if(file.exists(...

Java IO流 ObjectOutputStream、ObjectInputStream的基本使用【代码】【图】

ObjectOutputStream、ObjectInputStream的使用　　ObjectOutputStream将Java对象的原始数据类型和图形写入OutputStream。可以使用ObjectInputStream读取（重构）对象。可以通过使用流的文件来实现对象的持久存储如果流是网络套接字流，则可以在另一个主机上或另一个进程中重构对象，只有支持java.io.Serializable接口的对象才能写入流中。方法readObject用于从流中读取对象应使用Java的安全铸造来获得所需的类型。在Java中，字符...

Java中IO流的基础介绍

1-1.IO概述i:input输入(读取)o:output输出(写入)流:数据(字符,字均1个字符=2个字节，1个字节=8个二进制位输入:把硬盘中的数据,读取到内存中使用输出:把内存中的数据写入到硬盘中保存1-2.一切皆为字节一切文件数据(文本、图片、视频等)在存储时，都是以二进制数字的形式保存，都一个一个的字节，那么传输时一样如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二...

Java连载94-增强for循环、IO流与文件【代码】【图】

一、JDK5.0新特性1.增强for循环2.语法for(类型变量：数组名/集合名）{}集合想要使用增强for循环这种语法，集合需要使用泛型。如果不使用泛型，那么需要哦使用Object类型来定义集合中的元素 package com.bjpowernode.java_learning;import java.util.*;?publicclass D94_1_EnhanceForCirculation {publicstaticvoid main(String[] args) {int[] a = {1,2,3,4,5,6};//遍历for(int i=0;i<a.length;i++) {System.out.println(a[i]);}...

JavaEE基础（二十二）/IO流【代码】

1、IO流(序列流)1.什么是序列流序列流可以把多个字节输入流整合成一个, 从序列流中读取数据时, 将从被整合的第一个流开始读, 读完一个之后继续读第二个, 以此类推.2.使用方式整合两个: SequenceInputStream(InputStream, InputStream)FileInputStream fis1 = new FileInputStream("a.txt"); //创建输入流对象,关联a.txt FileInputStream fis2 = new FileInputStream("b.txt"); //创建输入流对象,关联b.txt ...

Java-IO流篇《六》【代码】【图】

1. java.io.File类 File类代表系统文件(文件和目录)，磁盘上的文件和目录在Java程序中是用File类的实例来表示。常用的构造方法：File (String pathname);File(File parent, String child) ;File(String parent,String child) 以pathname为路径创建File对象，如果pathname是相对路径，则是相对于Java的系统属性user.dir中的路径(即当前字节码运行的目录)。 File类的...

Java基础--常用API--IO流相关API【代码】【图】

回到顶部一、IO流1、定义：　　IO流指的是Input/Output流，即输入流/输出流。　　　　输入流：将外界信息写入程序，即从外界获取信息，属于读操作。　　　　输出流：将程序数据发送给外界，即向外界传输数据，属于写操作。　　流一定要关闭，否则可能会出现一些异常。2、分类：　　（1）按照功能划分：　　　　输入流：只能读数据，不能写数据。　　　　输出流：只能写数据，不能读数据。　　（2）按照处理单元划分：　　　　字节流...

java IO流（二） IO流概述【图】

1.流的分类* 1.操作数据单位：字节流、字符流* 2.数据的流向：输入流、输出流* 3.流的角色：节点流、处理流图示： 2.流的体系结构说明：红框对应的是IO流中的4个抽象基类。蓝框的流需要大家重点关注。3.重点说明的几个流结构 4.输入、输出的标准化过程4.1 输入过程① 创建File类的对象，指明读取的数据的来源。（要求此文件一定要存在）② 创建相应的输入流，将File类的对象作为参数，传入流的构造器中③ 具体的读入过程： ...

java基础50 IO流技术（）

1、待续待续原创作者：DSHORE作者主页：http://www.cnblogs.com/dshore123/原文出自：https://www.cnblogs.com/dshore123/p/9306363.html欢迎转载，转载务必说明出处。（如果本文对您有帮助，可以点击一下右下角的推荐，或评论，谢谢！）原文：https://www.cnblogs.com/dshore123/p/9319067.html

javaAPI_IO流基础_IO流常见的功能

IO流常见操作1.复制文本文件[使用多种方式实现]/* * 复制文本文件 * * 分析： * 复制数据，如果我们知道用记事本打开并能够读懂，就用字符流，否则用字节流。 * 通过该原理，我们知道我们应该采用字符流更方便一些。 * 而字符流有5种方式，所以做这个题目我们有5种方式。推荐掌握第5种。 * 数据源： * c:\\a.txt -- FileReader -- BufferdReader * 目的地： * d:\\b.txt -- FileWriter -- BufferedWriter */public clas...

08 - JavaSE之IO流【代码】

IO流JAVA流式输入输出原理：可以想象成一根管道怼到文件上，另一端是我们程序，然后流的输入输出都是按照程序本身作为第一人称说明的。比如 input，对于我们程序来说就是有数据输入我们程序，output就是我们程序输出数据到文件等。对象不能搞错了，否则就南辕北辙了。通过不同的角度对流的输入输出功能进行分类：按数据流的方向分为：输入流和输出流按处理数据单位不同分为：字节流和字符流（2个字节）按功能不同分为：节点流和处理...

java IO流学习笔记

import java.io.*;class hello{ public static void main(String[] args) { System.out.println(File.separator); System.out.println(File.pathSeparator); }}【运行结果】：\;String fileName="D:"+File.separator+"hello.txt"; File f=new File(fileName); if(f.exists()){ f.delete();File f=new File("D:\\hello.txt");创建新文件f.createNewFile();创建新文件夹 f.mkdir();删除...

JAVA - 技术教程分类

Java 教程 Java 简介 Java 开发环境配置 Java 基础语法 Java 对象和类 Java 基本数据类型 Java 变量类型 Java 修饰符 Java 运算符 Java 循环结构 Java 条件语句 Java switch case Java Number & Math 类 Java Character 类 Java String 类 Java StringBuffer Java 数组 Java 日期时间 Java 方法 Java Stream、File、IO Java Scanner 类 Java 异常处理 Java 继承 Java Override/Overload Java 多态 Java 抽象类 Java 封装 Java 接口 Java 枚举 Java 包(package) Java 数据结构 Java 集合框架 Java ArrayList Java LinkedList Java HashSet Java HashMap Java Iterator Java Object Java 泛型 Java 序列化 Java 网络编程 Java 多线程编程 Java Applet 基础 Java 文档注释 Java 实例 Java 8 新特性 Java MySQL 连接 Java 9 新特性 Java 测验 java 全部

JAVA - 最热教程

Java在运行项目时候，点击右键的弹框，...nacos配置中心超时问题：java.net.Conn...Java的设计模式（7）— 生产者-消费者模...基于DOM4j和POI实现的XML文件转换为XLS...如何在Java中创建一些变量类型别名使用java8的Stream统计字符串数组中每一...idea插件篇之java内存分析工具(JProfil...cannot cast 'java.lang.Integer' to '...java – Bootstrap.properties中Spring...Java8利用stream流实现数字排序和中文排...