多线程学习系列 - 2 - Immutable Pattern

目录

多线程学习系列 - 1 - Single Threaded Execution Pattern

多线程学习系列 - 2 - Immutable Pattern

先看看什么算是Immutable

immutable [i'mju:t?bl]（21世纪大英汉词典） adj.永远不变的；不可改变的；永恒的；无变化的

能够保证实例状态绝对不会改变的类，我们认为是immutable的

最常用的String就是immutable类

考虑下面Person类，看它是如何成为一个immutable类

它有属性String name和String address

public final class Person {private final String name;private final String address;public Person(String name, String address){this.name = name;this.address = address;}public String getName(){return name;}public String getAddress(){return address;}public String toString(){return "Person [name:" + name + "\t address:" + address + "]";}}

类很简单，只有两个字段几个方法

首先Person非常凶猛，上场先挥刀自宫，把自己声明成final绝后，所以也就没有子类能修改父类属性的可能

然后把两个属性都声明为private，也就是说对外不可见，并且设置为final也禁止了set方法的再次赋值

至此Person功德圆满，成为了immutable类

ps：如果你使用反射，很遗憾，反射可以改变name和address的值，这里我们不考虑恶意改变，所以去除这种情况

测试代码如下

public static void main(String[] args) {Person p = new Person("Alice", "Alaska");System.out.println(p);;Class<Person> clazz = Person.class;try {Field feild = clazz.getDeclaredField("name");feild.setAccessible(true);feild.set(p, "Bobby");System.out.println(p);} catch (SecurityException e) {e.printStackTrace();} catch (NoSuchFieldException e) {e.printStackTrace();} catch (IllegalArgumentException e) {e.printStackTrace();} catch (IllegalAccessException e) {e.printStackTrace();}}

打印结果

Person [name:Alice address:Alaska]
Person [name:Bobby address:Alaska]

Immutable Pattern的参与者

一个字段值无法更改的类，也没有任何用来更改字段值的方法。当Immutable参与者的实例建立后，状态就完全不再变化

Immutable Pattern适用性

1.当实例产生后，状态不需要再改变时（原文为状态不再变化时，我觉得改成不需要再改变时会更好）

其实只将字段定义为private final并且没有set方法，也还是有可能是mutable类的，后面会给出例子，上面的Person确实是immutable的

2.实例需要共享，而且访问很频繁时

使用immutable类可以省去synchronized，性能会节省不少且不丧失安全性

标准类链接库里使用到的Immutable Pattern

下面只简单列举一些

java.lang.String

java.awt.Color

和基本类型的包装类

java.lang.Boolean

java.lang.Byte

java.lang.Character

java.lang.Double

java.lang.Float

java.lang.Integer

java.lang.Long

java.lang.Short

java.lang.Void

习题2.5

一个人设计的line，看看这个line是否为不可变类

public class Line {    private final Point startPoint;    private final Point endPoint;    public Line(int startx, int starty, int endx, int endy) {        this.startPoint = new Point(startx, starty);        this.endPoint = new Point(endx, endy);    }    public Line(Point startPoint, Point endPoint) {        this.startPoint = startPoint;        this.endPoint = endPoint;    }    public int getStartX() { return startPoint.getX(); }    public int getStartY() { return startPoint.getY(); }    public int getEndX() { return endPoint.getX(); }    public int getEndY() { return endPoint.getY(); }    public String toString() {        return "[ Line: " + startPoint + "-" + endPoint + " ]";    }}

Point类

public class Point {    public int x;    public int y;    public Point(int x, int y) {        this.x = x;        this.y = y;    }    public int getX() { return x; }    public int getY() { return y; }    public String toString() {        return "(" + x + "," + y + ")";    }}

这里我们先不考虑继承的问题，因为人家设计完了，没有其余的类了

那么看看这个line，所有字段都为private final，方法都是get并且返回int和String

我们来看看这个构造函数

public Line(Point startPoint, Point endPoint) {    this.startPoint = startPoint;    this.endPoint = endPoint;}

问题出在这个Point上

很容易看出，Point是可变的，line赋值之后Point改变了会怎样？很简单，line也被改变了

下面的代码证实了这点

public static void main(String[] args) {Point s = new Point(1, 2);Point e = new Point(3, 4);Line line = new Line(s, e);System.out.println(line);e.x = 5;System.out.println(line);}

打印结果

[ Line: (1,2)-(3,4) ]
[ Line: (1,2)-(5,4) ]

成对出现的mutable与immutable

如果有这样一个对象，它的一部分属性是不可变的另一部分是可变的，可以明显的区分出来，那么我们可以考虑将它拆分为两个类

一个为immutable另一个为mutable

比如String和StringBuffer

我们在java源码中可以看到

现在来看看下面两个成对出现的类，他们是否有安全问题

习题2.6

public final class ImmutablePerson {    private final String name;    private final String address;    public ImmutablePerson(String name, String address) {        this.name = name;        this.address = address;    }    public ImmutablePerson(MutablePerson person) {        this.name = person.getName();        this.address = person.getAddress();    }    public MutablePerson getMutablePerson() {        return new MutablePerson(this);    }    public String getName() {        return name;    }    public String getAddress() {        return address;    }    public String toString() {        return "[ ImmutablePerson: " + name + ", " + address + " ]";    }}

public final class MutablePerson {    private String name;    private String address;    public MutablePerson(String name, String address) {        this.name = name;        this.address = address;    }    public MutablePerson(ImmutablePerson person) {        this.name = person.getName();        this.address = person.getAddress();    }    public synchronized void setPerson(String newName, String newAddress) {        name = newName;        address = newAddress;    }    public synchronized ImmutablePerson getImmutablePerson() {        return new ImmutablePerson(this);    }    String getName() {    // Called only by ImmutablePerson        return name;    }    String getAddress() { // Called only by ImmutablePerson        return address;    }    public synchronized String toString() {        return "[ MutablePerson: " + name + ", " + address + " ]";    }}

题目很简单，和2.5基本一样

public ImmutablePerson(MutablePerson person) {    this.name = person.getName();    this.address = person.getAddress();}

解释也和2.5一样，那么如何修改

在执行这个方法的时候，MutablePerson可能会改变，如何被改变，可以通过setPerson，setPerson使用了synchronized关键字，意为获得this的锁，那么我们只需也获取这个对象的锁，就可以保证setPerson和public ImmutablePerson(MutablePerson person)不会交叉执行了

代码如下

public ImmutablePerson(MutablePerson person) {synchronized (person) {        this.name = person.getName();        this.address = person.getAddress();}}

这节内容较少，所以就不画图了