2015 International Conference on Energy Systems and Applications (ICESA 2015)

Dr. D. Y. Patil Institute of Engineering and Technology, Pune, India 30 Oct - 01 Nov, 2015

Minimizing Impact on Java Virtual Machine via JAVA Code Optimization

Vamsi Krishna Myalapalli, Sunitha Geloth Open Text Corporation,

Mind Space IT Park, Hi-Tec City,

Hyderabad, India

{vamsikrishna.vasu, sunithasaini}@gmail.com

Abstract— In the contemporary programming microcosm most of the commercial applications are contingent upon JAVA programming language as front end language and is escalating exponentially. Performance engineering the code plays a crucial part. Many JAVA programmers code programs with less contemplation towards optimized processing. Code tuning often engenders massive performance enhancement. As such, the proposed model is intended to bolster the JAVA programmers to enhance and tune the JAVA code dependent application(s). This paper exposes sundry miscellaneous rewriting techniques for escalating JAVA application program performance towards minimizing impact on JVM and could oblige as an optimization tool for JAVA application programmer(s). Our investigatory denouements advocate that performance enhancements i.e. Space and Time complexities were enriched.

Keywords— JAVA Optimization; JAVA Tuning; JAVA Code Rewrite; JAVA Performance Tuning; JAVA Code Tuning.

1. INTRODUCTION

Making programs run faster in a production environment is a challenge for many developers. We can considerably enhance the performance of the Server amp; applications deployed on it by mutating some server configuration and deployment settings.

Application developers should tune applications prior to usage in production. Application Tuning results in massive performance improvements. Once the application tuning is complete System administrators carry out rest of the steps in below list.

Sequence of Steps for performance tuning:

1. Application Tuning (The Proposed model).
2. Server Tuning.
3. Java Run time System Tuning.
4. Operating system Tuning.

Further paper is prepared as follows. Second section explains the associated background and related work. Third section deals with proposed benchmark i.e. the techniques. Fourth section demonstrates experimental setup i.e. implementing tactic. Section 5 explains comparative analysis and finally section 6 concludes the paper.

1. BACKGROUND AND RELATED WORK

High Performance JAVA Programming [1] explained sundry techniques to reduce time and space complexity in commercial JAVA application code made of servlets, beans, JDBC and other plain JAVA code. This paper encompasses

techniques for reducing time and space complexity in plain JAVA code and other best practices to minimize load levied on the JVM.

High Performance C Programming [2] explained tuning code via arithmetic logic, variable scope impact on the compiler and other associated issues.

When tuning an application, the bottlenecks have to be recognized. For example, if our code is processor bound the algorithms should be tuned and short-lived objects must be handled appropriately. Tuning bottlenecks is an incessant process. Hence, critical ones must be handled accurately.

This paper explains the rewriting methodologies to reduce object utilization in plain JAVA code and in turn, this tuned plain JAVA code can be employed with other miscellaneous code.

1. PROPOSED BENCHMARK

There exists sundry approaches for JAVA tuning and this paper explains holistic techniques for JAVA tuning where we optimize the JAVA application performance. We performed snooping upon resource utilization using JProfiler profiling tool and byte code using de-compiler software.

Code Handling #(1-8):

1. Concatenate Strings using String Builder: lsquo;Stringrsquo; is immutable whereas lsquo;StringBuilderrsquo; is mutable. Performance enhances if lsquo;StringBuilder.append()rsquo; is used instead of string concatenation. The latter case causes expensive copying amp; upshots significant performance degradation.
2. Variables should be assigned null which are no Longer Required: This tactic assists the garbage collector to recognize the fragments of memory which can be securely reclaimed. It should be noticed that it JAVA will not thwart memory leaks and excess memory consumption.
3. Detecting Memory Leaks: Profiling tools help programmers to detect memory leaks. Enforcing memory snapshots after each transaction will also keep track of memory leaks. Leak free applications ensure active heap memory after subsequent garbage collection(s).
4. Moving to Final Methods on extreme necessity: The lsquo;finalrsquo; keyword thwarts over riding. Some Dynamic compilers ensure lsquo;inter procedural optimizationrsquo; and lsquo;inliningrsquo; if methods are not final.
5. Static Final Constants: Many of the Dynamic Compilers ensure constant folding optimization when constants appear as static final.
6. Strings as literals: Strings should be created as literals instead of creating Strings using the new keyword.
7. Prevent Finalizers: The Finalizer(s) are un-predictable and might cause portability problems and severe performance hitches . We should not put real time code in Finalizers under any cost. Do not rest on on a finalizer in updating critical persistent state.
8. Over riding the method toString(): This practice helps a lot when the programmer is dealing with collections. As a best practice toString should return vital information of the object.

