【IT168 技术文章】在创建后状态不再发生改变的对象称作常量对象(Immutable Objects)。常量对象其可靠性使其广泛地用作开发简单可靠代码的策略。常量对象在开发并发程序中非常有用。由于创建后不能被改变状态，它们不会被线程干扰所破坏，不可能产生不一致的观察状态。
Java程序员通常不愿意使用常量对象，他们担心创建新对象的开销要比更新可变对象状态的代价要大。对象创建代价通常被人们过分夸大，其影响往往可被常量对象带来的好处所抵消。这些好处包括垃圾收集可以减少常量对象的内存开销，降低为防止可变对象(mutable object)被破坏的代码复杂度。
下面举例说明使用常量对象给并发编程所带来的好处。SynchronizatedRGB类是描述颜色的类，它有三个整型字段表示颜色分量，一个字符串字段表示颜色名称：
2
3 //Values must be between 0 and 255.
4 private int red;
5 private int green;
6 private int blue;
7 private String name;
8
9 private void check(int red, int green, int blue) {
10 if (red < 0 || red > 255
11 || green < 0 || green > 255
12 || blue < 0 || blue > 255) {
13 throw new IllegalArgumentException();
14 }
15 }
16
17 public SynchronizedRGB(int red, int green, int blue, String name) {
18 check(red, green, blue);
19 this.red = red;
20 this.green = green;
21 this.blue = blue;
22 this.name = name;
23 }
24
25 public void set(int red, int green, int blue, String name) {
26 check(red, green, blue);
27 synchronized (this) {
28 this.red = red;
29 this.green = green;
30 this.blue = blue;
31 this.name = name;
32 }
33 }
34
35 public synchronized int getRGB() {
36 return ((red << 16) | (green << 8) | blue);
37 }
38
39 public synchronized String getName() {
40 return name;
41 }
42
43 public synchronized void invert() {
44 red = 255 - red;
45 green = 255 - green;
46 blue = 255 - blue;
47 name = "Inverse of " + name;
48 }
49 }
50
51
程序员必须小心使用这个SynchronizedRGB类，避免出现不一致状态的情况。比如假设某线程执行下面的代码：
2 ...
3 int myColorInt = color.getRGB(); //Statement 1
4 String myColorName = color.getName(); //Statement 2
5
然而此时如果另外一个线程在1语句和2语句之间调用了color.set方法, myColorInt值就不能匹配myColorName值。为避免这种结果，两条语句必须合并在一起互斥执行：
2 int myColorInt = color.getRGB();
3 String myColorName = color.getName();
4 }
5
这种不一致情况只在当SynchronizedRGB是可变对象时才会发生，对于常量版的SynchronizedRGB类却不是问题。
下面的准则列出了通常创建常量对象的策略，当然不是创建所有“常量”对象都要符合下面的准则。
1.不要提供“setter”方法，这些方法会修改字段以及由字段引用的对象。
2.将字段声明为final和private访问类型。
3.不允许子类覆盖方法，最简单的办法是将类定义为final。更复杂的方法是将构造函数定义为私有，并使用factory方法生成实例。
4.如果实例字段中包括可变对象的引用，则不允许这些对象被改变，也就是不要提供修该可变对象的方法。
5.不要将可变对象的引用共享;不要将可变对象的引用外部序列化;传递给构造函数的可变对象应复制备份赋给字段;不要返回原始对象，而应返回对象的复制。
根据上面准则应该按照下面办法修改SynchronizedRGS对象:
1.该类中有两种setter方法。第一个方法set会修改任意对象，因此在新版的常量类中删除set方法。第二个方法invert应该返回新创建的对象，不要返回经过修改的原对象。
2.所有字段要定义成private和final类型。
3.类本身要定义成final类。
4.name字段指向的对象是String。由于String对象是不可变的，因此不需要额外改动。
下面的代码ImmutableRGB类是新版的SynchronizedRGB:
2
3 //Values must be between 0 and 255.
4 final private int red;
5 final private int green;
6 final private int blue;
7 final private String name;
8
9 private void check(int red, int green, int blue) {
10 if (red < 0 || red > 255
11 || green < 0 || green > 255
12 || blue < 0 || blue > 255) {
13 throw new IllegalArgumentException();
14 }
15 }
16
17 public ImmutableRGB(int red, int green, int blue, String name) {
18 check(red, green, blue);
19 this.red = red;
20 this.green = green;
21 this.blue = blue;
22 this.name = name;
23 }
24
25 public int getRGB() {
26 return ((red << 16) | (green << 8) | blue);
27 }
28
29 public String getName() {
30 return name;
31 }
32
33 public ImmutableRGB invert() {
34 return new ImmutableRGB(255 - red, 255 - green, 255 - blue,
35 "Inverse of " + name);
36 }
37 }
38
39
通过上面修改，ImmutableRGB符合了常量对象的所有特征，可以放心的在并发程序中使用，而不用担心内存不一致和线程干扰。
Swing的实现大量使用了Immutable Object，比如Point、Rectangle等小对象。由于用户界面属于输入响应交互式模式，因此存在大量的并发问题，尤其界面、数据一致性问题。Swing通过使用这些Immutable Object较好的避免了并发问题。
但是同样也应该注意到，Immutable Object也会带来副作用，就是前面所说的小对象创建与销毁所带来的开销。Java的所有对象都是在内存堆而不是运行栈中分配，因此对象的创建、销毁及回收的开销都是比较大的。如果垃圾收集不是太及时，就会造成一定时间内类似于内存泄漏的现象，这也是Swing应用程序内存开销比较大的一个重要原因。
当然如果Java中加入类似与C/C++中的struct结构，这个问题能很容易地解决。C/C++中的struct是可以在运行时栈上分配的对象(其数组也是)，这使得它们在创建和回收小对象时非常高效。
我也曾思索过这个问题：为什么不在Java中加入栈分配对象的功能。前不久在JavaLobby碰巧也看到这个问题：ValueTypes - What are we waiting for? 但是迄今为止我没有看到比较合理的解释。如果java有类似struct的语言构造，我觉得想Swing应采用这种能在运行时栈分配的ValueType来描述Point和Rectangle等小对象。
有点跑题。总之在目前情况下，使用Immutable Object是一个进行小规模并发编程的好办法。
前面系列文章都是讲如何使用Java语言的基本并发特征来完成并发编程。Java6引入了一个java.util.concurrent包，这个包提供了一些高层次的并发编程工具，如线程池、原子对象、以及同步容器类等等，这些内容将在后续文章中讲述。
