2. 程式人生 > >Java檔案流關閉和垃圾回收問題

Java檔案流關閉和垃圾回收問題

阿新 • • 發佈：2018-11-16

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow

也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！

               

 

週末碰到一段程式碼，是關於Java IO流的，程式碼中出現在一個多執行緒的系統中，其中一段程式碼在開啟一個檔案操作流用完以後沒有及時關閉，開始以為很快會出現開啟檔案太多或者導致記憶體溢位，但是在運行了很長時間以後仍然沒有出現問題，後來自己寫了個小程式測試了一下，總算似乎搞清楚為啥了。

先看以下一段程式碼

[java] view plain copy print ?
  1. import java.io.FileInputStream;  
  2. public class TTT {  
  3.     public static void main(String[] args) throws
     Exception {  
  4.         for (int i = 0; i < 10; i++) {  
  5.             final String threadId = "thread_"
     + i;  
  6.             Thread thread = new Thread(new Runnable() {  
  7.                 public void run() {  
  8.                     System.out.println(threadId + " started!");  
  9.                     try {  
  10.                         FileInputStream fis = new FileInputStream("/opt/test.log");  
  11.                         Thread.sleep(60 * 1000);  
  12.                     } catch (Exception ex) {  
  13.                         ex.printStackTrace();  
  14.                     }  
  15.                     System.out.println(threadId + " stopped!");  
  16.                 }  
  17.             });  
  18.             thread.start();  
  19.         }  
  20.         Thread.sleep(10 * 60 * 1000);  
  21.     }  
  22. }  
import java.io.FileInputStream;public class TTT { public static void main(String[] args) throws Exception {  for (int i = 0; i < 10; i++) {   final String threadId = "thread_" + i;   Thread thread = new Thread(new Runnable() {    public void run() {     System.out.println(threadId + " started!");     try {      FileInputStream fis = new FileInputStream("/opt/test.log");      Thread.sleep(60 * 1000);     } catch (Exception ex) {      ex.printStackTrace();     }     System.out.println(threadId + " stopped!");    }   });   thread.start();  }  Thread.sleep(10 * 60 * 1000); }}

在linux上編譯並執行這個類，然後使用linux的命令/usr/sbin/lsof -p <pid>來檢視這個程式開啟的檔案資訊

[python] view plain copy print ?
  1. $ /usr/sbin/lsof -p `ps -ef | grep java | grep TTT | awk '{print $2}'` | grep "test.log"  
  2. java    21562 fkong    3r   REG  253,0        0 35471424 /opt/test.log  
  3. java    21562 fkong    4r   REG  253,0        0 35471424 /opt/test.log  
  4. java    21562 fkong    5r   REG  253,0        0 35471424 /opt/test.log  
  5. java    21562 fkong    6r   REG  253,0        0 35471424 /opt/test.log  
  6. java    21562 fkong    7r   REG  253,0        0 35471424 /opt/test.log  
  7. java    21562 fkong    8r   REG  253,0        0 35471424 /opt/test.log  
  8. java    21562 fkong    9r   REG  253,0        0 35471424 /opt/test.log  
  9. java    21562 fkong   10r   REG  253,0        0 35471424 /opt/test.log  
  10. java    21562 fkong   11r   REG  253,0        0 35471424 /opt/test.log  
  11. java    21562 fkong   12r   REG  253,0        0 35471424 /opt/test.log  
$ /usr/sbin/lsof -p `ps -ef | grep java | grep TTT | awk '{print $2}'` | grep "test.log"java    21562 fkong    3r   REG  253,0        0 35471424 /opt/test.logjava    21562 fkong    4r   REG  253,0        0 35471424 /opt/test.logjava    21562 fkong    5r   REG  253,0        0 35471424 /opt/test.logjava    21562 fkong    6r   REG  253,0        0 35471424 /opt/test.logjava    21562 fkong    7r   REG  253,0        0 35471424 /opt/test.logjava    21562 fkong    8r   REG  253,0        0 35471424 /opt/test.logjava    21562 fkong    9r   REG  253,0        0 35471424 /opt/test.logjava    21562 fkong   10r   REG  253,0        0 35471424 /opt/test.logjava    21562 fkong   11r   REG  253,0        0 35471424 /opt/test.logjava    21562 fkong   12r   REG  253,0        0 35471424 /opt/test.log 

 

