Java并发编程（六）不可改变对象

6. 不可改变对象

如果一个对象在创建后不可改变，那么就称之为不可改变对象。基于不可变对象被广泛接受为创建简单、可靠代码的有效策略。

不可变对象在并发程序中显得尤为重要。由于它们不能改变，所以他们不会在线程干扰中出现错误，并且不会出现非一致性状态。

开发者并不太原因使用不可变对象，他们担心创建对象的开销比更新一个现有对象的开销大。创建对象的开销经常被夸大，并且可以被不可变对象带来的效率弥补。这包括由于垃圾回收降低的开销和没有必要保护不可变对象被改变。

接下来的小节介绍一个不可变对象类，并且从该类得到了一个不可变实例。这样，给出了这类转换的一般规则，并展示了不可变对象的优势。

6.1 一个同步类例子

SynchronizedRGB类定义了代表颜色的对象。每一个对象使用三个原色的数值代表颜色，和一个颜色名字的字符串。

public class SynchronizedRGB {

    // Values must be between 0 and 255.
    private int red;
    private int green;
    private int blue;
    private String name;

    private void check(int red,
                       int green,
                       int blue) {
        if (red < 0 || red > 255
            || green < 0 || green > 255
            || blue < 0 || blue > 255) {
            throw new IllegalArgumentException();
        }
    }

    public SynchronizedRGB(int red,
                           int green,
                           int blue,
                           String name) {
        check(red, green, blue);
        this.red = red;
        this.green = green;
        this.blue = blue;
        this.name = name;
    }

    public void set(int red,
                    int green,
                    int blue,
                    String name) {
        check(red, green, blue);
        synchronized (this) {
            this.red = red;
            this.green = green;
            this.blue = blue;
            this.name = name;
        }
    }

    public synchronized int getRGB() {
        return ((red << 16) | (green << 8) | blue);
    }

    public synchronized String getName() {
        return name;
    }

    public synchronized void invert() {
        red = 255 - red;
        green = 255 - green;
        blue = 255 - blue;
        name = "Inverse of " + name;
    }
}

SynchronizedRGB类必须小心使用来避免不一致状态。例如，假设一个线程执行以下代码，

SynchronizedRGB color =
    new SynchronizedRGB(0, 0, 0, "Pitch Black");
...
int myColorInt = color.getRGB();      //Statement 1
String myColorName = color.getName(); //Statement 2

如果另一个线程在语句1之后，语句2之前调用color.set，那么myColorInt的值就和myColorName的值不符合。为了避免这样，这两个命令必须绑定在一起，

synchronized (color) {
    int myColorInt = color.getRGB();
    String myColorName = color.getName();
} 

这类不一致状态只能发生在可变对象上——对于SynchronizedRGB的不可变对象版本，却不会产生任何问题。

6.2 一种定义不可变对象的策略

接下来的几条规则定义了一种创建不可变对象的策略。不是所有的不可变对象都要符合这些规则。也不意味着这些类的构造方法都是草率的——他们可能有很好的理由相信对象在创建后不会改变。然而，这些策略需要复杂的分析，并且不适用于初学者。

1. 不提供setter方法——修改域的值的方法
2. 将所有的域都设置为final和private
3. 不允许子类重写方法。最简单的方法就是设置类为final。一个复杂的方法是将构造方法私有化，并通过工厂方法创建实例。
4. 如果实例域包括一个可变对象的引用，那么不允许修改这些对象。
   
   1. 不提供修改可变对象的方法。
   2. 不要共享可变对象的引用。不要将引用保存在外部，不要将可变对象传递给构造函数，必要的话，创建拷贝，并存储拷贝的引用。类似的，必要的时候创建内部可变对象的拷贝，来避免在方法中返回可变对象的原始引用。

将这些策略应用到SynchronizedRGB包括以下步骤，

1. 该类中有两个setter方法。第一个，set方法，任意地改变对象，在该类的不可变对象版本中删除。第二个，invert方法，可以用创建一个新的对象而不是修改原来的对象来适配。
2. 所有的域都设置为private，进一步设置为final
3. 将该类设置为final
4. 只有一个域指向一个对象，并且那个对象是不可修改的。因此，没有必要保护包含的可变对象的状态改变。

这些改变之后，我们有了ImmutableRGB类，

final public class ImmutableRGB {

    // Values must be between 0 and 255.
    final private int red;
    final private int green;
    final private int blue;
    final private String name;

    private void check(int red,
                       int green,
                       int blue) {
        if (red < 0 || red > 255
            || green < 0 || green > 255
            || blue < 0 || blue > 255) {
            throw new IllegalArgumentException();
        }
    }

    public ImmutableRGB(int red,
                        int green,
                        int blue,
                        String name) {
        check(red, green, blue);
        this.red = red;
        this.green = green;
        this.blue = blue;
        this.name = name;
    }


    public int getRGB() {
        return ((red << 16) | (green << 8) | blue);
    }

    public String getName() {
        return name;
    }

    public ImmutableRGB invert() {
        return new ImmutableRGB(255 - red,
                       255 - green,
                       255 - blue,
                       "Inverse of " + name);
    }
}

文章翻译自Java Tutorials，Immutable Objects，翻译难免会有纰漏，欢迎读者讨论指正。