Classes and Interfaces # (9-17):

1. Members and Classes Accessibility must be Curtailed: This should be enforce

   剩余内容已隐藏，支付完成后下载完整资料

   ---

   通过Java代码优化减少对虚拟机的影响

   Vamsi Krishna Myalapalli, Sunitha Geloth

   Open Text Corporation, Mind Space IT Park, Hi-Tec City, Hyderabad, India

   摘要：在当代编程微观世界中，大多数商业应用程序都依赖于JAVA编程语言作为前端语言并且呈指数级升级。 性能工程代码起着至关重要的作用。 许多JAVA程序员编写的程序对优化处理的思考较少。 代码调整通常会带来巨大的性能提升。 因此，所提出的模型旨在支持JAVA程序员增强和调整JAVA代码相关的应用程序。 本文介绍了各种各样的杂项重写技术，以提高JAVA应用程序的性能，最大限度地减少对JVM的影响，并有可能成为JAVA应用程序员的优化工具。 我们的调查结果主张增强性能，即空间和时间的复杂性。

   关键词：JAVA优化; JAVA调整; JAVA代码重写; JAVA性能调优; JAVA代码调整。

   1 引言

   在生产环境中使程序运行得更快对许多开发人员来说是一个挑战。 通过改变某些服务器配置和部署设置，我们可以显著提高部署在其服务器上的应用程序的性能。

   应用程序开发人员应在量产之前调整应用程序。应用程序调整可带来巨大的性能提升。应用程序调整完成后，系统管理员将执行以下列其余步骤。

   性能调整的步骤顺序：

   1.应用程序调整（建议的模型）。

   2.服务器调整。

   3. Java运行时系统调整。

   4.操作系统调整。

   进一步的论文分析如下。 第二部分解释了相关背景和相关工作。 第三部分涉及提出的基准，即技术。第四部分说明实验设置，即实施策略。 第5节解释了比较分析，最后第6节总结了论文。

   2 背景和相关工作

   高性能JAVA编程^[1]解释了各种技术，以减少由servlet，bean，JDBC和其他普通JAVA代码构成的商业JAVA应用程序代码中的时间和空间复杂性。本文包含了简化JAVA代码中减少时间和空间复杂性的技术以及其他最佳实践，以最大限度地减少JVM上的负载。高性能C编程^[2]解释了通过算术逻辑调整代码，可变范围对编译器的影响以及其他相关问题。调整应用程序时，必须识别瓶颈。例如，如果我们的代码是处理器绑定的，则应该调整算法并且适当地处理短期对象。调整瓶颈是一个不间断的过程，因此必须准确处理关键问题。本文解释了在简单JAVA代码中减少对象利用率的重写方法，这个调优使得JAVA代码可以与其他杂项代码一起使用。

   3 设定的基准

   JAVA调整存在各种方法，本文解释了JAVA调优的整体技术，我们优化了JAVA应用程序的性能。我们使用JProfiler分析工具和使用解编译软件的字节代码对资源利用率进行了监听。

   代码处理＃（1-8）：

   1）使用String Builder连接字符串：String是不可变的，而StringBuilder是可变的。如果使用StringBuilder.append（）而不是字符串连接，性能会增强。后一种情况导致昂贵的复制和结果显着的性能下降。

   2）变量应该被指定为null，这些变量不再需要：这种策略有助于垃圾收集器识别可以安全回收的内存片段。应该注意的是，JAVA不会阻止内存泄漏和过多的内存消耗。

   3）检测内存泄漏：分析工具可帮助程序员检测内存泄漏。每次事务后执行内存快照也会跟踪内存泄漏。无泄漏应用程序确保后续垃圾回收后的活动堆内存。

   4）在极端必要性上采用最终方法：final关键字阻碍了骑行。如果方法不是最终的，一些动态编译器确保“程序间优化”和“内联”.2015能源系统和应用国际会议（ICESA 2015）DY Patil博士工程技术研究所，印度浦那30 Oct-01 Nov， 2015978-1-4673-6817-9 / 15 / $ 31.00copy;2015 IEEE 19

   5）静态最终常量：当常量显示为静态最终时，许多动态编译器确保恒定的折叠优化。

   6）字符串作为文字：字符串应该创建为文字而不是使用new关键字创建字符串。

   7）防止终结器：终结器是不可预测的，可能导致可移植性问题和严重的性能故障。我们不应该在任何成本下将实时代码放在Finalizer中。在更新关键持久状态时不要依赖终结器。

   8）超越方法toString（）：当程序员处理集合时，这种做法有很大帮助。作为最佳实践，toString应该返回对象的重要信息。

   类和接口＃（9-17）：

   1. 成员和类必须缩减可访问性：应尽可能强制执行。数据成员必须保持隐藏，即私有，必须通过公共方法访问这些成员。这确保了封装或信息隐藏。持有公共可变字段的类将使线程变得不安全。

   10）通过Lambda实现功能接口：它们让我们定义接口的默认行为，并在不执行它们的情况下引用该方法。他们消除了冗长。

   11）可变性必须保持最小：不可变对象是线程安全的，可以与其成员一起自由共享可模糊性确保易于使用，测试和失败原子。此外，他们不需要防御复制或克隆。例如：整数，字符串等

   12）继承与组合：（Is-A）继承使代码易碎并违反封装。而是对当前类进行修改，为新类提供一个私有字段，该字段引用当前类的实例（组合（Has-A））。

   13）通过接口确定抽象类：继承抽象类可能会导致对类型层次结构的附带损害。接口允许创建非分层类型框架，并且是开发mixin的田园诗。

   14）首选模拟多重传播：实现接口的类可以将接口函数的调用转发到包含私有内部类的实例，从而扩展了框架实现。 SMI允许继承多个类（最简单的方法来演变抽象类而不是接口）。启动和实现接口后，修改应用程序代码实际上很困难，因此更喜欢SMI。

   15）仅使用接口来定义类型：接口不得用于传播常量。这是对Interface的利用率很低。

   16）选择Tagged Classes类的层次结构：标记类是longwinded，无效和容易出错。标记类可能会增加内存占用，因为它们会使带有开关、标记字段和枚举等的代码变得混乱。要将标记类转换为类层次结构，请为标记类中的单个方法定义抽象方法的抽象类，其功能取决于关于标签值。

   17）非静态的静态成员类：非静态成员类实例与其包含实例之间的关系是在创建前者之后生成的;事后不能改变。由于此关联在非静态成员类实例中使用内存并且需要时间来创建非静态成员类，因此应该阻止非静态成员类。

   泛型＃（18-23）：

   18）在代码中确定原始类型：如果我们改变代码中的原始类型，则类型安全性将丢失。另一方面，错误率会增加。

   19）删除未经检查的警告：删除未经检查的警告（ClassCastException）使代码类型安全。

   20）支持列表上的列表（通用）：泛型保持不变，并且数组保持协变。

   21）首选通用方法：使用类似于类的通用方法保护类型安全。静态效用方法是最佳的竞争者。

   22）如果要升级API灵活性，请强制使用有界通配符：这样可以为不变类型提供额外的灵活性。

   23）考虑Typesafe异构容器：这为容器的参数提供了类型安全性。

   枚号＃（24-27）：

   24）首选枚举而不是常量：切换枚举最好通过恒定的精确行为来增加外部枚举类型。

   25）首选实例成员而不是常规：序数方法在枚举中给出数字位置。

   26）使用EnumMap而不是Ordinal Indexing：由于数组与泛型代码不兼容，因此需要进行未选中的转换。此外，存在使用序数索引计算数组索引时出错的可能性。 EnumMap将Map的类型安全性添加到阵列速度。

   27）从接口模拟可扩展枚举：我们不能组成可扩展枚举，但我们可以通过接口模拟它。因此允许最终用户组成实现该接口的特定实例。

   通用＃（28-33）：

   28）实施用于定义类型的标记接口：没有方法的接口是标记/标记接口（例如：可序列化）。标记接口表示一种类型，它将由标记类的实例实现，允许我们在编译期间捕获错误。

   29）返回空集合或数组而不是返回Null：这有时会最小化JVM上的负载。

   30）支持for / for循环的每个循环：For-Each隐藏迭代器或索引变量并将代码标记为整洁。

   31）优先于Boxed原语的原始类型：与盒装原语（包含1个非功能值）相比，原语（仅包含完全功能值）通常具有更少的空间和时间复杂性。如果原始和盒装基元混合或程序框基元，则会导致创建不必要且昂贵的对象。

   32）如果另一种类型合适，则阻止字符串：字符串是枚举，聚合和原始类型的不适当的替代，因为它们较慢且不够灵活。

   33）通过接口引用对象：我们必须倾向于使用接口而不是类来引用对象。如果存在适用的接口类型，则必须通过接口类型声明变量，参数，返回值和字段。这确保了代码的灵活性。

   例外情况＃（34-37）：

   34）Checked vs Unchecked（Runtime）异常：我们应该在调用者实际可以恢复的条件下强制执行检查异常。另一方面，强制执行未经检查的异常（子类化RuntimeException）以指示编码错误。

   35）防止不必要的检查异常：更多检查的异常会使API混乱。当普通代码无法正常运行时，运行时异常将正常运行。

   36）提高适用于抽象的异常：引发的异常应与代码相关。如果更改了高层实现，那么使用后续代码，它抛出的异常将会改变，从而破坏当前的最终用户代码。预防：实施异常翻译，即高必须捕获低层异常。 Exception Chaining可以加强这一过程。

   37）永远不要忽视异常：空白捕获块会超过异常的必要性。至少，它必须包含启发其存在理由的评论。

   线程＃（38-47）：

   38）确保线程安全：如果各种线程共享数据，则每个写入或读取数据的线程都应进行同步。

   39）避免极端同步：剩余同步会降低性能并可能触发死锁。在同步体中，不要调用可以以方法对象（外来方法）的形式从客户端覆盖或提供的方法。

   40）支持线程上的任务和执行程序：执行程序是任务的可执行接口依赖执行功能。计划的线程池执行程序将允许多个线程并从抛出未经检查的异常的任务中恢复。

   41）支持并发实用程序优先于通知和等待：必须强制执行高级别的并发实用程序，因为wait和notify将锁定和减速代码。

   42）Notify vs notifyAll：首选notifyAll over notify以确定线程的活跃度。这不会导致突然的问题。

   43）专注于延迟初始化：这可以最大限度地降低初始化类或创建实例的负担，最大限度地降低访问最近初始化字段的代价。我们可以轻松地初始化以获得性能并打破风险初始化循环。

   44）永远不要依赖线程调度程序：虽然这会提高性能，但它会使我们的代码不可移植且不健壮。 （例如：收益率和优先级方法）。

   45）通过线程组支持线程池执行程序：线程组隔离小程序以确保安全性。它们不提供有效的功能和性能。

   46）谨慎处理Serializable：除了增加测试负担以及错误和安全故障的确定性之外，这最大限度地减少了在分类/发布后更改类设计的弹性。

   47）更喜欢序列化实例的序列化代理：创建可序列化类的静态私有内部类，它简要表示包含类的对象的逻辑状态。这个内部类是序列化代理，可以最大限度地减少Serializable子句面临的故障。其他＃（48-51）：

   48）谨慎处理Native方法：它们用于向后兼容（C，C ）和性能。这使得代码不可移植。

   49）支持2元素枚举类型超过布尔类型：这提供了程序R / W功能并允许自动完成IDE。

   50）明智地实现Singleton模式：Singleton很难检查它的客户端，因为除非它实现了一个可以作为其类型的接口，否则不可能将模拟设计替换为单例。

   51）在Mutable fileld（s）上实施防御拷贝：防御拷贝阻止了对可变字段的修改。

   4 对比阅读

   我们重写了代码并使用JProfiler分析工具识别了资源利用率，并注意到确保了调整和长期维护。 除了分析代码之外，我们还使用针对源代码的解编译来调查字节代码（.class文件）。 除了减少时间和空间复杂性之外，我们还全面降低了错误率并增强了安全性。 我们的分析可以作为JAVA程序员的基准实践，以白盒测试工具的形式用于查找隐藏的错误。

   5 结论

   由于JAVA在许多商业应用开发中被用作前端编程语言，JAVA调优在编程微观世界中起着关键作用。 无论平台如何，调整都能带来巨大的性能提升。 另一方面，硬件调整涉及升级现有硬件，软件调整集中于调整编程方法和实践。

   参考文献

   1. Vamsi Krishna Myalapalli and Sunitha Geloth, “High Performance JAVA Programming”, IEEE International Conference on Pervasive Computing, Pune, India, January 2015.
   2. Vamsi Krishna Myalapalli, Jaya Krishna Myalapalli and Pradeep Raj Savarapu, “High Performance C Programming”, IEEE International Conference on Pervasive Computing, Pune, India, January 2015.
   3. Joshua Bl

      剩余内容已隐藏，支付完成后下载完整资料

      ---

      资料编号：[19988]，资料为PDF文档或Word文档，PDF文档可免费转换为Word