不管是在10個執行緒執行過程中還是執行完，使用lsof命令檢視的結果都一樣，都可以看到有10個檔案流沒有關閉。

 

下面我把這個程式碼做了一些改動，就是線上程執行完之後，將所有執行緒置為null，如下

[java] view plain copy print ?
  1. import java.io.FileInputStream;  
  2. import java.util.ArrayList;  
  3. import java.util.List;  
  4. public class TTT {  
  5.     public static void main(String[] args) throws Exception {  
  6.         List<Thread> threads = new ArrayList<Thread>();  
  7.         for (int i = 0; i < 10; i++) {  
  8.             final String threadId = "thread_" + i;  
  9.             Thread thread = new Thread(new Runnable() {  
  10.                 public void run() {  
  11.                     System.out.println(threadId + " started!");  
  12.                     try {  
  13.                         FileInputStream fis = new FileInputStream("/opt/test.log");  
  14.                         Thread.sleep(60 * 1000);  
  15.                     } catch (Exception ex) {  
  16.                         ex.printStackTrace();  
  17.                     }  
  18.                     System.out.println(threadId + " stopped!");  
  19.                 }  
  20.             });  
  21.             thread.start();  
  22.             threads.add(thread);  
  23.         }  
  24.         Thread.sleep(2 * 60 * 1000);  
  25.         for (Thread thread : threads) {  
  26.             thread = null;  
  27.         }  
  28.         System.out.println("Clean up threads!");  
  29.         Thread.sleep(10 * 60 * 1000);  
  30.     }  
  31. }  
import java.io.FileInputStream;import java.util.ArrayList;import java.util.List;public class TTT { public static void main(String[] args) throws Exception {  List<Thread> threads = new ArrayList<Thread>();  for (int i = 0; i < 10; i++) {   final String threadId = "thread_" + i;   Thread thread = new Thread(new Runnable() {    public void run() {     System.out.println(threadId + " started!");     try {      FileInputStream fis = new FileInputStream("/opt/test.log");      Thread.sleep(60 * 1000);     } catch (Exception ex) {      ex.printStackTrace();     }     System.out.println(threadId + " stopped!");    }   });   thread.start();   threads.add(thread);  }  Thread.sleep(2 * 60 * 1000);  for (Thread thread : threads) {   thread = null;  }  System.out.println("Clean up threads!");  Thread.sleep(10 * 60 * 1000); }} 

 

 

再次在10個執行緒執行過程中和執行完畢後使用lsof檢視，結果仍然類似，還是有10個檔案流沒有關閉。

 

我再次做了一些改動，在將所有執行緒置為null以後，增加(或者說是催促JVM)做幾次gc操作，如下：

[java] view plain copy print ?
  1. import java.io.FileInputStream;  
  2. import java.util.ArrayList;  
  3. import java.util.List;  
  4. public class TTT {  
  5.     public static void main(String[] args) throws Exception {  
  6.         List<Thread> threads = new ArrayList<Thread>();  
  7.         for (int i = 0; i < 10; i++) {  
  8.             final String threadId = "thread_" + i;  
  9.             Thread thread = new Thread(new Runnable() {  
  10.                 public void run() {  
  11.                     System.out.println(threadId + " started!");  
  12.                     try {  
  13.                         FileInputStream fis = new FileInputStream("/opt/test.log");  
  14.                         Thread.sleep(60 * 1000);  
  15.                     } catch (Exception ex) {  
  16.                         ex.printStackTrace();  
  17.                     }  
  18.                     System.out.println(threadId + " stopped!");  
  19.                 }  
  20.             });  
  21.             thread.start();  
  22.             threads.add(thread);  
  23.         }  
  24.         Thread.sleep(2 * 60 * 1000);  
  25.         for (Thread thread : threads) {  
  26.             thread = null;  
  27.         }  
  28.         System.out.println("Clean up threads!");  
  29.           
  30.         System.gc();  
  31.         System.gc();  
  32.         System.gc();  
  33.         System.out.println("Finished GC!");  
  34.           
  35.         Thread.sleep(10 * 60 * 1000);  
  36.     }  
  37. }  
