Daniel Hu的技术生活博客

很早以前写在Baidu Blog上，今天有用到，所以搬了过来。

Elipse为Java项目的时候，有一个很人性化的“任务管理”功能，利用这个功能可以方便地将项目中一些需要处理的任务记录下来。先来看看“任务管理”是怎么使用的吧。
下面这个类在Class和name 属性的comment中分别加入了一段FIXME 和TODO标签，在FIXME和TODO标签的候命 还跟上了一段文字来说明需要任务的内容。
/**
* FIXME
* @author Administrator
*
*/
public class User {
    //TODO 需要增加Javadoc
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
打开Eclipse中的任务窗口(Task View)

在任务窗口中刚才定义的2个任务就会显示出来了。

任务完成以后，可以通过点击编辑窗口的左边的【任务提示标记】将相应的任务标签删除，任务窗口中任务也会一并删除。

 

Eclipse除了默认提供了3种任务标签(FIXME,TODO,XXX),参考下图,还可以支持自定义任务标签。 

进入Windows->Perferences->Java->Compile->Task Tags，我们就可以自定义任务标签，Eclipse中可以支持HIgh，Normal，Low三种级别的任务。

一直来使用的都是Eclipse，不过现在的手上的那个项目用Eclipse开发和debug总是不爽，就有了换个IDE的想法。选择IntelliJ IDEA，也是因为之前也使用过一阵子IntelliJ IDEA。今天google了一些关于IntelliJ IDEA使用、配置方面的内容，并做个简单的记录。我使用的IntelliJ IDEA版本是8.x

性能优化

1.修改JVM参数

修改idea.exe.vmoptions配置文件调整以下内容：
-Xms256m
-Xmx384m
-XX:MaxPermSize=128m
-XX:NewRatio=4
-Xss128k
-Dsun.awt.keepWorkingSetOnMinimize=true
-server
-Xms256m设置初时的内存数，你需要设置一个合理的值， 增加该值可以提高Java程序的启动速度。如果你的内存够大，如2G，可以设置到400m。
-Xmx384m设置最大内存数，提高该值，可以减少内存Garage收集的频率，提高程序性能。
-Dsun.awt.keepWorkingSetOnMinimize=true可以让IDEA最小化到任务栏时依然保持以占有的内存，当你重新回到IDEA，能够被快速显示，而不是由灰白的界面逐渐显现整个界面，加快回复到原界面的速度。
-server控制内存garage方式，这样你无需在花一到两分钟等待内存garage的收集。

2.优化文件保存和工程加载

取消“Synchronize file on frame activation”和“Save files on framedeactivation”的选择
同时我们选择"Save files automatically", 并将其设置为30秒，这样IDEA依然可以自动保持文件,所以在每次切换时，你需要按下Ctrl+S保存文件

如何让IntelliJ IDEA动的时候不打开工程文件：Settings->General去掉Reopen last project on startup

3.用*标识编辑过的文件

Editor –> Editor Tabs
—————————————–
在IDEA中，你需要做以下设置, 这样被修改的文件会以*号标识出来，你可以及时保存相关的文件。
"Mark modifyied tabs with asterisk"

4.显示行号

如何显示行号：Settings->Editor->Appearance标签项，勾选Show line numbers

5.自定义键盘快捷方式

如果默认代码提示和补全快捷键跟输入法冲突，如何解决：Settings->Keymap

6.如何让光标不随意定位

Settings->Editor中去掉Allow placement of caret after end of line。

7.中文乱码问题

在包含中文文件名或者文件夹的时候会出现??的乱码，解决方法如下：

File菜单->Settings->Colors & Fonts->Editor Font=宋体, size=12, line spacing =1.0
File菜单->Settings->Appearance-> Font Name=Simsun，size=12

8.如何完美显示中文

Settings->Appearance中勾选Override default fonts by (not recommended)，设置Name:NSimSun，Size:12

 

参考资料

Intellij idea性能优化
IntelliJ IDEA 目录技巧
IntelliJ IDEA 8性能优化
intellij idea 使用总结

LINUX

Linux设置环境变量

Linux的五个查找命令

15 Practical Linux Find Command Examples

find和crontab命令学习

SOA

十年SOA：当前的位置和未来的方向

SOA治理的仙境

2010年SOA发展趋势

对SOA实施者的实践忠告

Operation & Management

从Twitter 运维技术经验可以学到什么

• Disk is the new Tape. (内存是新类型的磁盘. 磁盘是新类型的磁带)
• Kill long running queries before they kill you. (问题是如何提前发现? 有效的监控!)
• Use metrics to make decisions, not guesses.
• "Cache Everything!" not the best policy

Agile

VISUAL STUDIO TEAM ARCHITECT团队的敏捷开发 （第三部分）

七年IT经验的七个总结

分享第一 条经验：“学历代表过去、能力代表现在、学习力代表未来。”

心态有多开放，视野就有多开阔。

尽量参加开源项目的开发、或者与朋友共同研制一些自己的产品，千万不要因为没有钱赚而不做。

书籍是人类进步的阶梯，对软件开发人员尤其如此。

详细制定自己软件开发专业知识学习计划，并注意及时修正和调整（软件开发技术变化实在太快）。

一定要确定自己的发展方向，并为此目的制定可行的计划。

总结与反思：

一： 不要去做技术上的高手，除非你的目标如此。虽然本文是关于提高软件开发知识的建议，做技术的高手是我一向都不赞同的。你可以提高自己的专业知识，但能胜任工作即止。

二： 在能胜任工作的基础上，立即去涉猎其它领域的专业知识，丰富自己的知识体系、提高自己的综合素质，尤其是那些目标不在技术方面的朋友。

Architecture

个人管理 － 我是这样偷着做架构的

毕加索一句话“Bad artists copy;Good artist steal”，现在搞艺术的都传为“Good artists copy, great artists steal”

读书时抄作业

1. 找到可以抄袭的作业
   • 找对人：我不会随便找一个人的来抄袭，因为我怕抄错了被发现了，所以我找的人不是班长也是课代表，或者排名前十名的。其次是这个人是否开放（Open），有些人不够哥们，把作业本子藏的好好的，你问他他当没听见，或者直接说不给。
   • 找对作业：有的人字迹写的差，你有时不小心就会抄错
2. 求同存异
   • 我也不是一个差学生，也算有思想的，所以当然不会只是像罚抄作业一样。抄的过程中，我也会看看他做的思路是不是对，如果对我就会全部抄下来
   • 有时后为了不让老师发现，我也会特意修改一些内容，不让把顺序颠倒一下，文字修改一下
3. 修正
   • 在抄的过程中，如果发现有明显错误的地方，我会自己修改一下，毕竟，我要偷也要做得职业点：）

其他

质量是什么？

质量是一种责任心，是一种对人对事负责的态度。

质量是一种责任心，是一种对人对事负责的态度。

java.util.concurrent包提供了很多并发的工具类，下面这段代码是一个简单的线程池的样例代码。

public class FixedThreadPoolDemo {
	public static void main(String[] args) {

		// int nThreads=Runtime.getRuntime().availableProcessors();
		ExecutorService executorService = Executors.newFixedThreadPool(2);

		Runnable saveLogTask = new Runnable() {

			@Override
			public void run() {
				try {
					Thread.currentThread().sleep(2000L);
				 System.out.println("Log is saved by thread"
						+ Thread.currentThread().getId());
				} catch (InterruptedException e) {
					e.printStackTrace();
				}

			}
		};
		Runnable feedBack = new Runnable() {

			@Override
			public void run() {
				try {
					Thread.currentThread().sleep(2000L);
				   System.out.println("Feedback is called by thread"
						+ Thread.currentThread().getId());
				} catch (InterruptedException e) {
					e.printStackTrace();
				}

			}
		};

		executorService.submit(saveLogTask);
		System.out.println("Do save log asynchronously.");
		executorService.submit(feedBack);
		System.out.println("Call feedback asynchronously.");

	}
}

其他相关

转载：使用Callable返回结果

-Xms 最小堆的大小， 也就是当你的虚拟机启动后， 就会分配这么大的堆内存给你

-Xmx 是最大堆的大小

-Xmn设置新生代的大小

整个JVM内存大小=新生代大小 + 老生代大小 + 永生代大小。老生代一般固定大小为64m，所以增大年轻代后，将会减小年老代大小。此值对系统性能影响较大，Sun官方推荐配置为整个堆的3/8。

样例配置

JAVA_OPTS=”${JAVA_OPTS} -Xms512m -Xmx1536m -XX:MaxPermSize=256m”

从程序中也可以获取部分的JVM 内存参数

public class GetHeapSize {
	public static void main(String[] args) {

		// Get the jvm heap size.
		Runtime runtime = Runtime.getRuntime();

		long heapSize = runtime.totalMemory()/1024/1024;

		// Print the jvm heap size.
		long maxMemory = runtime.maxMemory()/1024/1024;
		System.out.println("Heap Size = " + heapSize+", maxMemory="+maxMemory);
	}
}

java -Xms64m -Xmx256m -Xmn16m com.danieljourney.GetHeapSize

输出 Heap Size = 62, maxMemory=254

java -Xms256m -Xmx256m -Xmn256m com.danieljourney.GetHeapSize

输出 Heap Size = 254, maxMemory=254

-Xss设置每个线程的堆栈大小。JDK5.0以后每个线程堆栈大小为1M，以前每个线程堆栈大小为256K。更具应用的线程所需内存大小进行调整。在相同物理内存下，减小这个值能生成更多的线程。但是操作系统对一个进程内的线程数还是有限制的，不能无限生成，经验值在3000~5000左右。

-XX:NewRatio=n设置新生代和老生代的比值。如:为3，表示新生代与老生代比值为1：3，新生代占整个老生代老生代和的1/4。

-XX:SurvivorRatio=n:新生代中Eden区与两个Survivor区的比值，注意Survivor区有两个。如：3，表示Eden：Survivor=3：2，一个Survivor区占整个年轻代的1/5。

-XX:MaxPermSize=n:设置永生代大小。

JAVA_OPTS=”${JAVA_OPTS} -Xms512m -Xmx1536m -XX:MaxPermSize=256m”

参考资料

转载：Java 6 JVM参数选项大全（中文版）

Java内存管理系列文章

There are two main concepts in JMS: message brokers and destinations.

When an application sends a message, it hands it off to a message broker. A Message broker is JMS’s answer to the post office. The message broker will ensure that the message is delivered to the specified destination, leaving the sender free to go about other business.

Point-to-point messaging model

In the point-to-point model, each message has exactly one sender and one receiver. When the message broker is given a message, it places the message in a queue. When a receiver comes along and asks for the next message in the queue, the message is pulled from the queue and delivered to the receiver. Because the message is removed from the queue as it is delivered, it is guaranteed that the message will be delivered to only one receiver.

Publish-subscribe messaging model

In the publish-subscribe messaging model, messages are sent to a topic. As with queues, many receivers may be listening to a topic. However, unlike queues where a message is delivered to exactly one receiver, all subscribers to a topic will receive a copy of the message.

 

 

作者：Ken Wu

Email: ken.wug@gmail.com

原文链接 http://kenwublog.com/docs/java6-jvm-options-chinese-edition.htm！

本文是基于最新的SUN官方文档Java SE 6 Hotspot VM Options 编写的译文。主要介绍JVM中的非稳态选项及其使用说明。

为了让读者明白每个选项的含义，作者在原文基础上补充了大量的资料。希望这份文档，对正在研究JVM参数的朋友有帮助！

另外，考虑到本文档是初稿，如有描述错误，敬请指正。

非稳态选项使用说明

-XX:+<option> 启用选项

-XX:-<option> 不启用选项

-XX:<option>=<number> 给选项设置一个数字类型值，可跟单位，例如 32k, 1024m, 2g
-XX:<option>=<string> 给选项设置一个字符串值，例如-XX:HeapDumpPath=./dump.core

行为选项

选项

默认值与限制

描述

-XX:-AllowUserSignalHandlers

限于Linux和Solaris，默认不启用

允许为java进程安装信号处理器。

Java信号处理相关知识，详见 http://kenwublog.com/java-asynchronous-notify-based-on-signal

-XX:-DisableExplicitGC

默认不启用

禁止在运行期显式地调用 System.gc()。

开启该选项后，GC的触发时机将由Garbage Collector全权掌控。
注意：你熟悉的代码里没调用System.gc()，不代表你依赖的框架工具没在使用。

例如RMI就在多数用户毫不知情的情况下，显示地调用GC来防止自身OOM。

请仔细权衡禁用带来的影响。

-XX:-RelaxAccessControlCheck

默认不启用

在Class校验器中，放松对访问控制的检查。

作用与reflection里的setAccessible类似。

-XX:-UseConcMarkSweepGC

默认不启用

启用CMS低停顿垃圾收集器。

资料详见：http://kenwublog.com/docs/CMS_GC.pdf

-XX:-UseParallelGC

-server时启用

其他情况下，默认不启用

策略为新生代使用并行清除，年老代使用单线程Mark-Sweep-Compact的垃圾收集器。

-XX:-UseParallelOldGC

默认不启用

策略为老年代和新生代都使用并行清除的垃圾收集器。

-XX:-UseSerialGC

-client时启用

其他情况下，默认不启用

使用串行垃圾收集器。

-XX:+UseSplitVerifier

java5默认不启用

java6默认启用

使用新的Class类型校验器 。

新Class类型校验器有什么特点？
新Class类型校验器，将老的校验步骤拆分成了两步：
1，类型推断。
2，类型校验。
新类型校验器通过在javac编译时嵌入类型信息到bytecode中，省略了类型推断这一步，从而提升了classloader的性能。

Classload顺序（供参考）
load -> verify -> prepare -> resove -> init

关联选项：
-XX:+FailOverToOldVerifier

-XX:+FailOverToOldVerifier

Java6新引入选项，默认启用

如果新的Class校验器检查失败，则使用老的校验器。

为什么会失败？

因为JDK6最高向下兼容到JDK1.2，而JDK1.2的class info 与JDK6的info存在较大的差异，所以新校验器可能会出现校验失败的情况。

关联选项：
-XX:+UseSplitVerifier

-XX:+HandlePromotionFailure

java5以前是默认不启用，java6默认启用

关闭新生代收集担保。

什么是新生代收集担保？
在一次理想化的minor gc中，Eden和First Survivor中的活跃对象会被复制到Second Survivor。
然而，Second Survivor不一定能容纳下所有从E和F区copy过来的活跃对象。

为了确保minor gc能够顺利完成，GC需要在年老代中额外保留一块足以容纳所有活跃对象的内存空间。
这个预留操作，就被称之为新生代收集担保（New Generation Guarantee）。如果预留操作无法完成时，仍会触发major gc(full gc)。
为什么要关闭新生代收集担保？
因为在年老代中预留的空间大小，是无法精确计算的。

为了确保极端情况的发生，GC参考了最坏情况下的新生代内存占用，即Eden+First Survivor。

这种策略无疑是在浪费年老代内存，从时序角度看，还会提前触发Full GC。

为了避免如上情况的发生，JVM允许开发者手动关闭新生代收集担保。

在开启本选项后，minor gc将不再提供新生代收集担保，而是在出现survior或年老代不够用时，抛出promotion failed异常。

-XX:+UseSpinning

java1.4.2和1.5需要手动启用, java6默认已启用

启用多线程自旋锁优化。

自旋锁优化原理

大家知道，Java的多线程安全是基于Lock机制实现的，而Lock的性能往往不如人意。
原因是，monitorenter与monitorexit这两个控制多线程同步的bytecode原语，是JVM依赖操作系统互斥(mutex)来实现的。
互斥是一种会导致线程挂起，并在较短的时间内又必须重新调度回原线程的，较为消耗资源的操作。

为了避免进入OS互斥，Java6的开发者们提出了自旋锁优化。

自旋锁优化的原理是在线程进入OS互斥前，通过CAS自旋一定的次数来检测锁的释放。

如果在自旋次数未达到预设值前锁已被释放，则当前线程会立即持有该锁。

CAS检测锁的原理详见: http://kenwublog.com/theory-of-lightweight-locking-upon-cas

关联选项：
-XX:PreBlockSpin=10

-XX:PreBlockSpin=10

-XX:+UseSpinning 必须先启用，对于java6来说已经默认启用了，这里默认自旋10次

控制多线程自旋锁优化的自旋次数。(什么是自旋锁优化？见 -XX:+UseSpinning 处的描述)

关联选项：
-XX:+UseSpinning

-XX:+ScavengeBeforeFullGC

默认启用

在Full GC前触发一次Minor GC。

-XX:+UseGCOverheadLimit

默认启用

限制GC的运行时间。如果GC耗时过长，就抛OOM。

-XX:+UseTLAB

1.4.2以前和使用-client选项时，默认不启用，其余版本默认启用

启用线程本地缓存区（Thread Local）。

-XX:+UseThreadPriorities

默认启用

使用本地线程的优先级。

-XX:+UseAltSigs

限于Solaris，默认启用

为了防止与其他发送信号的应用程序冲突，允许使用候补信号替代 SIGUSR1和SIGUSR2。

-XX:+UseBoundThreads

限于Solaris, 默认启用

绑定所有的用户线程到内核线程。
减少线程进入饥饿状态（得不到任何cpu time）的次数。

-XX:+UseLWPSynchronization

限于solaris，默认启用

使用轻量级进程（内核线程）替换线程同步。

-XX:+MaxFDLimit

限于Solaris，默认启用

设置java进程可用文件描述符为操作系统允许的最大值。

-XX:+UseVMInterruptibleIO

限于solaris，默认启用

在solaris中，允许运行时中断线程 。

---

性能选项

选项与默认值

默认值与限制

描述

-XX:+AggressiveOpts

JDK 5 update 6后引入，但需要手动启用。

JDK6默认启用。

启用JVM开发团队最新的调优成果。例如编译优化，偏向锁，并行年老代收集等。

-XX:CompileThreshold=10000

1000

通过JIT编译器，将方法编译成机器码的触发阀值，可以理解为调用方法的次数，例如调1000次，将方法编译为机器码。

-XX:LargePageSizeInBytes=4m

默认4m

amd64位：2m

设置堆内存的内存页大小。

调整内存页的方法和性能提升原理，详见 http://kenwublog.com/tune-large-page-for-jvm-optimization

-XX:MaxHeapFreeRatio=70

70

GC后，如果发现空闲堆内存占到整个预估堆内存的70%，则收缩堆内存预估最大值。

什么是预估堆内存？

预估堆内存是堆大小动态调控的重要选项之一。

堆内存预估最大值一定小于或等于固定最大值(-Xmx指定的数值)。

前者会根据使用情况动态增大或缩小，以提高GC回收的效率。

-XX:MaxNewSize=size

1.3.1 Sparc: 32m

1.3.1 x86: 2.5m

新生代占整个堆内存的最大值。

-XX:MaxPermSize=64m

5.0以后: 64 bit VMs会增大预设值的30%

1.4 amd64: 96m

1.3.1 -client: 32m

其他默认 64m

Perm（俗称方法区）占整个堆内存的最大值。

-XX:MinHeapFreeRatio=40

40

GC后，如果发现空闲堆内存占到整个预估堆内存的40%，则增大堆内存的预估最大值。此值不会超过固定最大值。

(什么是预估堆内存？见 -XX:MaxHeapFreeRatio 处的描述)

关联选项：

-XX:MaxHeapFreeRatio=70

-XX:NewRatio=2

Sparc -client: 8

x86 -server: 8

x86 -client: 12

-client: 4 (1.3)

8 (1.3.1+)

x86: 12

其他默认 2

新生代和年老代的堆内存占用比例。

例如2表示新生代占最大堆内存的1/2。即年老代和新生代平分堆的占用。

-XX:NewSize=2.125m

5.0以后: 64 bit Vms 会增大预设值的30%

x86: 1m

x86, 5.0以后: 640k

其他默认 2.125m

新生代预估堆内存占用的默认值。(什么是预估堆内存？见 -XX:MaxHeapFreeRatio 处的描述)

-XX:ReservedCodeCacheSize=32m

Solaris 64-bit, amd64, -server x86: 48m

1.5.0_06之前, Solaris 64-bit amd64: 1024m

其他默认 32m

设置代码缓存的最大值，编译时用。

-XX:SurvivorRatio=8

Solaris amd64: 6

Sparc in 1.3.1: 25

Solaris platforms 5.0以前: 32

其他默认 8

Eden与Survivor的占用比例。例如8表示，一个survivor区占用 1/8 的新生代内存，另外因为有2个survivor，

所以survivor总共是占用新生代内存的 2/8，Eden的占比则为 6/8。

-XX:TargetSurvivorRatio=50

50

实际使用的survivor空间大小占比。默认是50%，最高90%。

-XX:ThreadStackSize=512

Sparc: 512

Solaris x86: 320 (5.0以前 256)

Sparc 64 bit: 1024

Linux amd64: 1024 (5.0 以前 0)

其他默认 512.

线程堆栈大小

-XX:+UseBiasedLocking

JDK 5 update 6后引入，但需要手动启用。

JDK6默认启用。

启用偏向锁。

偏向锁原理详见 http://kenwublog.com/theory-of-java-biased-locking

-XX:+UseFastAccessorMethods

默认启用

优化原始类型的getter方法性能。

-XX:-UseISM

默认启用

启用solaris的ISM。

详见Intimate Shared Memory.

-XX:+UseLargePages

JDK 5 update 5后引入，但需要手动启用。

JDK6默认启用。

启用大内存分页。

调整内存页的方法和性能提升原理，详见http://kenwublog.com/tune-large-page-for-jvm-optimization

关联选项

-XX:LargePageSizeInBytes=4m

-XX:+UseMPSS

1.4.1 之前: 不启用

其余版本默认启用

启用solaris的MPSS，不能与ISM同时使用。

-XX:+StringCache

默认启用

启用字符串缓存。

-XX:AllocatePrefetchLines=1

1

与机器码指令预读相关的一个选项，资料比较少，本文档不做解释。有兴趣的朋友请自行阅读官方doc。

-XX:AllocatePrefetchStyle=1

1

与机器码指令预读相关的一个选项，资料比较少，本文档不做解释。有兴趣的朋友请自行阅读官方doc。

---

调试选项

选项与默认值

默认值与限制

描述

-XX:-CITime

1.4引入。

默认启用

打印JIT编译器编译耗时。

-XX:ErrorFile=./hs_err_pid<pid>.log

Java 6引入。

如果JVM crashed，将错误日志输出到指定文件路径。

-XX:-ExtendedDTraceProbes

Java6引入，限于solaris

默认不启用

启用dtrace诊断。

-XX:HeapDumpPath=./java_pid<pid>.hprof

默认是java进程启动位置，即user.dir

堆内存快照的存储文件路径。

什么是堆内存快照？

当java进程因OOM或crash被OS强制终止后，会生成一个hprof（Heap PROFling）格式的堆内存快照文件。该文件用于线下调试，诊断，查找问题。

文件名一般为

java_<pid>_<date>_<time>_heapDump.hprof

解析快照文件，可以使用 jhat, eclipse MAT，gdb等工具。

-XX:-HeapDumpOnOutOfMemoryError

1.4.2 update12 和 5.0 update 7 引入。

默认不启用

在OOM时，输出一个dump.core文件，记录当时的堆内存快照（什么是堆内存快照? 见 -XX:HeapDumpPath 处的描述）。

-XX:OnError="<cmd args>;<cmd args>"

1.4.2 update 9引入

当java每抛出一个ERROR时，运行指定命令行指令集。指令集是与OS环境相关的，在linux下多数是bash脚本，windows下是dos批处理。

-XX:OnOutOfMemoryError="<cmd args>;
<cmd args>"

1.4.2 update 12和java6时引入

当第一次发生OOM时，运行指定命令行指令集。指令集是与OS环境相关的，在linux下多数是bash脚本，windows下是dos批处理。

-XX:-PrintClassHistogram

默认不启用

在Windows下, 按ctrl-break或Linux下是执行kill -3（发送SIGQUIT信号）时，打印class柱状图。

Jmap –histo pid也实现了相同的功能。

详见 http://java.sun.com/javase/6/docs/technotes/tools/share/jmap.html

-XX:-PrintConcurrentLocks

默认不启用

在thread dump的同时，打印java.util.concurrent的锁状态。

Jstack –l pid 也同样实现了同样的功能。

详见 http://java.sun.com/javase/6/docs/technotes/tools/share/jstack.html

-XX:-PrintCommandLineFlags

5.0 引入，默认不启用

Java启动时，往stdout打印当前启用的非稳态jvm options。

例如：

-XX:+UseConcMarkSweepGC -XX:+HeapDumpOnOutOfMemoryError -XX:+DoEscapeAnalysis

-XX:-PrintCompilation

默认不启用

往stdout打印方法被JIT编译时的信息。

例如：

1 java.lang.String::charAt (33 bytes)

-XX:-PrintGC

默认不启用

开启GC日志打印。

打印格式例如：

[Full GC 131115K->7482K(1015808K), 0.1633180 secs]

该选项可通过 com.sun.management.HotSpotDiagnosticMXBean API 和 Jconsole 动态启用。

详见 http://java.sun.com/developer/technicalArticles/J2SE/monitoring/#Heap_Dump

-XX:-PrintGCDetails

1.4.0引入，默认不启用

打印GC回收的细节。

打印格式例如：

[Full GC (System) [Tenured: 0K->2394K(466048K), 0.0624140 secs] 30822K->2394K(518464K), [Perm : 10443K->10443K(16384K)], 0.0625410 secs] [Times: user=0.05 sys=0.01, real=0.06 secs]

该选项可通过 com.sun.management.HotSpotDiagnosticMXBean API 和 Jconsole 动态启用。

详见 http://java.sun.com/developer/technicalArticles/J2SE/monitoring/#Heap_Dump

-XX:-PrintGCTimeStamps

默认不启用

打印GC停顿耗时。

打印格式例如：

2.744: [Full GC (System) 2.744: [Tenured: 0K->2441K(466048K), 0.0598400 secs] 31754K->2441K(518464K), [Perm : 10717K->10717K(16384K)], 0.0599570 secs] [Times: user=0.06 sys=0.00, real=0.06

secs]

该选项可通过 com.sun.management.HotSpotDiagnosticMXBean API 和 Jconsole 动态启用。

详见 http://java.sun.com/developer/technicalArticles/J2SE/monitoring/#Heap_Dump

-XX:-PrintTenuringDistribution

默认不启用

打印对象的存活期限信息。

打印格式例如：

[GC
Desired survivor size 4653056 bytes, new threshold 32 (max 32)
- age 1: 2330640 bytes, 2330640 total
- age 2: 9520 bytes, 2340160 total

204009K->21850K(515200K), 0.1563482 secs]

Age1 2表示在第1和2次GC后存活的对象大小。

-XX:-TraceClassLoading

默认不启用

打印class装载信息到stdout。记Loaded状态。

例如：

[Loaded java.lang.Object from /opt/taobao/install/jdk1.6.0_07/jre/lib/rt.jar]

-XX:-TraceClassLoadingPreorder

1.4.2引入，默认不启用

按class的引用/依赖顺序打印类装载信息到stdout。不同于 TraceClassLoading，本选项只记 Loading状态。

例如：

[Loading java.lang.Object from /home/confsrv/jdk1.6.0_14/jre/lib/rt.jar]

-XX:-TraceClassResolution

1.4.2引入，默认不启用

打印所有静态类，常量的代码引用位置。用于debug。

例如：

RESOLVE java.util.HashMap java.util.HashMap$Entry HashMap.java:209

说明HashMap类的209行引用了静态类 java.util.HashMap$Entry

-XX:-TraceClassUnloading

默认不启用

打印class的卸载信息到stdout。记Unloaded状态。

-XX:-TraceLoaderConstraints

Java6 引入，默认不启用

打印class的装载策略变化信息到stdout。

例如：

[Adding new constraint for name: java/lang/String, loader[0]: sun/misc/Launcher$ExtClassLoader, loader[1]: <bootloader> ]

[Setting class object in existing constraint for name: [Ljava/lang/Object; and loader sun/misc/Launcher$ExtClassLoader ]

[Updating constraint for name org/xml/sax/InputSource, loader <bootloader>, by setting class object ]

[Extending constraint for name java/lang/Object by adding loader[15]: sun/reflect/DelegatingClassLoader ]

装载策略变化是实现classloader隔离/名称空间一致性的关键技术。

对此感兴趣的朋友，详见 http://kenwublog.com/docs/Dynamic+Class+Loading+in+the+Java+Virtual+Machine.pdf 中的 contraint rules一章。

-XX:+PerfSaveDataToFile

默认启用

当java进程因OOM或crashed被强制终止后，生成一个堆快照文件（什么是堆内存快照? 见 -XX:HeapDumpPath 处的描述）。

作者敬告

完善的单元测试，功能回归测试，和性能基准测试可以减少因调整非稳态JVM选项带来的风险。

参考资料

Java6性能调优白皮书

http://java.sun.com/performance/reference/whitepapers/6_performance.html

Java6 GC调优指南

http://java.sun.com/javase/technologies/hotspot/gc/gc_tuning_6.html

更为全面的options列表

http://blogs.sun.com/watt/resource/jvm-options-list.html

周五给大家做的关于常用JAVA代码质量静态检查工具的分享，一并通过网站分享给大家。

通常我们初始化一个Collection类采用以下的样例代码

List normal = new ArrayList();
normal.add("string_1");
normal.add("string_2");
normal.add("string_3");

这种初始化方式也可以替换成下面的代码

List<String> countries = new ArrayList<String>() {{
	add("India");
	add("Switzerland");
	add("Italy");
	add("France");
	add("Germany");
}};

    这种编码风格让Java这种语言似乎多了动态语言的色彩:-)，这就是Java的Double Brace Initialization，

这种实现方式的原理和可能存在的性能问题，大家可以学习原文Double Brace Initialization in Java。

.

原文地址 http://java.chinaitlab.com/advance/748786.html

自从Java平台的最开始，Runnable接口就已存在了。它允许你定义一个可由线程完成的任务。如大多数人所已知的那样，它只提供了一个run方法，该方法既不接受任何参数，也不返回任何值。如果你需要从一个未完成的任务中返回一个值，你就必须在该接口之外使用一个方法去等待该任务完成时通报的某种消息。例如，下面的示例就是你在这种情景下可能做的事情：

Runnable runnable = …;
Thread t = new Thread(runnable);
t.start();
t.join();
String value = someMethodtoGetSavedValue()

严格来说，上述代码并无错误，但现在可用不同的方法去做，这要感谢J2SE 5.0引入的Callable接口。不同于Runnable接口拥有run方法，Callable接口提供的是call方法，该方法可以返回一个 Object对象，或可返回任何一个在泛型化格式中定义了的特定类型的对象。

