正文
高性能JAVA代码之 java代码性能分析
小程序:扫一扫查出行
【扫一扫了解最新限行尾号】
复制小程序
【扫一扫了解最新限行尾号】
复制小程序
java中大量数据如何提高性能?
通过使用一些辅助性工具来找到程式中的瓶颈,然后就能对瓶颈部分的代码进行优化。一般有两种方案:即优化代码或更改设计方法。我们一般会选择后者,因为不去调用以下代码要比调用一些优化的代码更能提高程式的性能。而一个设计良好的程式能够精简代码,从而提高性能。
????下面将提供一些在JAVA程式的设计和编码中,为了能够提高JAVA程式的性能,而经常采用的一些方法和技巧。
????1.对象的生成和大小的调整。
????JAVA程式设计中一个普遍的问题就是没有好好的利用JAVA语言本身提供的函数,从而常常会生成大量的对象(或实例)。由于系统不仅要花时间生成对象,以后可能还需花时间对这些对象进行垃圾回收和处理。因此,生成过多的对象将会给程式的性能带来非常大的影响。
????例1:关于String ,StringBuffer,+和append
????JAVA语言提供了对于String类型变量的操作。但如果使用不当,会给程式的性能带来影响。如下面的语句:
????String name=new String("HuangWeiFeng");
????System.out.println(name+"is my name");
????看似已非常精简了,其实并非如此。为了生成二进制的代码,要进行如下的步骤和操作:
????(1) 生成新的字符串 new String(STR_1);
????(2) 复制该字符串;
????(3) 加载字符串常量"HuangWeiFeng"(STR_2);
????(4) 调用字符串的构架器(Constructor);
????(5) 保存该字符串到数组中(从位置0开始);
????(6) 从java.io.PrintStream类中得到静态的out变量;
????(7) 生成新的字符串缓冲变量new StringBuffer(STR_BUF_1);
????(8) 复制该字符串缓冲变量;
????(9) 调用字符串缓冲的构架器(Constructor);
????(10) 保存该字符串缓冲到数组中(从位置1开始);
????(11) 以STR_1为参数,调用字符串缓冲(StringBuffer)类中的append方法;
????(12) 加载字符串常量"is my name"(STR_3);
????(13) 以STR_3为参数,调用字符串缓冲(StringBuffer)类中的append方法;
????(14) 对于STR_BUF_1执行toString命令;
????(15) 调用out变量中的println方法,输出结果。
????由此能看出,这两行简单的代码,就生成了STR_1,STR_2,STR_3,STR_4和STR_BUF_1五个对象变量。这些生成的类的实例一般都存放在堆中。堆要对所有类的超类,类的实例进行初始化,同时还要调用类极其每个超类的构架器。而这些操作都是非常消耗系统资源的。因此,对对象的生成进行限制,是完全有必要的。
????经修改,上面的代码能用如下的代码来替换。
????StringBuffer name=new StringBuffer("HuangWeiFeng");
????System.out.println(name.append("is my name.").toString());
????系统将进行如下的操作:
????(1) 生成新的字符串缓冲变量new StringBuffer(STR_BUF_1);
????(2) 复制该字符串缓冲变量;
????(3) 加载字符串常量"HuangWeiFeng"(STR_1);
????(4) 调用字符串缓冲的构架器(Constructor);
????(5) 保存该字符串缓冲到数组中(从位置1开始);
????(6) 从java.io.PrintStream类中得到静态的out变量;
????(7) 加载STR_BUF_1;
????(8) 加载字符串常量"is my name"(STR_2);
????(9) 以STR_2为参数,调用字符串缓冲(StringBuffer)实例中的append方法;
????(10) 对于STR_BUF_1执行toString命令(STR_3);
????(11)调用out变量中的println方法,输出结果。
????由此能看出,经过改进后的代码只生成了四个对象变量:STR_1,STR_2,STR_3和STR_BUF_1.你可能觉得少生成一个对象不会对程式的性能有非常大的提高。但下面的代码段2的执行速度将是代码段1的2倍。因为代码段1生成了八个对象,而代码段2只生成了四个对象。
????代码段1:
????String name= new StringBuffer("HuangWeiFeng");
????name+="is my";
????name+="name";
????代码段2:
????StringBuffer name=new StringBuffer("HuangWeiFeng");
????name.append("is my");
????name.append("name.").toString();
????因此,充分的利用JAVA提供的库函数来优化程式,对提高JAVA程式的性能时非常重要的.其注意点主要有如下几方面;
????(1) 尽可能的使用静态变量(Static Class Variables)
????如果类中的变量不会随他的实例而变化,就能定义为静态变量,从而使他所有的实例都共享这个变量。
????例:
????public class foo
????{
??????SomeObject so=new SomeObject();
????}
????就能定义为:
????public class foo
????{
??????static SomeObject so=new SomeObject();
????}
????(2) 不要对已生成的对象作过多的改动。
????对于一些类(如:String类)来讲,宁愿在重新生成一个新的对象实例,而不应该修改已生成的对象实例。
????例:
????String name="Huang";
????name="Wei";
????name="Feng";
????上述代码生成了三个String类型的对象实例。而前两个马上就需要系统进行垃圾回收处理。如果要对字符串进行连接的操作,性能将得更差,因为系统将不得为此生成更多得临时变量,如上例1所示。
????(3) 生成对象时,要分配给他合理的空间和大小JAVA中的非常多类都有他的默认的空间分配大小。对于StringBuffer类来讲,默认的分配空间大小是16个字符。如果在程式中使用StringBuffer的空间大小不是16个字符,那么就必须进行正确的初始化。
????(4) 避免生成不太使用或生命周期短的对象或变量。对于这种情况,因该定义一个对象缓冲池。以为管理一个对象缓冲池的开销要比频繁的生成和回收对象的开销小的多。
????(5) 只在对象作用范围内进行初始化。JAVA允许在代码的所有地方定义和初始化对象。这样,就能只在对象作用的范围内进行初始化。从而节约系统的开销。
????例:
????SomeObject so=new SomeObject();
????If(x==1) then
????{
??????Foo=so.getXX();
????}
????能修改为:
????if(x==1) then
????{
??????SomeObject so=new SomeObject();
??????Foo=so.getXX();
????}
????2.异常(Exceptions)
????JAVA语言中提供了try/catch来发方便用户捕捉异常,进行异常的处理。不过如果使用不当,也会给JAVA程式的性能带来影响。因此,要注意以下两点:
????(1) 避免对应用程式的逻辑使用try/catch
????如果能用if,while等逻辑语句来处理,那么就尽可能的不用try/catch语句。
????(2) 重用异常
????在必须要进行异常的处理时,要尽可能的重用已存在的异常对象。以为在异常的处理中,生成一个异常对象要消耗掉大部分的时间。
????3. 线程(Threading)
????一个高性能的应用程式中一般都会用到线程。因为线程能充分利用系统的资源。在其他线程因为等待硬盘或网络读写而 时,程式能继续处理和运行。不过对线程运用不当,也会影响程式的性能。
????例2:正确使用Vector类
????Vector主要用来保存各种类型的对象(包括相同类型和不同类型的对象)。不过在一些情况下使用会给程式带来性能上的影响。这主要是由Vector类的两个特点所决定的。第一,Vector提供了线程的安全保护功能。即使Vector类中的许多方法同步。不过如果你已确认你的应用程式是单线程,这些方法的同步就完全不必要了。第二,在Vector查找存储的各种对象时,常常要花非常多的时间进行类型的匹配。而当这些对象都是同一类型时,这些匹配就完全不必要了。因此,有必要设计一个单线程的,保存特定类型对象的类或集合来替代Vector类.用来替换的程式如下(StringVector.java):
????public class StringVector
????{
??????private String [] data;
??????private int count;
??????public StringVector()
??????{
????????this(10); // default size is 10
??????}
??????public StringVector(int initialSize)
??????{
????????data = new String[initialSize];
??????}
??????public void add(String str)
??????{
??????// ignore null strings
??????if(str == null) { return; }
??????ensureCapacity(count + 1);
??????data[count++] = str;
??????}
??????private void ensureCapacity(int minCapacity)
??????{
????????int oldCapacity = data.length;
????????if (minCapacity oldCapacity)
????????{
??????????String oldData[] = data;
??????????int newCapacity = oldCapacity * 2;
??????????data = new String[newCapacity];
??????????System.arraycopy(oldData, 0, data, 0, count);
????????}
??????}
??????public void remove(String str)
??????{
??????if(str == null) { return; // ignore null str }
??????for(int i = 0; i count; i++)
??????{
????????// check for a match
????????if(data[i].equals(str))
????????{
??????????System.arraycopy(data,i+1,data,i,count-1); // copy data
??????????// allow previously valid array element be gc�0�7d
??????????data[--count] = null;
??????????return;
????????}
??????}
??????}
??????public final String getStringAt(int index)
??????{
??????if(index 0) { return null; }
??????else if(index count) { return null; // index is # strings }
??????else { return data[index]; // index is good }
??????}
????}
????因此,代码:
????Vector Strings=new Vector();
????Strings.add("One");
????Strings.add("Two");
????String Second=(String)Strings.elementAt(1);
????能用如下的代码替换:
????StringVector Strings=new StringVector();
????Strings.add("One");
????Strings.add("Two");
????String Second=Strings.getStringAt(1);
????这样就能通过优化线程来提高JAVA程式的性能。用于测试的程式如下(TestCollection.java):
????import java.util.Vector;
????public class TestCollection
????{
??????public static void main(String args [])
??????{
????????TestCollection collect = new TestCollection();
????????if(args.length == 0)
????????{
??????????System.out.println("Usage: java TestCollection [ vector | stringvector ]");
??????????System.exit(1);
????????}
????????if(args[0].equals("vector"))
????????{
??????????Vector store = new Vector();
??????????long start = System.currentTimeMillis();
??????????for(int i = 0; i 1000000; i++)
??????????{
????????????store.addElement("string");
??????????}
??????????long finish = System.currentTimeMillis();
??????????System.out.println((finish-start));
??????????start = System.currentTimeMillis();
??????????for(int i = 0; i 1000000; i++)
??????????{
????????????String result = (String)store.elementAt(i);
??????????}
??????????finish = System.currentTimeMillis();
??????????System.out.println((finish-start));
????????}
????????else if(args[0].equals("stringvector"))
????????{
??????????StringVector store = new StringVector();
??????????long start = System.currentTimeMillis();
??????????for(int i = 0; i 1000000; i++) { store.add("string"); }
??????????long finish = System.currentTimeMillis();
??????????System.out.println((finish-start));
??????????start = System.currentTimeMillis();
??????????for(int i = 0; i 1000000; i++) {
????????????String result = store.getStringAt(i);
??????????}
??????????finish = System.currentTimeMillis();
??????????System.out.println((finish-start));
????????}
??????}
????}
????关于线程的操作,要注意如下几个方面:
????(1) 防止过多的同步
????如上所示,不必要的同步常常会造成程式性能的下降。因此,如果程式是单线程,则一定不要使用同步。
????(2) 同步方法而不要同步整个代码段
????对某个方法或函数进行同步比对整个代码段进行同步的性能要好。
????(3) 对每个对象使用多”锁”的机制来增大并发。
????一般每个对象都只有一个”锁”,这就表明如果两个线程执行一个对象的两个不同的同步方法时,会发生”死锁”。即使这两个方法并不共享所有资源。为了避免这个问题,能对一个对象实行”多锁”的机制。如下所示:
????class foo
????{
??????private static int var1;
??????private static Object lock1=new Object();
??????private static int var2;
??????private static Object lock2=new Object();
??????public static void increment1()
??????{
????????synchronized(lock1)
????????{
??????????var1++;
????????}
??????}
??????public static void increment2()
??????{
????????synchronized(lock2)
????????{
??????????var2++;
????????}
??????}
????}
????4.输入和输出(I/O)
????输入和输出包括非常多方面,但涉及最多的是对硬盘,网络或数据库的读写操作。对于读写操作,又分为有缓存和没有缓存的;对于数据库的操作,又能有多种类型的JDBC驱动器能选择。但无论怎样,都会给程式的性能带来影响。因此,需要注意如下几点:
????(1) 使用输入输出缓冲
????尽可能的多使用缓存。但如果要经常对缓存进行刷新(flush),则建议不要使用缓存。
????(2) 输出流(Output Stream)和Unicode字符串
当时用Output Stream和Unicode字符串时,Write类的开销比较大。因为他要实现Unicode到字节(byte)的转换.因此,如果可能的话,在使用Write类之前就实现转换或用OutputStream类代替Writer类来使用。
????(3) 当需序列化时使用transient
当序列化一个类或对象时,对于那些原子类型(atomic)或能重建的原素要表识为transient类型。这样就不用每一次都进行序列化。如果这些序列化的对象要在网络上传输,这一小小的改动对性能会有非常大的提高。
????(4) 使用高速缓存(Cache)
对于那些经常要使用而又不大变化的对象或数据,能把他存储在高速缓存中。这样就能提高访问的速度。这一点对于从数据库中返回的结果集尤其重要。
????(5) 使用速度快的JDBC驱动器(Driver)
JAVA对访问数据库提供了四种方法。这其中有两种是JDBC驱动器。一种是用JAVA外包的本地驱动器;另一种是完全的JAVA驱动器。具体要使用哪一种得根据JAVA布署的环境和应用程式本身来定。
????5.一些其他的经验和技巧
????(1) 使用局部变量。
????(2) 避免在同一个类中动过调用函数或方法(get或set)来设置或调用变量。
????(3) 避免在循环中生成同一个变量或调用同一个函数(参数变量也相同)。
????(4) 尽可能的使用static,final,private等关键字。
Java编程的特点是什么呢
Java编程的特点是什么呢?
Java由美国SUN公司(被oracle公司收购)发明于1995年,是目前业界应用最广泛、使用人数最多的语言,连续多年排名世界第一,可以称之为“计算机语言界的英语”。
那么Java这么高的评价它的特点有哪些,下面我来为题主解答:
一、跨平台/可移植性
这是Java的核心优势。Java在设计时就很注重移植和跨平台性。比如:Java的int永远都是32位。不像C++可能是16,32,可能是根据编译器厂商规定的变化。这样的话程序的移植就会非常麻烦。
Java首先利用文本编辑器编写 Java源程序,源文件的后缀名为.java;再利用编译器(javac)将源程序编译成字节码文件,字节码文件的后缀名为.class; 最后利用虚拟机(解释器,java)解释执行。如下图所示:
二、安全性
Java适合于网络/分布式环境,为了达到这个目标,在安全性方面投入了很大的精力,使Java可以很容易构建防病毒,防篡改的系统。比如Java取消了强大但又危险的指针。由于指针可进行移动运算,指针可随便指向一个内存区域,而不管这个区域是否可用,这样做是危险的。
三、面向对象
面向对象是一种程序设计技术,非常适合大型软件的设计和开发。由于C++为了照顾大量C语言使用者而兼容了C,使得自身仅仅成为了带类的C语言,多少影响了其面向对象的彻底性!Java则是完全的面向对象语言。
四、简单性
Java就是C++语法的简化版,我们也可以将Java称之为“C++-”。跟我念“C加加减”,指的就是将C++的一些内容去掉;比如:头文件,指针运算,结构,联合,操作符重载,虚基类等等。同时,由于语法基于C语言,因此学习起来完全不费力。
五、高性能
Java最初发展阶段,总是被人诟病“性能低”;客观上,高级语言运行效率总是低于低级语言的,这个无法避免。Java语言本身发展中通过虚拟机的优化提升了几十倍运行效率。比如,通过JIT(JUST IN TIME)即时编译技术提高运行效率。 将一些“热点”字节码编译成本地机器码,并将结果缓存起来,在需要的时候重新调用。这样的话,使Java程序的执行效率大大提高,某些代码甚至接近C++的效率。
因此,Java低性能的短腿,已经被完全解决了。业界发展上,我们也看到很多C++应用转到Java开发,很多C++程序员转型为Java程序员。
六、分布式
Java是为Internet的分布式环境设计的,因为它能够处理TCP/IP协议。事实上,通过URL访问一个网络资源和访问本地文件是一样简单的。Java还支持远程方法调用(RMI,Remote Method Invocation),使程序能够通过网络调用方法。
七、多线程
多线程的使用可以带来更好的交互响应和实时行为。 Java多线程的简单性是Java成为主流服务器端开发语言的主要原因之一。
八、健壮性
Java是一种健壮的语言,吸收了C/C++ 语言的优点,但去掉了其影响程序健壮性的部分(如:指针、内存的申请与释放等)。Java程序不可能造成计算机崩溃。即使Java程序也可能有错误。如果出现某种出乎意料之事,程序也不会崩溃,而是把该异常抛出,再通过异常处理机制加以处理。
以上几种特性你了解到啦吗? 记得给个赞!
java的特点有哪些?
Java语言是一种分布式的面向对象语言,具有面向对象、平台无关性、简单性、解释执行、多线程、安全性等很多特点,下面针对这些特点进行逐一介绍。
1. 面向对象
Java是一种面向对象的语言,它对对象中的类、对象、继承、封装、多态、接口、包等均有很好的支持。为了简单起见,Java只支持类之间的单继承,但是可以使用接口来实现多继承。使用Java语言开发程序,需要采用面向对象的思想设计程序和编写代码。
2. 平台无关性
平台无关性的具体表现在于,Java是“一次编写,到处运行(Write Once,Run any Where)”的语言,因此采用Java语言编写的程序具有很好的可移植性,而保证这一点的正是Java的虚拟机机制。在引入虚拟机之后,Java语言在不同的平台上运行不需要重新编译。
Java语言使用Java虚拟机机制屏蔽了具体平台的相关信息,使得Java语言编译的程序只需生成虚拟机上的目标代码,就可以在多种平台上不加修改地运行。
3. 简单性
Java语言的语法与C语言和 C++ 语言很相近,使得很多程序员学起来很容易。对Java来说,它舍弃了很多 C++ 中难以理解的特性,如操作符的重载和多继承等,而且Java语言不使用指针,加入了垃圾回收机制,解决了程序员需要管理内存的问题,使编程变得更加简单。
4. 解释执行
Java程序在Java平台运行时会被编译成字节码文件,然后可以在有Java环境的操作系统上运行。在运行文件时,Java的解释器对这些字节码进行解释执行,执行过程中需要加入的类在连接阶段被载入到运行环境中。
5. 多线程
Java语言是多线程的,这也是Java语言的一大特性,它必须由 Thread 类和它的子类来创建。Java支持多个线程同时执行,并提供多线程之间的同步机制。任何一个线程都有自己的 run() 方法,要执行的方法就写在 run() 方法体内。
6. 分布式
Java语言支持 Internet 应用的开发,在Java的基本应用编程接口中就有一个网络应用编程接口,它提供了网络应用编程的类库,包括 URL、URLConnection、Socket 等。Java的 RIM 机制也是开发分布式应用的重要手段。
7. 健壮性
Java的强类型机制、异常处理、垃圾回收机制等都是Java健壮性的重要保证。对指针的丢弃是Java的一大进步。另外,Java的异常机制也是健壮性的一大体现。
8. 高性能
Java的高性能主要是相对其他高级脚本语言来说的,随着 JIT(Just in Time)的发展,Java的运行速度也越来越高。
9. 安全性
Java通常被用在网络环境中,为此,Java提供了一个安全机制以防止恶意代码的攻击。除了Java语言具有许多的安全特性以外,Java还对通过网络下载的类增加一个安全防范机制,分配不同的名字空间以防替代本地的同名类,并包含安全管理机制。
Java语言的众多特性使其在众多的编程语言中占有较大的市场份额,Java语言对对象的支持和强大的 API 使得编程工作变得更加容易和快捷,大大降低了程序的开发成本。Java的“一次编写,到处执行”正是它吸引众多商家和编程人员的一大优势。
如何利用Java开发高性能高并发Web应用.ppt
1、提供HTML静态访问
web界面上最快的访问速度是什么高性能JAVA代码之?当然是最原始的HTML文件访问,对于其他语言 比如 jsp ,asp,php等等,他们首先要通过服务器解析成html之后在返回给访问者高性能JAVA代码之,如果高性能JAVA代码之我们能提供全部是htm来的页面,那么就能大大的降低服务器和数据库资源的利用和提高网站的并发,所以我们尽可能使我们的网站上的页面采用静态页面来实现,这个最简单的方法其实也是最有效的方法。当然实现这种方式大家比较高性能JAVA代码之了解的就是信息发布系统CMS,信息发布系统可以实现最简单的信息录入自动生成静态页面,还能具备频道管理、权限管理、自动抓取等功能,对于一个大型网站来说,拥有一套高效、可管理的CMS是必不可少的。
在后续的文章中我们会单独的使用jsp + servlet实现一个简单的信息发布系统.
2、使用独立的图片服务器
为什么要把图片单独设置一个服务器?对于Web服务器来说,图片消耗的服务器资源是最多的,如果能把所有的图片资源放到一个单独的图片服务器中进行处理的话,可以降低提供页面访问请求的服务器系统压力,从而能进一步的提高web程序的并发.所以在有条件的情况下最好能把图片放置到一个单独的服务器中.
3、配置多台数据库服务器,多个数据库集群
集群(Cluster)技术是使用特定的连接方式,将价格相对较低的硬件设备结合起来,同时也能提供高性能相当的任务处理能力。
越是大型高并发的应用,数据库的压力就会越大,如果数据库操作很频繁,数据库的瓶颈很快就能显现出来,这时一台数据库将很快无法满足应用,于是我们需要使用数据库集群。
数据库集群就是使用多个数据库服务器分担请求的压力,达到快速响应的目的.
4、使用缓存
所谓的缓存就是把数据咱是放置到内存中,前台在请求的时候直接从内存中读取数据,而不需要去查询数据库或者读取文件等,这样就能做到最快的响应。网站架构和网站开发中的缓存是非常重要的。
目前有很多开源的缓冲实现方案,APC,File,SQLite,Memcache等等各种类库实现着不同的缓存方式,只有通过了解他们的实现方式,根据具体应用具体选择,才会使缓存系统发挥出最大的性能。
对于java开发来说,大名顶顶的 分布式缓存系统Memcache 可能是最好的选择,他提供一个基于Socket的访问方式,使得该缓存系统支持远程读写访问。尽管这个缓存的内容可能是存在内存中,也可能是存在文件内。
试编写一个java应用程序,要求输入一个圆的半径,输出其面积
代码为:
Scanner scanner=new Scanner(System.in);
System.out.println("请输入圆的半径:");
int r=Integer.parseInt(scanner.next()); //获取半径
System.out.println("圆的面积为:"+Math.PI*r*r);
扩展资料:
java所具有的特性:
1.简单性
Java看起来设计得很像C++,但是为了使语言小和容易熟悉,设计者们把C++语言中许多可用的特征去掉了,这些特征是一般程序员很少使用的。例如,Java不支持goto语句,代之以提供break和continue语句以及异常处理。Java还剔除了C++的操作符过载(overload)和多继承特征,并且不使用主文件,免去了预处理程序。
因为Java没有结构,数组和串都是对象,所以不需要指针。Java能够自动处理对象的引用和间接引用,实现自动的无用单元收集,使用户不必为存储管理问题烦恼,能更多的时间和精力花在研发上。
2.面向对象
Java是一个面向对象的语言。对程序员来说,这意味着要注意应中的数据和操纵数据的方法(method),而不是严格地用过程来思考。在一个面向对象的系统中,类(class)是数据和操作数据的方法的集合。
数据和方法一起描述对象(object)的状态和行为。每一对象是其状态和行为的封装。类是按一定体系和层次安排的,使得子类可以从超类继承行为。在这个类层次体系中有一个根类,它是具有一般行为的类。Java程序是用类来组织的。
Java还包括一个类的扩展集合,分别组成各种程序包(Package),用户可以在自己的程序中使用。例如,Java提供产生图形用户接口部件的类(java.awt包),这里awt是抽象窗口工具集(abstractwindowingtoolkit)的缩写,处理输入输出的类(java.io包)和支持网络功能的类(java.net包)。
3.分布性
Java设计成支持在网络上应用,它是分布式语言。Java既支持各种层次的网络连接,又以Socket类支持可靠的流(stream)网络连接,所以用户可以产生分布式的客户机和服务器。
网络变成软件应用的分布运载工具。Java程序只要编写一次,就可到处运行。
4.编译和解释性
Java编译程序生成字节码(byte-code),而不是通常的机器码。Java字节码提供对体系结构中性的目标文件格式,代码设计成可有效地传送程序到多个平台。Java程序可以在任何实现了Java解释程序和运行系统(run-timesystem)的系统上运行。
在一个解释性的环境中,程序开发的标准“链接”阶段大大消失了。如果说Java还有一个链接阶段,它只是把新类装进环境的过程,它是增量式的、轻量级的过程。因此,Java支持快速原型和容易试验,它将导致快速程序开发。这是一个与传统的、耗时的“编译、链接和测试”形成鲜明对比的精巧的开发过程。
5.稳健性
Java原来是用作编写消费类家用电子产品软件的语言,所以它是被设计成写高可靠和稳健软件的。Java消除了某些编程错误,使得用它写可靠软件相当容易。
Java是一个强类型语言,它允许扩展编译时检查潜在类型不匹配问题的功能。Java要求显式的方法声明,它不支持C风格的隐式声明。这些严格的要求保证编译程序能捕捉调用错误,这就导致更可靠的程序。
可靠性方面最重要的增强之一是Java的存储模型。Java不支持指针,它消除重写存储和讹误数据的可能性。类似地,Java自动的“无用单元收集”预防存储漏泄和其它有关动态存储分配和解除分配的有害错误。Java解释程序也执行许多运行时的检查,诸如验证所有数组和串访问是否在界限之内。
异常处理是Java中使得程序更稳健的另一个特征。异常是某种类似于错误的异常条件出现的信号。使用try/catch/finally语句,程序员可以找到出错的处理代码,这就简化了出错处理和恢复的任务。
6.安全性
Java的存储分配模型是它防御恶意代码的主要方法之一。Java没有指针,所以程序员不能得到隐蔽起来的内幕和伪造指针去指向存储器
。更重要的是,Java编译程序不处理存储安排决策,所以程序员不能通过查看声明去猜测类的实际存储安排。编译的Java代码中的存储引用在运行时由Java解释程序决定实际存储地址。
Java运行系统使用字节码验证过程来保证装载到网络上的代码不违背任何Java语言限制。这个安全机制部分包括类如何从网上装载。例如,装载的类是放在分开的名字空间而不是局部类,预防恶意的小应用程序用它自己的版本来代替标准Java类。
7.可移植性
Java使得语言声明不依赖于实现的方面。例如,Java显式说明每个基本数据类型的大小和它的运算行为(这些数据类型由Java语法描述)。
Java环境本身对新的硬件平台和操作系统是可移植的。Java编译程序也用Java编写,而Java运行系统用ANSIC语言编写。
8.高性能
Java是一种先编译后解释的语言,所以它不如全编译性语言快。但是有些情况下性能是很要紧的,为了支持这些情况,Java设计者制作了“及时”编译程序,它能在运行时把Java字节码翻译成特定CPU(中央处理器)的机器代码,也就是实现全编译了。
Java字节码格式设计时考虑到这些“及时”编译程序的需要,所以生成机器代码的过程相当简单,它能产生相当好的代码。
9.多线索性
Java是多线索语言,它提供支持多线索的执行(也称为轻便过程),能处理不同任务,使具有线索的程序设计很容易。Java的lang包提供一个Thread类,它支持开始线索、运行线索、停止线索和检查线索状态的方法。
Java的线索支持也包括一组同步原语。这些原语是基于监督程序和条件变量风范,由C.A.R.Haore开发的广泛使用的同步化方案。用关键词synchronized,程序员可以说明某些方法在一个类中不能并发地运行。这些方法在监督程序控制之下,确保变量维持在一个一致的状态。
10.动态性
Java语言设计成适应于变化的环境,它是一个动态的语言。例如,Java中的类是根据需要载入的,甚至有些是通过网络获取的。
参考资料:百度百科-Java
怎样利用Java开发高性能
1、调整垃圾收集(GC)
由于垃圾收集的复杂性,很难发现你的应用的准确性能。不过,如果你真的想优化你的应用,你应该相应地处理垃圾收集。通用的准则是调整GC设置并同时执行性能分析。
一旦你对结果感到满意,你可以停止该过程并寻求其他优化方式。确保除了在平均事务处理时间之外,你还留心了异常值。这些异常值是造成Java应用缓慢的真正的罪魁祸首并且很难找到。
此外,你要明白应用运行期间性能下降的效应。在每单个cpu时钟内的缓慢操作是可以忽略的,但在每单个数据库事务中的缓慢操作则是非常昂贵的消耗。但是你应该根据性能短板选择你的优化策略,并应该根据工作负载来优化应用。
2、正确地选择适合你的GC算法
让我们更深入地探讨GC优化。毕竟,GC优化是要处理的整个优化问题中最基本的。目前,Java中有四种供你选择的垃圾收集算法。每种算法满足不同的需求,因此你要选择(适合你的需求的)。很多开发人员正是因为不了解GC算法而未能优化他们的应用。
这四个算法分别是串行回收器,并行/吞吐量回收器,CMS回收器和G1回收器。想要了解更多关于每种垃圾收集器的信息及它们是如何工作的,请查看这篇来自Takipi博客的非常棒的文章Garbage Collectors—Serial vs。 Parallel vs。 CMS vs。 G1。这篇文章同时还讨论了Java8对GC算法的影响及其他细节上的改变。让我们再回到GC算法上,根据Understanding Java Garbage Collection这篇文章所述,并发标记和清除GC(即”CMS”)算法才是适合网络服务端应用的最佳算法。并行GC算法适合那些内部可预测的应用。
G1和CMS是并发操作的理想选择,但仍然会引起(应用)频繁停顿。实际的选择取决于你如何取舍。举例来说,尽管选择并行算法会带来更长的GC停顿时间,但相较于其他GC算法,选择并行算法仍是一个好主意。
3、Java堆
Java内存堆在迎合内存需求方面担任了至关重要角色。通常更好的做法是初始时分配最小的堆,然后通过持续的测试不断增加它的大小。大多数时候优化问题都可以通过增加堆的大小解决,但如果存在大量的GC开销,则该解决方案不起作用。
GC开销还会使吞吐量急剧下降,进而使得应用难以形容的慢。此外,及早调整GC可以帮助你避免堆大小分配的问题。开始的时候,你可以选择任何1GB到8GB的堆大小。当你选择正确的堆大小,老生代和新生代对象的概念也就不需要了。总而言之,堆大小应该取决于老生代和新生代对象的比率,之前的GC优化和对象集合(即所有对象占用的内存大小)。
4、关键应用优化
关键代码优化是优化你的Java应用最好的方式。如果你的应用对GC和堆优化没有反应,那么最好是做架构改进并关注于你的应用是如何处理信息的。使用聪明的算法并管理好对象就能解决大量的问题,包括内存碎片,堆大小问题和垃圾收集的问题。
5、使用最优的函数
Java提供了多个函数来提升算法效率。如果你使用StringBuilder代替简单的String,你可以得到微乎其微的性能提升。不过,我们还有其他方式在代码层面进行优化。让我们看看下面这些优化方法。
使用StringBuilder代替+操作符。
避免使用iterator。
多使用栈带来的好处。
避免使用正则表达式,使用Apache Commons Lang作为代替。
远离递归。递归会占用大量资源!
高性能JAVA代码之的介绍就聊到这里吧,感谢你花时间阅读本站内容,更多关于java代码性能分析、高性能JAVA代码之的信息别忘了在本站进行查找喔。