import java.io.FileInputStream;import java.util.ArrayList;import java.util.List;public class TTT { public static void main(String[] args) throws Exception {  List<Thread> threads = new ArrayList<Thread>();  for (int i = 0; i < 10; i++) {   final String threadId = "thread_" + i;   Thread thread = new Thread(new Runnable() {    public void run() {     System.out.println(threadId + " started!");     try {      FileInputStream fis = new FileInputStream("/opt/test.log");      Thread.sleep(60 * 1000);     } catch (Exception ex) {      ex.printStackTrace();     }     System.out.println(threadId + " stopped!");    }   });   thread.start();   threads.add(thread);  }  Thread.sleep(2 * 60 * 1000);  for (Thread thread : threads) {   thread = null;  }  System.out.println("Clean up threads!");    System.gc();  System.gc();  System.gc();  System.out.println("Finished GC!");    Thread.sleep(10 * 60 * 1000); }} 

 

再次使用lsof檢視，在執行中仍然還是可以看到那有10個檔案流開啟著，但是在“Finished GC!”之後，看到的結果是那10個開啟的檔案流都被關閉了。

 

最後，我乾脆把那些設定thread為null的語句刪除了，執行的結果也和上面執行gc操作的結果一致。

 

最終，JVM中對於那些打開了沒有關閉的IO檔案流，會在不再被使用的情況下，等到下次做Full GC的時候把他們全部回收，但是讓JVM去幹這些事總歸還是不好的，還是那句老話，自己的事情自己做。

 

 

 

 

 

 

 

           

給我老師的人工智慧教程打call！http://blog.csdn.net/jiangjunshow

這裡寫圖片描述

相關推薦

Java檔案流關閉和垃圾回收問題

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

java記憶體結構和垃圾回收機制

java和c語言不同 開發c語言專案，需要程式設計師手動清理垃圾，而java有垃圾自動回收機制。它可以減少記憶體異常發生的機率。 一、java的記憶體結構，可以分為五個區域： 1、程式計數器，它儲存的是程式當前執行的指令的地址，也就是說是用來指示 執行哪條指令的。在多執行緒的環境下，

JAVA學習--檔案流FileInputStream和FileOutputStream操作

* 1.流的分類：  * 按照資料流向的不同：輸入流  輸出流  * 按照處理資料的單位的不同：位元組流  字元流（處理的文字檔案）  * 按照角色的不同：節點流（直接作用於檔案的）  處理流  *   * 2

Java中的引用型別（強引用、弱引用）和垃圾回收

Java中的引用型別和垃圾回收 強引用Strong References 　　強引用是最常見的引用： 　　比如： StringBuffer buffer = new StringBuffer(); 　　建立了一個StringBuffer類的物件，並用一個變數buffer儲存對這個

Java程式設計思想-終結處理和垃圾回收

關於垃圾回收要知道三點： 物件可能不被垃圾回收 垃圾回收並不等於“析構” 垃圾回收只與記憶體有關 垃圾回收器如何工作？ 可以將對想象成一個傳送帶，每分配一個物件，傳送帶就往前移動一格，然而這樣的弊端是會造成頻繁的記憶體頁面排程（將其移進移出硬碟）進而影響效能，當建立

Java 檔案流一：位元組流（FileInputStream 和 FileOutputStream）

   Java檔案流操作是一個非常重要的內容。下圖列舉了關於Java基本的檔案流操作，當然目前還有NIO，這個後來會進行討論，先看基本的檔案流操作。我們主要使用的是訪問檔案的流和緩衝流。   檔案的流操作一般包含字元流和位元組流，兩者區別在於，字元流每次傳播16bit資

Java的堆、棧和垃圾回收