    public interface Callable<V> {
       V call() throws Exception;
    }

因为你不可能把Callable对象传到Thread对象去执行，你可换用ExecutorService对象去执行Callable对象。该服务接受Callable对象，并经由submit方法去执行它。

    <T> Future<T> submit(Callable<T> task)

如该方法的定义所示，提交一个Callable对象给ExecutorService会返回一个Future对象。然后，Future的get方法将会阻塞，直到任务完成。
    为了证明这一点，下面的例子为命令行中的每个词都创建一个单独的Callable实例，然后把这些词的长度加起来。各个Callable对象将只是计算它自己的词的长度之和。Futures对象的Set集合将被保存以便从中获得计算用的值。如果需要保持返回值的顺序，则可换用一个List对象。

import java.util.*;
import java.util.concurrent.*;

public class CallableExample {

    public static class WordLengthCallable
            implements Callable {
        private String word;
        public WordLengthCallable(String word) {
            this.word = word;
        }
        public Integer call() {
            return Integer.valueOf(word.length());
        }
    }

    public static void main(String args[]) throws Exception {
        ExecutorService pool = Executors.newFixedThreadPool(3);
        Set<Future<Integer>> set = new HashSet<Future&lg;Integer>>();
        for (String word: args) {
            Callable<Integer> callable = new WordLengthCallable(word);
            Future<Integer> future = pool.submit(callable);
            set.add(future);
        }
        int sum = 0;
        for (Future<Integer> future : set) {
            sum += future.get();
        }
        system.out.printf("The sum of lengths is %s%n", sum);
        system.exit(sum);
    }
}

     WordLengthCallable保存了每个词并使用该词的长度作为call方法的返回值。这个值可能会花点儿时间

去生成，不过在这个例子中，可以立即知道它。 call方法的唯一要求是这个值要在call方法的结尾处返回。

当Future的get方法稍后被调用时，如果任务运行得很快的话，Future将会自动得到这个值(如同本例的情

况)，否则将一直等到该值生成完毕为止。多次调用get方法不会导致任务从该线程返回。因为该程序的目

的是计划所有字的长度之和，它不会强令Callable任务结束。如果最后一个任务在前三个任务之前完成，

也是没错的。对 Future的get方法的第一次调用将只会等待Set中第一个任务结束，而不会阻塞其它的任务

分别执行完毕。它只会等待当次线程或任务结束。这个特定的例子使用固定数线程池来产生ExecutorService

对象，但其它有效的方法也是可行的。