java代码书写过程，文件资源的释放需要特别谨慎的对待.通常文件资源使用后必须close，然后再删除。
 
如果先删除但没有close掉，会造成文件句柄未被释放.
 
这会造成实际使用磁盘空间较大，成为瓶颈
 
eg:
 
 
 
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileTest {
	public static void main(String[] args) {
		File file = new File("/home/admin/a.txt");
//		File file = new File("c://a.txt");
		FileOutputStream  out = null;
		try {
			out = new FileOutputStream(file);
			file.delete();
			while(true){
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if(out!=null) {
					out.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	
}
 
 
 
 
此时文件关闭了，但是out还持有文件，out未关闭则文件句柄未被释放。造成实际可使用空间小于可使用空间。
 
 
 
2.文件句柄的调试可用lsof 命令进行查看
 
   lsof -s |grep java
 
   lsof -s |grep deleted
 
 

 转载----这个方法考虑到了中文，即时Eclipse默认设置为utf-8也可以很好的执行
 
 java读取txt文件内容。可以作如下理解：
 
 
首先获得一个文件句柄。File file = new File(); file即为文件句柄。两人之间连通电话网络了。接下来可以开始打电话了。
 
 
通过这条线路读取甲方的信息：new FileInputStream(file) 目前这个信息已经读进来内存当中了。接下来需要解读成乙方可以理解的东西
 
 
既然你使用了FileInputStream()。那么对应的需要使用InputStreamReader()这个方法进行解读刚才装进来内存当中的数据
 
 
解读完成后要输出呀。那当然要转换成IO可以识别的数据呀。那就需要调用字节码读取的方法BufferedReader()。同时使用bufferedReader()的readline(）方法读取txt文件中的每一行数据。
 
 
 
 
 
  
 
   
 
       
 
        
 
         package 
         com.campu;
        
 
        

           
        
 
        
 
         import 
         java.io.BufferedInputStream;
        
 
        
 
         import 
         java.io.BufferedReader;
        
 
        
 
         import 
         java.io.File;
        
 
        
 
         import 
         java.io.FileInputStream;
        
 
        
 
         import 
         java.io.InputStreamReader;
        
 
        
 
         import 
         java.io.Reader;
        
 
        

           
        
 
        
 
         /**
        
 
        
 
          
         * @author 码农小江
        
 
        
 
          
         * H20121012.java
        
 
        
 
          
         * 2012-10-12下午11:40:21
        
 
        
 
          
         */
        
 
        
 
         public 
         class 
         H20121012 {
        
 
        
 
             
         /**
        
 
        
 
              
         * 功能：Java读取txt文件的内容
        
 
        
 
              
         * 步骤：1：先获得文件句柄
        
 
        
 
              
         * 2：获得文件句柄当做是输入一个字节码流，需要对这个输入流进行读取
        
 
        
 
              
         * 3：读取到输入流后，需要读取生成字节流
        
 
        
 
              
         * 4：一行一行的输出。readline()。
        
 
        
 
              
         * 备注：需要考虑的是异常情况
        
 
        
 
              
         * @param filePath
        
 
        
 
              
         */
        
 
        
 
             
         public 
         static 
         void 
         readTxtFile(String filePath){
        
 
        
 
                 
         try 
         {
        
 
        
 
                         
         String encoding=
         "GBK"
         ;
        
 
        
 
                         
         File file=
         new 
         File(filePath);
        
 
        
 
                         
         if
         (file.isFile() && file.exists()){ 
         //判断文件是否存在
        
 
        
 
                             
         InputStreamReader read = 
         new 
         InputStreamReader(
        
 
        
 
                             
         new 
         FileInputStream(file),encoding);
         //考虑到编码格式
        
 
        
 
                             
         BufferedReader bufferedReader = 
         new 
         BufferedReader(read);
        
 
        
 
                             
         String lineTxt = 
         null
         ;
        
 
        
 
                             
         while
         ((lineTxt = bufferedReader.readLine()) != 
         null
         ){
        
 
        
 
                                 
         System.out.println(lineTxt);
        
 
        
 
                             
         }
        
 
        
 
                             
         read.close();
        
 
        
 
                 
         }
         else
         {
        
 
        
 
                     
         System.out.println(
         "找不到指定的文件"
         );
        
 
        
 
                 
         }
        
 
        
 
                 
         } 
         catch 
         (Exception e) {
        
 
        
 
                     
         System.out.println(
         "读取文件内容出错"
         );
        
 
        
 
                     
         e.printStackTrace();
        
 
        
 
                 
         }
        
 
        
 
              
        
 
        
 
             
         }
        
 
        
 
              
        
 
        
 
             
         public 
         static 
         void 
         main(String argv[]){
        
 
        
 
                 
         String filePath = 
         "L:\\Apache\\htdocs\\res\\20121012.txt"
         ;
        
 
        
 
         //      "res/";
        
 
        
 
                 
         readTxtFile(filePath);
        
 
        
 
             
         }
        
 
        
 
              
        
 
        
 
              
        
 
        

           
        
 
        
 
         }
        
 
       
 
 
  
 
 
 

文件句柄
 
 
 
在文件I/O中，要从一个文件读取数据，应用程序首先要调用操作系统函数并传送文件名，并选一个到该文件的路径来打开文件。该函数取回一个顺序号，即文件句柄（file handle），该文件句柄对于打开的文件是唯一的识别依据。要从文件中读取一块数据，应用程序需要调用函数readFile，并将文件句柄在内存中的地址和要拷贝的字节数传送给操作系统。当完成任务后，再通过调用系统函数来关闭该文件。
 
 
文件句柄和文件描述符
 
 
 
文件句柄是windows里面的叫法，文件描述符是linux里面的叫法。其实两者是同样的概念。
 
 
最大文件句柄数
 
 
 
Linux 进程最多能够打开的文件句柄数(这里的文件句柄数包括socket数，从网络读取数据也是另外一种文件读取方式)是有限制的，超过了这个限制，应用程序就会抛出异常(Too many open files.)。在Android 上，最大的数量一般都是1024，但一些定制的rom可能会有一些差别。另外，有一个概念需要先明确，文件句柄数，并不是打开的文件数。因为一个文件即使被打开，也可能没有文件描述符。
 
 
获取文件句柄数
 
 
 
那么遇到问题的时候，如何获取某个进程的文件句柄数呢？
 
 
获取进程对应的ID：adb shell ps | grep '进程名'
进入到对应的目录：cd /proc/进程ID/fd
使用下面的命令即可能够获取到对应进程的文件句柄数：
 ls /proc/进程ID/fd -l
如想要获取当前进程socket占用的文件句柄数，可以增加多个过滤：
 ls /proc/进程ID/fd -l | grep socket -c
 
文件句柄泄漏定位
 
通常的分析手法如下(转自：https://blog.csdn.net/xiaolli/article/details/56012228)：
 (1). 确定是哪类文件打开太多，没有关闭.
 
 
fd leaks, 通常伴随着此进程会出现Java Exception, Native Exception 等. 在mtk 的AEE DB 中, 有一支文件 PROCESS_FILE_STATE 描述, 此进程的打开的所有文件.
 查看此文件, 确定哪个或者哪种文件打开数量最多，即追查此类文件打开如此多, 而没有被关闭的原因.
 
 
如果没有DB, 当发生文件句柄泄露到1024 时, 在L 版本后, 在Kernel Log 中search “FDLEAK”, 在L 版本之前, 在Kernel Log 中search “FS_TAG”, 即可枚举出所有的此进程所打开的文件.
 
 
如果问题容易复现，可以直接 adb shell ls -a -l /proc/pid/fd , 直接打印出当前此process 所有打开的文件.
 
 
(2). 确定此类文件是在哪里打开.
 
 
 
对于一些确定的文件, 比如/data/data/xxxx_app/yyyy 之类的文件, 通常开发者自己可以快速的确定打开文件的位置，基本上不需要debug,对于一些另外一些常见的场景说明如下：
 
 
大批量的打开“anon_inode:[eventpoll]” 和 “pipe”, 超过100个eventpoll, 通常情况下是开启了太多的HandlerThread/Looper/MessageQueue, 线程忘记关闭, 或者looper 没有释放. 可以抓取hprof 进行快速分析. 抓取hprof 可以参考FAQ:http://online.mediatek.com/Pages/FAQ.aspx?List=SW&FAQID=FAQ08893
对于system server, 如果有大批量的socket 打开, 可能是因为Input Channel 没有关闭, 此类同样抓取hprof, 查看system server 中WindowState 的情况.
大批量的打开“/dev/ashmem”, 如果是Context provider, 或者其他app, 很可能是打开数据库没有关闭, 或者数据库链接频繁打开忘记关闭.
 
(3). 暴力确定文件打开的位置
 
MTK 有开发了fd leaks debug 功能，可以记录每次打开fd 的backtrace, 可以参考FAQ： http://online.mediatek.com/Pages/FAQ.aspx?List=SW&FAQID=FAQ11422
 
(4). 修正

Java中的句柄与资源泄露
 
作者：邵发
 官网：http://afanihao.cn/java
 
本文内容介绍Java中的句柄与资源泄露问题，是Java网站开发中必须清楚掌握的基本概念。句柄包括两类：文件句柄和网络句柄。本文是Java学习指南系列教程的官方配套文档，配套示例代码或者视频讲解。
 
在项目开发中，句柄的概念极为重要。如果不了解句柄，就可能发生以下错误：
 
文件被占用，无法删除或移动
Tomcat资源占满，无法访问
MySQL数据库连接数已满，无法连接
 
 
1.  文件句柄
 
句柄 ( Handle ) ，是一种系统资源。在实际编程中分为两类：文件句柄，网络句柄（Socket）。
 
先说文件句柄。当在程序里打开一个文件的时候，操作系统内核里创建了一个文件句柄，该句柄为当前进程拥有。比如，
      InputStream inputStream = new FileInputStream(“C:\test\example.txt”);
 此时就打开了一个文件句柄。文件句柄在用完之后一定要执行close 关闭，在close的时候会释放系统资源。即使用以下的代码框架：
 
InputStream inputStream = new FileInputSteam( file );
try{
   ... 读取文件 ...
}
finally{
    inputStream.close();
}
 
无论在try{}中有无异常发生，总是在finally{}中执行close()方法，确保文件句柄的释放。
 
涉及到文件句柄的地方有：
 
// 读取一个文件
InputStream inputStream = new FileInputStream( file )
// 写入一个文件
OutputStream outputStream = new OutputStream (file)
// 随机读写文件 ( 不常见 )
RandomAccessFile  raf = new RandomAccessFile (file, "rw")
 
也就是说，创建一个InputStream / OutputStream / RandomAccessFile 对象时，各自对应了一个句柄。所有带句柄的对象，在用完之后要记得关闭掉。
 
需要区分的是，File对象只是一个文件路径，相当于String的包装类，它是不对应文件句柄的。例如，File f = new File(“C:\test\example.txt”) 这只是定义了一个路径，什么事都没有发生，不会创建文件句柄。
 
 
 
2.  网络句柄
 
当在项目中使用网络编程技术时，也需引起我们的注意。一个Socket对应一个句柄，可以称为网络句柄。网络句柄和文件句柄一样，都是有限的资源，也是用完了就必须关闭。
 
涉及网络句柄的地方有：
 
2.1 Socket 和 ServerSocket
 
在TCP网络编程中的Socket和ServerSocket代表了网络句柄，以下示例详见Java学习指南系列的《网络通信篇》视频教程。
 
// 服务器：创建一个ServerSocket的时候，句柄数加1
ServerSocket  serverSock = new ServerSocket(2019);
// 服务器：接收到一个客户端连接的时候，句柄数加1
Socket sock = serverSock.accept();
// 客户端：连接上服务器的时候，句柄数加1
Socket sock = new Socket();
sock.connect( new InetSocketAddress("127.0.0.1",2019));
 
也就是说，一个Socket / ServerSocket 对象各自对应了一个句柄。
 
2.2 JDBC Connection
 
在数据库JDBC编程中，需要获取一个Connection对象，代表一个与MySQL服务器之间的一个链接。例如，
 
Connection conn = DriverManager.getConnection(connectionUrl, username, password);
try{
   ...
} finally {
   conn.close();
}
 
这个Connection对象内部会包含一个Socket连接，所以它也对应一个句柄，在用完后应当及时关闭。
 
 
 
2.3 HttpServletRequest和HttpServletResponse
 
在Java网站开发时，HttpServletRequest和HttpServletResponse内部包含了网络Socket连接，但是这个Socket是被Tomcat框架自己管理的，我们看不到也管不着。
 
比如，在处理Servlet请求时，
 
OutputStream outputStream = response.getOutputStream();
outputStream.write( data );
 
可以脑补一下，从HttpServletResponse获取OutputStream，其内部实现不就是从Socket中获取OutputStream吗？
 
Tomcat本身是一个Java写的TCP服务器，当一个客户端请求到来时，它会创建一个Socket并创建一个线程来处理。所以在实际运行时，一个请求对应一个线程和一个Socket资源的。再强调一遍，这个Socket是由Tomcat自行管理的，我们看不到也管不着。
 
 
 
3.  句柄数量的监测
 
一个进程可创建的句柄是有限的，以前的Windows或Linux上最多可以创建约2000多个。但是最新的Win10系统似乎突破了这个限制。
 
可以自己试一下，
 
public static void main(String[] args) throws Exception
{
	File file = new File("C:/test/example.txt");
	byte[] buf = new byte[4000];
	for(int i=1; i<10000; i++)
	{
		InputStream is = new FileInputStream(file);
		is.read(buf);
		System.out.println("创建第" + i + "个文件句柄");
	}
	System.out.println("Exit.");
}
 
在任务管理器里，可以观察到一个进程所占用的系统资源，如CPU、内存、线程数、句柄数。其中，线程和句柄两列默认是隐藏的，必须打开这两列的显示。按 CTRL + SHIFT + ESC，打开任务管理器，如下图所示。
 
 
如果没有显示句柄这一列的话，可以右键点一下CPU这个标签，选择列即可显示（自己百度一下）。
 
在这里可以看到每一个进程所占用的资源情况，我们的Java进程的名称是java.exe或者javaw.exe。比如，Eclipse启动时对应一个javaw.exe进程。
 
以单步调试的方式运行上述代码，可以发现每创建一个FileInputStream对象，该进程的句柄数会加1。如果调用了close()方法，则句柄数会减1。
 
4.  句柄与GC垃圾回收
 
Java里有一个GC垃圾回收机制，可以把失去引用的对象自动回收。比如，
 
for(int i=1; i<10000; i++)
{
	InputStream inputStream = new FileInputStream(file);
	inputStream.read(buf);
	System.out.println("创建第" + i + "个文件句柄");
}
 
此处，每一轮循环创建一个对象inputStream，此对象在循环之后失去引用，会被自动回收（销毁）。但是需要区分的是，此处销毁的是对象自身，并没有释放句柄啊！
 
在Java里，一定要显式地调用inputStream.close()才能够释放这个inputStream所对应的句柄资源。句柄释放和GC机制是两码事!
 
 
 
5.  try-with-resources
 
在有的代码里，形式上看不到close()的调用，但是句柄在内部被关闭了。比如，在MyBatis编程中经常可见的代码：
 
try ( SqlSession session = sqlSessionFactory.openSession() )  {
  // do work

}
 
在这里，并没有看到 session.close() 的调用，为什么呢？
 
此种try语法称为 try-with-resources，在小括号里是一个称为资源的对象。资源对象类型，就是实现了java.lang. AutoCloseable接口的类型。语法规定，在try{} 运行完后会自动调用resource.close()方法来关闭资源。可以认为这种语法是对try { } finally{} 的简写，相当于：
 
SqlSession session = sqlSessionFactory.openSession();
try {
// do work

}
finally {
	session.close();
}
 
记住，此种try-with-resources语法，是要求资源对象类型是实现了AutoCloseable接口的。你得自己检查一下，有这个接口的类型才能这么简写。
 
 
 
6.  线程与句柄
 
线程数和句柄数，都是有限的资源。一个程序不能开太多的线程，也不能开太多的句柄。
 
在网站开发中，这两个概念是相关的。表现在：
 (1) 当一个请求到来时，Tomcat创建一个线程，在线程里处理这个请求Socket。所以一个请求对应了一个线程和一个Socket句柄
 (2) 无论是线程占满、还是句柄占满，都会导致系统不可访问。
 
比如，如果句柄占满，则Tomcat无法创建新的Socket连接，自然也就不能访问了。
 
 
 
7.  句柄与服务器的稳定性
 
在网站开发中，通过观察任务管理器中的句柄数，可以检查有没有句柄泄露的情况。
 
如果句柄数保持稳定，则没有问题。如果持续增加、不见减少，就说明你的程序代码里有句柄泄露。如果已经达到上限（2000-3000），则服务器已经不可访问。
 
所谓句柄泄露，就是说你打开一个句柄但是忘了close掉。比如，
 - 打开了一个FileInputStream / FileOutputStream / RandomAccessFile 对象
 - 打开了一个数据库连接 Connection 对象 ( 或者封装后的 SqlSession 等)
 - 打开了一个Socket连接对象
 - 使用HttpClient / FTP Client等封装后的API，打开了一个网络连接但没有close掉 ...
 
凡是涉及到这些调用的地方，一定要仔细核对，因为这关系到你的服务器是否能长期稳定地运行。
 
 
 
最后，本文演示所用的项目源码及视频讲解 在此处获取 ，更多教程请注意 阿发你好 的Java学习指南系列教程。