平常寫Android，慢慢忘了很多的Java的基礎知識，之後看到一道面試題，其實就是java能否實現像c一樣的swap方法 public static void main(String[] args) { MyClass myClass

Java程式和垃圾回收機制

一、java程式的基本規則 1.java程式的組織形式 類是java程式的最小程式單位。空類不能被java命令解釋執行，但並不表示這個類是錯誤的。 如果類能被直譯器直接解釋執行，則這個類必須包含main方法，而且main方法必須使用public static void來修飾

【Java】finalize()和垃圾回收機制

finalize()方法：一旦gc準備釋放物件佔用的儲存空間，將首先呼叫finalize()方法，並在下一次垃圾回收動作發生時才會真正回收記憶體。可在此進行重要的清理操作。gc只能釋放那些經由new分配的記憶體，對其他形式獲得的記憶體無法釋放。finalize()方法不一定

java架構之路-（12）JVM垃圾回收演算法和垃圾回收器

　　接上次JVM虛擬機器堆記憶體模型來繼續說，上次我們主要說了什麼時候可能把物件直接放在老年代，還有我們的可能性分析，提出GCroot根的概念。這次我們主要來說說垃圾回收所使用的的演算法和我們的垃圾回收器，需要了解我們的可達性分析GCroot根是什麼，還有我們的動態年齡判斷和老年代分配擔保機制，還不清楚咋回事

JVM內存管理機制和垃圾回收機制

mark 代碼 本地方法棧 final類 boot 存取 帶來 logs byte JVM自身結構物理圖： Java代碼編譯和執行的整個過程包含了以下三個重要的機制： 1.java源碼編譯機制 1）分析和輸入到符號表 class文件結構包含： 結構

[轉] javascript中的變量和垃圾回收

tor 們的 問題 只有一個 次數 ie9 內存 通過 保持 [From] http://www.imooc.com/article/4585 基本類型和引用類型 js中的變量雖然不區分類型,但是實際上Ecmascript包含兩種類型,基本類型和引用類型. 基本類型有5

C#內存管理和垃圾回收機制

委托 釋放 strong 實時性 作用 集成 一定的 簡介 box 數據類型 垃圾回收機制 一、數據類型 C#中的數據類型分為值類型 (Value type) 和引用類型(reference type)， 值 類 型： 所有的值類型都集成自 System.ValueT

深入理解JAVA虛擬機閱讀筆記——垃圾回收器

ont 分享 root 深入理解 .com 筆記 直接 用戶線程 另一個 一、垃圾收集器總覽 新生代：Serial、 ParNew、 Parallel Scavenge 老年代：CMS、Serial Old、 Parallel Old 最新的：G1 並行和並發的區別：

Java 內存分配及垃圾回收機制初探

com 分配內存 str return ability 占用 基礎 而是 oat 一、運行時內存分配 Java虛擬機在執行Java程序的過程中會把它所管理的內存劃分為若幹個不同的數據區域。 這些區域都有各自的用途，以及創建和銷毀的時間，有的區域隨著虛擬機進程的啟動而存在，

清理：處理終結和垃圾回收

首先，Java也有垃圾收集器，且回收不在使用的物件佔據的記憶體，但有一種特殊的情況-------沒有使用new，但垃圾收集器只知道釋放由new分配的記憶體，此時就需要用到finalize()方法。 在理想情況下，它的工作原理應該是這樣的：一旦垃圾收集器準備好釋放物件佔用的儲存空間，它首先呼叫fi

Java中的物件與垃圾回收機制

物件在記憶體中的狀態 當一個物件在堆記憶體中執行時，根據它被引用變數所引用的狀態，可以把它所處的狀態分為如下三種。 可達狀態：當一個物件被建立之後，若有一個以上的引用變數引用它，則這個物件在程式中處於可達狀態，程式可以通過引用變數來呼叫該物件的例項變數和方法。 可

JavaScript 的記憶體洩露和垃圾回收

什麼是記憶體洩露 ? 任何程式語言，在執行時都需要使用到記憶體，比如在一個函式中， var arr = [1, 2, 3, 4, 5]; 這麼一個數組，就需要記憶體。 但是，在使用了這些記憶體之後， 如果後面他們不會再被用到，但是還沒有及時釋放，這就叫做記憶體洩露（memory

java中的物件與垃圾回收

java的垃圾回收時java語言得重要功能之一。當程式建立物件、陣列等引用型別實體時，系統都會在堆記憶體中為之分配一塊記憶體區，物件就儲存在這塊記憶體區，當這塊記憶體區不在被任何引用變數所引用時，這塊記憶體就變成了垃圾，等待垃圾回收機制進行回收。 垃圾回收機制只負責回收堆記憶體中

JAVA檔案流的讀寫

package trsdf; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import j