当前位置: 首页 > news >正文

网上手机网站建设计划书/刷网站软件

网上手机网站建设计划书,刷网站软件,叶榭网站建设,代卖平台哪个好分享一下我老师大神的人工智能教程!零基础,通俗易懂!http://blog.csdn.net/jiangjunshow也欢迎大家转载本篇文章。分享知识,造福人民,实现我们中华民族伟大复兴!周末碰到一段代码,是关于Java IO…

分享一下我老师大神的人工智能教程!零基础,通俗易懂!http://blog.csdn.net/jiangjunshow

也欢迎大家转载本篇文章。分享知识,造福人民,实现我们中华民族伟大复兴!

 

周末碰到一段代码,是关于Java IO流的,代码中出现在一个多线程的系统中,其中一段代码在打开一个文件操作流用完以后没有及时关闭,开始以为很快会出现打开文件太多或者导致内存溢出,但是在运行了很长时间以后仍然没有出现问题,后来自己写了个小程序测试了一下,总算似乎搞清楚为啥了。

先看以下一段代码

[java] view plaincopyprint?
  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 plaincopyprint?
  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 plaincopyprint?
  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 plaincopyprint?
  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

这里写图片描述
http://www.lbrq.cn/news/1082485.html

相关文章:

  • 东莞寮步镇疫情最新情况/图片优化软件
  • 人工智能搭建/武汉整站优化
  • 旅游开发公司网站建设方案书/在哪里可以找到网站
  • 济宁b2b网站开发公司/2024政治时政热点
  • 电脑记事本做网站/江阴百度推广公司
  • 临朐网站建设建站/网页广告怎么做
  • 网站动画效果用什么程序做的/网络推广方案
  • 哪些网站做批发衣服好/石家庄seo网站管理
  • 做网站要会写什么/google关键词优化
  • 免费源码分享论坛/南京百度seo
  • 做中国供应商免费网站有作用吗/seo博客教程
  • 惠州网站建设推广/广州网站优化页面
  • 携程网站用js怎么做/北京软件培训机构前十名
  • 在线做家装设计的网站/网络营销seo培训
  • 厦门市app开发网站建设公司/可以推广赚钱的软件
  • 正定网站建设/自媒体平台注册
  • 海外营销平台有哪些/台州seo优化
  • 珠海网站友情链接/推广策略有哪些方法
  • 建筑工程网站搭建/网推平台
  • 网站关键词代码位置/克州seo整站排名
  • 品牌宣传网站建设/苏州百度搜索排名优化
  • 团购网站怎么做/西安网约车
  • 主要网站 开发语言/济南百度开户电话
  • 网站空间到期怎么办/百度搜索引擎下载
  • 泉州专业做网站公司/国内重大新闻十条
  • 方圆网站建设/产品关键词大全
  • 上海网站制作是什么/电商运营是做什么的
  • 移动网站 案例/2022百度seo优化工具
  • 哪个网站帮忙做户型方案/网站seo策划方案
  • 公司公众号怎么制作/seo优化入门教程
  • linux git ssh配置过程
  • 2023 年 NOI 最后一题题解
  • RHCA学习概述
  • RNN、LSTM、Transformer推荐博文
  • 30道JS高频经典笔试题集合+详解(一)
  • 用Python+MySQL实战解锁企业财务数据分析