IT神童

java,net,php技术研究神童

2012年8月23日

让Java代码跑得更快

本文简单介绍一下在写代码过程中用到的一些让JAVA代码更高效的技巧。

1,将一些系统资源放在池中,如数据库连接,线程等.在standalone的应用中,数据库连接池可以使用一些开源的连接池实现,如C3P0,proxool和DBCP等,在运行在容器中的应用这可以使用服务器提供的DataSource.线程池可以使用JDK本身就提供的java.util.concurrent.ExecutorService.

  1. import java.util.concurrent.Executors;  
  2. import java.util.concurrent.ExecutorService;  
  3. public class JavaThreadPool {  
  4.     public static void main(String[] args) {  
  5.     ExecutorService pool = Executors.newFixedThreadPool(2);  
  6.       
  7.     Thread t1 = new MyThread();  
  8.     Thread t2 = new MyThread();  
  9.     Thread t3 = new MyThread();  
  10.     Thread t4 = new MyThread();  
  11.     Thread t5 = new MyThread();  
  12.  
  13.     pool.execute(t1);  
  14.     pool.execute(t2);  
  15.     pool.execute(t3);  
  16.     pool.execute(t4);  
  17.  
  18.     pool.shutdown();  
  19.     }  
  20. }  
  21.  
  22. class MyThread extends Thread {  
  23.     public void run() {  
  24.     System.out.println(Thread.currentThread().getName() + "running....");  
  25.     }  
  26. }  

2,减少网络开销,在和数据库或者远程服务交互的时候,尽量将多次调用合并到一次调用中。

3,将经常访问的外部资源cache到内存中,简单的可以使用static的hashmap在应用启动的时候加载,也可以使用一些开源的cache框架,如OSCache和Ehcache等.和资源的同步可以考虑定期轮询和外部资源更新时候主动通知.或者在自己写的代码中留出接口(命令方式或者界面方式)共手动同步。

4,优化IO操作,JAVA操作文件的时候分InputStream and OutputStream,Reader and Writer两类,stream的方式要快,后者主要是为了操作字符而用的,在字符仅仅是ASCII的时候可以用stream的方式提高效率.JDK1.4之后的nio比io的效率更好。java教程下载

  1. OutputStream out = new BufferedOutputStream(new FileOutputStream(new File("d:/temp/test.txt")));              
  2. out.write("abcde".getBytes());        
  3. out.flush();  
  4. out.close(); 

利用BufferedInputStream,BufferedOutputStream,BufferedReader,BufferedWriter减少对磁盘的直接访问次数。

  1. FileReader fr = new FileReader(f);  
  2. BufferedReader br = new BufferedReader(fr);  
  3. while (br.readLine() != null) count++; 

5不要频繁的new对象,对于在整个应用中只需要存在一个实例的类使用单例模式.对于String的连接操作,使用StringBuffer或者StringBuilder.对于utility类型的类通过静态方法来访问。

6,避免使用错误的方式,如Exception可以控制方法推出,但是Exception要保留stacktrace消耗性能,除非必要不要使用instanceof做条件判断,尽量使用比的条件判断方式.使用JAVA中效率高的类,比如ArrayList比Vector性能好。

7,对性能的考虑要在系统分析和设计之初就要考虑。

总之,一个系统运行时的性能,无非是从CPU,Memory和IO这三个主要方面来考虑优化.减少不必要的CPU消耗,减少不必要的IO操作,增加Memory利用效率。

posted @ 2012-08-23 14:42 IT神童 阅读(534) | 评论 (0)编辑 收藏

Java高并发:静态页面生成方案

提升网站性能的方式有很多,例如有效的使用缓存,生成静态页面等等。今天要说的就是生成静态页面的方式。这个也是我近期一直在搞的一个问题,近期在做使用html + servlet做个人网站,为什么是这2个东西呢?

1、直接用servlet是为了保证网站能以最快的速度执行命令个人总感觉像Struts hibernate spring之类的虽然方便但是效能带来的损耗不太能接收

2、使用html同样是为了保证最快的反应速度,毕竟html 比jsp少了一层服务器执行。速度上要快的多

一、在这里要先说一下什么是页面静态化:

简单的说,我们如果访问一个链接 ,服务器对应的模块会处理这个请求,转到对应的jsp界面,最后生成我们想要看到的数据。这其中的缺点是显而易见的:因为每次请求服务器都会进行处理,如果有太多的高并发请求,那么就会加重应用服务器的压力,弄不好就把服务器 搞down 掉了。那么如何去避免呢?如果我们把对 test.do 请求后的结果保存成一个 html 文件,然后每次用户都去访问 ,这样应用服务器的压力不就减少了?

那么静态页面从哪里来呢?总不能让我们每个页面都手动处理吧?这里就牵涉到我们要讲解的内容了,静态页面生成方案… 我们需要的是自动的生成静态页面,当用户访问 ,会自动生成 test.html ,然后显示给用户。

二、下面我们在简单介绍一下要想掌握页面静态化方案应该掌握的知识点

1、 基础- URL Rewrite

什么是 URL Rewrite 呢 ? URL 重写。用一个简单的例子来说明问题:输入网址 ,但是实际上访问的却是 abc.com/test.action,那我们就可以说 URL 被重写了。这项技术应用广泛,有许多开源的工具可以实现这个功能。java电子书免费下载2、 基础- Servlet web.xml

如果你还不知道 web.xml 中一个请求和一个 servlet 是如何匹配到一起的,那么请搜索一下 servlet 的文档。这可不是乱说呀,有很多人就认为 /xyz/*.do 这样的匹配方式能有效。

如果你还不知道怎么编写一个 servlet ,那么请搜索一下如何编写 servlet.这可不是说笑呀,在各种集成工具漫天飞舞的今天,很多人都不会去从零编写一个 servlet了。

三、基本的方案介绍

其中,对于 URL Rewriter的部分,可以使用收费或者开源的工具来实现,如果 url不是特别的复杂,可以考虑在 servlet 中实现,那么就是下面这个样子:
 

posted @ 2012-08-23 14:41 IT神童 阅读(140) | 评论 (0)编辑 收藏

公司的Java框架应具备的通用功能

以前在学校的时候自己以为是不是每个做JAVA开发的公司每次做项目的时候都要搭建一个SSH框架呢,工作之后才发现每个公司都有自己的一套框架,要不是在SSH基础上,要不是在SSI基础上进行了符合自己公司需求的封装,并且随着自己公司的框架被应用到各个实际系统的过程中,这个框架会越来越成熟,会使该公司的开发效率越来越高。

根据笔者接触过的几个公司的框架,笔者发现要想实现高效的开发,每个公司的框架应该具备如下的特点:

1.具有灵活的分页功能。

分页功能是每个项目中必须要实现的功能,而恰恰这个功能是比较费时费力的,如果在框架中实现这一功能,将在每个项目中大大减少分页的重复性工作。

2.可以方便的实现文件的上传与下载、数据的导入和导出的功能。

文件的上传于下载、数据的导入和导出在大部门项目中也会遇到,但是这两个功能可能会因为项目的不同导致实现上有一点区别,我们框架中要做的就是应该抽出其中共有的东西,定义为抽象的东西,以便不同的项目、不同的需求都能很容易的实现该功能。成都java培训机构
3.方便的事务管理功能。

事务管理一般来说都定义在业务逻辑层。我们框架中应该实现对业务逻辑对象事务的简单配置甚至是零配置。笔者接触过的两个框架中,一个需要在配置完一个业务逻辑对象时,在事务管理的配置文件中加上一句简单的配置即可,另一个是框架中实现了几个基本的业务逻辑对象,并对这几个对象实现了事务管理的配置,开发的时候定义的业务逻辑对象都是继承自这几个基本对象,也就省去了事务管理的配置。

4.具有异常处理框架。

基本上每个项目的异常处理都应该可以使用公司的框架定义的异常处理框架,并不会因为项目的不同而要求的异常处理也不一样。

5.具有自己的一套页面组件。

项目开发都是团队的开发,要想保证每个开发人员的界面风格统一,最好的办法就是定义一套公司自己的页面组建。这样既能保证开发效率,也能做到界面的统一。freemark就是不错的选择,其支持自定义宏,公司框架中可以定义一套自己的页面组建宏,供开发人员调用即可。


 

6.具有数据校验框架。

每个项目在数据校验时都可能会用到大量的正则表达式,那么在公司的框架中将这些正则表达式封装起来,提供统一的调用接口将是不错的选择。

7.简单的实现菜单的配置。

一个好的框架应该提供对菜单、二级菜单等的简单配置、管理。还是上文提到的两个框架,一个是通过XML配置文件实现了对系统中一级菜单、二级菜单、三级菜单的管理,而另个框架要实现相同的需求却要在数据库中进行繁琐的配置,显然第一个框架的实现方案更可取、更高效。

posted @ 2012-08-23 14:40 IT神童 阅读(264) | 评论 (1)编辑 收藏

Java中用内存映射处理大文件

在处理大文件时,如果利用普通的FileInputStream 或者FileOutputStream 抑或RandomAccessFile 来进行频繁的读写操作,都将导致进程因频繁读写外存而降低速度.如下为一个对比实验。

  1. package test;  
  2.  
  3. import java.io.BufferedInputStream;  
  4. import java.io.FileInputStream;  
  5. import java.io.FileNotFoundException;  
  6. import java.io.IOException;  
  7. import java.io.RandomAccessFile;  
  8. import java.nio.MappedByteBuffer;  
  9. import java.nio.channels.FileChannel;  
  10.  
  11. public class Test {  
  12.  
  13.       
  14.     public static void main(String[] args) {  
  15.         try {  
  16.             FileInputStream fis=new FileInputStream("/home/tobacco/test/res.txt");  
  17.             int sum=0;  
  18.             int n;  
  19.             long t1=System.currentTimeMillis();  
  20.             try {  
  21.                 while((n=fis.read())>=0){  
  22.                     sum+=n;  
  23.                 }  
  24.             } catch (IOException e) {  
  25.                 // TODO Auto-generated catch block  
  26.                 e.printStackTrace();  
  27.             }  
  28.             long t=System.currentTimeMillis()-t1;  
  29.             System.out.println("sum:"+sum+"  time:"+t);  
  30.         } catch (FileNotFoundException e) {  
  31.             // TODO Auto-generated catch block  
  32.             e.printStackTrace();  
  33.         }  
  34.           
  35.         try {  
  36.             FileInputStream fis=new FileInputStream("/home/tobacco/test/res.txt");  
  37.             BufferedInputStream bis=new BufferedInputStream(fis);  
  38.             int sum=0;  
  39.             int n;  
  40.             long t1=System.currentTimeMillis();  
  41.             try {  
  42.                 while((n=bis.read())>=0){  
  43.                     sum+=n;  
  44.                 }  
  45.             } catch (IOException e) {  
  46.                 // TODO Auto-generated catch block  
  47.                 e.printStackTrace();  
  48.             }  
  49.             long t=System.currentTimeMillis()-t1;  
  50.             System.out.println("sum:"+sum+"  time:"+t);  
  51.         } catch (FileNotFoundException e) {  
  52.             // TODO Auto-generated catch block  
  53.             e.printStackTrace();  
  54.         }  
  55.           
  56.         MappedByteBuffer buffer=null;  
  57.         try {  
  58.             buffer=new RandomAccessFile("/home/tobacco/test/res.txt","rw").getChannel().map(FileChannel.MapMode.READ_WRITE, 01253244);  
  59.             int sum=0;  
  60.             int n;  
  61.             long t1=System.currentTimeMillis();  
  62.             for(int i=0;i<1253244;i++){  
  63.                 n=0x000000ff&buffer.get(i);  
  64.                 sum+=n;  
  65.             }  
  66.             long t=System.currentTimeMillis()-t1;  
  67.             System.out.println("sum:"+sum+"  time:"+t);  
  68.         } catch (FileNotFoundException e) {  
  69.             // TODO Auto-generated catch block  
  70.             e.printStackTrace();  
  71.         } catch (IOException e) {  
  72.             // TODO Auto-generated catch block  
  73.             e.printStackTrace();  
  74.         }  
  75.  
  76.     }  
  77.  
  78. }  
java基础教程
测试文件为一个大小为1253244字节的文件。测试结果:
  1. sum:220152087 time:1464  
  2. sum:220152087 time:72  
  3. sum:220152087 time:25 

说明读数据无误。删去其中的数据处理部分。

  1. package test;  
  2.  
  3. import java.io.BufferedInputStream;  
  4. import java.io.FileInputStream;  
  5. import java.io.FileNotFoundException;  
  6. import java.io.IOException;  
  7. import java.io.RandomAccessFile;  
  8. import java.nio.MappedByteBuffer;  
  9. import java.nio.channels.FileChannel;  
  10.  
  11. public class Test {  
  12.  
  13.       
  14.     public static void main(String[] args) {  
  15.         try {  
  16.             FileInputStream fis=new FileInputStream("/home/tobacco/test/res.txt");  
  17.             int sum=0;  
  18.             int n;  
  19.             long t1=System.currentTimeMillis();  
  20.             try {  
  21.                 while((n=fis.read())>=0){  
  22.                     //sum+=n;  
  23.                 }  
  24.             } catch (IOException e) {  
  25.                 // TODO Auto-generated catch block  
  26.                 e.printStackTrace();  
  27.             }  
  28.             long t=System.currentTimeMillis()-t1;  
  29.             System.out.println("sum:"+sum+"  time:"+t);  
  30.         } catch (FileNotFoundException e) {  
  31.             // TODO Auto-generated catch block  
  32.             e.printStackTrace();  
  33.         }  
  34.           
  35.         try {  
  36.             FileInputStream fis=new FileInputStream("/home/tobacco/test/res.txt");  
  37.             BufferedInputStream bis=new BufferedInputStream(fis);  
  38.             int sum=0;  
  39.             int n;  
  40.             long t1=System.currentTimeMillis();  
  41.             try {  
  42.                 while((n=bis.read())>=0){  
  43.                     //sum+=n;  
  44.                 }  
  45.             } catch (IOException e) {  
  46.                 // TODO Auto-generated catch block  
  47.                 e.printStackTrace();  
  48.             }  
  49.             long t=System.currentTimeMillis()-t1;  
  50.             System.out.println("sum:"+sum+"  time:"+t);  
  51.         } catch (FileNotFoundException e) {  
  52.             // TODO Auto-generated catch block  
  53.             e.printStackTrace();  
  54.         }  
  55.           
  56.         MappedByteBuffer buffer=null;  
  57.         try {  
  58.             buffer=new RandomAccessFile("/home/tobacco/test/res.txt","rw").getChannel().map(FileChannel.MapMode.READ_WRITE, 01253244);  
  59.             int sum=0;  
  60.             int n;  
  61.             long t1=System.currentTimeMillis();  
  62.             for(int i=0;i<1253244;i++){  
  63.                 //n=0x000000ff&buffer.get(i);  
  64.                 //sum+=n;  
  65.             }  
  66.             long t=System.currentTimeMillis()-t1;  
  67.             System.out.println("sum:"+sum+"  time:"+t);  
  68.         } catch (FileNotFoundException e) {  
  69.             // TODO Auto-generated catch block  
  70.             e.printStackTrace();  
  71.         } catch (IOException e) {  
  72.             // TODO Auto-generated catch block  
  73.             e.printStackTrace();  
  74.         }  
  75.  
  76.     }  
  77.  

测试结果:

  1. sum:0 time:1458  
  2. sum:0 time:67  
  3. sum:0 time:8 

由此可见,将文件部分或者全部映射到内存后进行读写,速度将提高很多。

这是因为内存映射文件首先将外存上的文件映射到内存中的一块连续区域,被当成一个字节数组进行处理,读写操作直接对内存进行操作,而后再将内存区域重新映射到外存文件,这就节省了中间频繁的对外存进行读写的时间,大大降低了读写时间。

posted @ 2012-08-23 14:37 IT神童 阅读(207) | 评论 (0)编辑 收藏

2012年8月22日

浅谈Java中的几种随机数

摘要:众所周知,随机数是任何一种编程语言最基本的特征之一。而生成随机数的基本方式也是相同的:产生一个0到1之间的随机数。看似简单,但有时我们也会忽略了一些有趣的功能。

众所周知,随机数是任何一种编程语言最基本的特征之一。而生成随机数的基本方式也是相同的:产生一个0到1之间的随机数。看似简单,但有时我们也会忽略了一些有趣的功能。

我们从书本上学到什么?

最明显的,也是直观的方式,在Java中生成随机数只要简单的调用:

  1. java.lang.Math.random() 

在所有其他语言中,生成随机数就像是使用Math工具类,如abs, pow, floor, sqrt和其他数学函数。大多数人通过书籍、教程和课程来了解这个类。一个简单的例子:从0.0到1.0之间可以生成一个双精度浮点数。那么通过上面的信息,开发人员要产生0.0和10.0之间的双精度浮点数会这样来写:

  1. Math.random() * 10 

而产生0和10之间的整数,则会写成:

  1. Math.round(Math.random() * 10) 

进阶

通过阅读Math.random()的源码,或者干脆利用IDE的自动完成功能,开发人员可以很容易发现,java.lang.Math.random()使用一个内部的随机生成对象 - 一个很强大的对象可以灵活的随机产生:布尔值、所有数字类型,甚至是高斯分布。例如:

  1. new java.util.Random().nextInt(10) 

它有一个缺点,就是它是一个对象。它的方法必须是通过一个实例来调用,这意味着必须先调用它的构造函数。如果在内存充足的情况下,像上面的表达式是可以接受的;但内存不足时,就会带来问题。java教程下载一个简单的解决方案,可以避免每次需要生成一个随机数时创建一个新实例,那就是使用一个静态类。猜你可能想到了java.lang.Math,很好,我们就是改良java.lang.Math的初始化。虽然这个工程量低,但你也要做一些简单的单元测试来确保其不会出错。

假设程序需要生成一个随机数来存储,问题就又来了。比如有时需要操作或保护种子(seed),一个内部数用来存储状态和计算下一个随机数。在这些特殊情况下,共用随机生成对象是不合适的。

并发

在Java EE多线程应用程序的环境中,随机生成实例对象仍然可以被存储在类或其他实现类,作为一个静态属性。幸运的是,java.util.Random是线程安全的,所以不存在多个线程调用会破坏种子(seed)的风险。

另一个值得考虑的是多线程java.lang.ThreadLocal的实例。偷懒的做法是通过Java本身API实现单一实例,当然你也可以确保每一个线程都有自己的一个实例对象。

虽然Java没有提供一个很好的方法来管理java.util.Random的单一实例。但是,期待已久的Java 7提供了一种新的方式来产生随机数:

  1. java.util.concurrent.ThreadLocalRandom.current().nextInt(10) 

这个新的API综合了其他两种方法的优点:单一实例/静态访问,就像Math.random()一样灵活。ThreadLocalRandom也比其他任何处理高并发的方法要更快。

经验

Chris Marasti-Georg 指出:

  1. Math.round(Math.random() * 10) 

使分布不平衡,例如:0.0 - 0.499999将四舍五入为0,而0.5至1.499999将四舍五入为1。那么如何使用旧式语法来实现正确的均衡分布,如下:

  1. Math.floor(Math.random() * 11) 

幸运的是,如果我们使用java.util.Random或java.util.concurrent.ThreadLocalRandom就不用担心上述问题了。

Java实战项目里面介绍了一些不正确使用java.util.Random API的危害。这个教训告诉我们不要使用:

  1. Math.abs(rnd.nextInt())%n 

而使用:

  1. rnd.nextInt(n) 

posted @ 2012-08-22 10:19 IT神童 阅读(195) | 评论 (0)编辑 收藏

Java 8的重要新特性以及未来版本的发展规划

摘要:我们一直在期待着Java 8的新功能,虽然很大一部分是对Java 7的扩展,发布时间也一推再推。但如今甲骨文终于承诺:新版本将是彻底的变革而不仅仅是Java 7的扩展。那Java 8到底是什么样的呢?

我们一直在期待着Java 8的新功能,虽然很大一部分是对Java 7的扩展,发布时间也一推再推。但如今甲骨文终于承诺:新版本将是彻底的变革而不仅仅是Java 7的扩展。那Java 8到底是什么样的呢?

甲骨文的Java总架构师马克•雷纳德在2011年JavaOne大会上为大家透露了Java 8的新功能,同时也谈到了一些关于Java 9的计划。他说,Java 7未能实现五个关键的功能是非常遗憾的一件事,而且另外两个功能为了配合发布日期也只好作罢。马克认为,Java 7的更新是非常重要的,他还暗示,Java 8将从根本上改变编程语言的功能。看完下面的介绍你也许会明白马克的说法不是天方夜谭。

Java 8包含两个主要项目:

1. Lambda

Lambda项目中,多核处理器下的Java编程将更高效,Lambda表达式可以帮助开发人员提高效率,更好地利用多核处理器。Lambda项目还包括一个新的处理系统,该系统允许要求代码建模的编程模式作为数据。新功能一览:

  • Lambda表达式的运用
  • 扩展目标类型化
  • 方法和构造函数参考
  • 默认方法

2. Jigsaw

Jigsaw项目的目标是创建一个实用的方式来在JDK上设计和实施一个模块系统,然后将该系统应用于JDK本身。其关键是令大块的代码更易于管理,并促进应用和大型运算的代码重用。Jigsaw项目还带来了许多新的表单功能,涉及封装、重构、版本和模块集成。

此外,除了这两个项目,Java 8 还增加改进了一些其他语言功能,如升级核心Java库使并行运算的表达更容易;虚拟扩展方法允许对接口增加方法,为默认实现指定参考;增加新的日期/时间API,同时支持传感器,增加代码的部署选项。

Java 9、10的发展规划

甲骨文对Java 8 的前景很是看好,并已经开始讨论Java 9发展的关键领域。比如加入一个self-tuning JVM,提高本地集成和大规模多核的可扩展性;通过新的元对象协议和资源管理器为云应用添加跨语言支持。java电子书免费下载

甲骨文也表示,Java9和10将加入大数据、多语言的互操作性、云计算和移动,预期分别于2015年和2017年发布。而关于Java开发工具包(JDK)10以及之后的版本也正在讨论中,比如使Java语言面向对象,形成一个统一的类型系统,所有原语都将转换为对象和方法。

随着使用人数的增加,Java正逐渐成为最常用的编程语言,令每个使用者都满意成了它的目标。甲骨文认为Java在将来会成为开发者们首选的编程语言,因为它可以实现的东西正好符合了开发者们的期望。 

posted @ 2012-08-22 10:17 IT神童 阅读(162) | 评论 (0)编辑 收藏

java基础学习--排序算法

选择排序:让第一个跟后面的每个元素比较,如果大于则交换量元素的位置,第二次则让第二个元素跟后面的元素一次比较(因为第一个元素的位置已经定了),一次类推直到最后一个元素.
代码:
public class TestChoose {
public static void main(String[] args) {
int[] arr = {8,3,67,43,21,56,78};
choose(arr);
printArray(arr);
}
public static void choose(int[] arr){
int temp = 0;
for(int i = 0;i < arr.length;i ++){
for(int j = i+1;j < arr.length;j ++){
if(arr[i]>arr[j]){
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}
public static void printArray(int[] arr){
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
System.out.println();
}
}
当if(arr[i]>arr[j])时:为升序排列
if(arr[i]<arr[j])时:为降序排列
冒泡排序:每次相邻的两个元素的相比较,每次相比大的放后面,每次比完以后最大的元素就确定 了,然后在从第一个元素开始,每相邻的两个元素之间的比较成都java培训机构
代码:
public static void bubbleSort(int[] arr){
int temp = 0;
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr.length -i -1; j++) {
if(arr[j]>arr[j+1]){
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
对上面中arr.length-x-1说明 
-x  是为了每次少比一次,每次比完以后最后的那个元素位值就确定了,所以没有必要再比成都java培训机构
-1  是防止数组越界,当我i=0的事,j最后一次就是arr.length,如果不减1,则会出现数组访问越界

把上面的代码中的choose(arr)改成bubbleSort(arr)可以测试冒泡排序的算法

posted @ 2012-08-22 10:15 IT神童 阅读(173) | 评论 (0)编辑 收藏

Java程序员面试中的多线程问题

     摘要:   阅读全文

posted @ 2012-08-22 10:07 IT神童 阅读(182) | 评论 (0)编辑 收藏

仅列出标题  
<2024年11月>
272829303112
3456789
10111213141516
17181920212223
24252627282930
1234567

导航

统计

常用链接

留言簿

随笔档案

搜索

最新评论

阅读排行榜

评论排行榜