多线程设计模式 -- immutable

对象

      //类定义为 final
      public final class Person {
	//类变量定义为 final
         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;
	}

         //name ,address  是不能修改的,所在多线程下安全的
	public String toString() {
		return "[ Person: name = " + name + ", address = " + address + " ]";
	}
}

线程

public class PrintPersonThread extends Thread {
	private Person person;

	public PrintPersonThread(Person person) {
		this.person = person;
	}

	public void run() {
		while (true) {
		    //将调用Person 的toString 方法 
                          //当多线程情况Person的name,address是final的 不能被修改所以是线程安全
                      System.out.println(Thread.currentThread().getName() + " prints "
					+ person);
		}
	}
}

public class Main {
    public static void main(String[] args) {
        Person alice = new Person("Alice", "Alaska");
        new PrintPersonThread(alice).start();
        new PrintPersonThread(alice ).start();
        new PrintPersonThread(alice ).start();
    }
}

用final标示比使用锁块和syschronized效率要好
同时 Integer ,等一些基本类型的包装类 都是使用immutable 模式

你写的东西和多线程有什么关系?

在多线程下保护共享资源(Person 对象)不被修改.

这个Person资源只能被访问，而不能被修改，在多线程环境下意义不大！

1.当实例产生后,不再改变时
2.实例需要共享,而且访问很频繁时

典型的静态资源，连锁都不需要，这样的资源与多线程几乎没什么关系！

表面上看这个模式的确是这样的.
Person这个类生成实例后是无法更改的.因为没有提供相关Set方法.类变量又是 private final 的.类也是 final 不会产生子类.
所以在多程线下这个这个类绝对安全.
假设我在Person类中删除类变量 final 标示,然后加上类变量了相关Set 方法,那么你说在多线程这个类还是安全的吗.答案肯定是不安全的.因为我们可以利用set 方法改变类变量的属性.

如果你有一个共享的实例,实例化后又不需要改变他了.那么设置类变量是final让他们不能修改.所以这样方法也就不用同步等待,提高执行效率.

包括我本人对这个例子也有一点疑惑.所以找了一个有说服的文章,如下:

不变模式(Immutable Pattern)顾名思义,它的状态在它的生命周期内是永恒的(晕,永恒的日月星晨,对象如人,
太渺小,谈不上永恒!),不会改变的.对于其中的不变类(Immutable Class),它的实例可以在运行期间保持状态永远不会被
改变,所以不需要采取共享互斥机制来保护,如果运用得当可以节省大量的时间成本.

请注意上面这段话,不变模式其中的不变类,说明不变类只是不变模式中一个组成部分,不变类和与之相辅的可变
类,以及它们之间的关系才共同构成不变模式!所以在涉及不变模式的时候一定要研究一个类是不变的还是可变的(Mutable).
在jdk中的String类和StringBuffer类就组成了一个不变模式.

还是先看具体的例子:

final class Dog{
    private final String name;
    private final int age;
    public Dog(String name,int age){
        this.name = name;
        this.age = age;
    }
    
    public String getName(){return this.name;}
    public int getAge(){return this.age;}
    
    public String toString(){
        return "Dog's name = " + this.name + ",age = " + this.age;
    }
}

1.Dog类本身被声明为final,可以保证它本身的状态不会被子类扩展方法所改变.
2.Dog类的所有成员变量都是final的,保证它在构造后不会被重新赋值.而且Dog类所有属性是private的,只提供getter访问.
3.Dog类的能传入的参数本身是Immutable的.这一点非常重要将在下面具体说明.
以上条件都是必要条件,而不是充要条件.

class DisplayDog extends Thread{
    private Dog dog;
    public DisplayDog(Dog dog){
        this.dog = dog;
    }
    
    public void run(){
        while(true){
            System.out.println(this.getName() + " display: " + dog);
        }
    }
}

DisplayDog类是把一个Dog对象传入后,不断显示这个dog的属性.我们会同时用多个线程来显示同一dog对象,看看它们在共享
同一对象时对象的状态:

public class Test {
    public static void main(String[] args) throws Exception {
        Dog dog = new Dog("Sager",100);
        new DisplayDog(dog).start();
        new DisplayDog(dog).start();
        new DisplayDog(dog).start();
    }
}

运行这个例子你可以等上一个月,虽然运行一年都正常并不能说明第366天不出现异常,但我们可以把这样的结果认为是一种
说明.多个线程共享一个不变类的实例时,这个实例的状态不会发生改变.事实上它没有地方让你去改变.
在临界区模式中有些操作必须只允许有一个线程操作,而这个类本身以及对它的访问类中并不需要进行临界区保护,这就让多
个线程不必等待从而提高了性能.

既然有这么好的优势,那我们在需要临界区保护的对象为什么不都设计成不变类呢?

1.不变类设计起来有一定难度.对于上面这个用来示例的Dog,由于其本身的属性,方法都很简单,我们还可以充分地考虑到可
以改变它状态的各种情况.但对于复杂的类,要保证它的不变性,是一个非常吃力的工作.

不变类中,任何一个必要都件都不是充要条件,虽然连老骨灰都没有这么说过,但我还是要真诚地目光深邃语气凝重地告诉你.
没有任何条件是充要条件的意思就是如果任何一个必要条件你没考虑到,那它就会无法保证类的不可变性.没有规范,没有模
板,完全看一人设计人员的经验和水平.也许你自以为考虑很全面的一个"不变类"在其他高手面前轻而易举地就"可变"了.

2.不变类的种种必要条件限制了类设计的全面性,灵活性.这点不用多说,简单说因为是不变类,所以你不能A,因为是不变类,你
不能B.

当然,如果你是一人很有经验的设计者,你能成功地设计一个不变类,但因为它的限制而失去一些功能,你就要以使用与之相辅
的可变类.并且它们之间可以相互转换,在需要不变性操作的时候以不变类提供给用户,在需要可变性操作的时候以可变类提供
给用户.

在jdk中String被设计为不可变类,一旦生成一个String对象,它的所有属性就不会被变,任何方法要么返回这个对象本身的原
始状态,要么抛弃原来的字符串返回一个新字符串,而绝对不会返回被修改了的字符串对象.
但是很多时候返回新字符串抛弃原来的字符串对象这样的操作太浪费资源了.特别是在循环地操作的时候:

String s = "Axman";
 for(int i=0;i<1000*1000;i++) s += "x";这样的操作是致命的.

那么这种时候需要将原始的不变的s包装成可变的StringBuffer来操作,性能的改变可能是成千上万倍:

      

 StringBuffer sb = new StringBuffer(s); //将不变的String包装成可变的String;
        for(int i=0;i<1000*1000;i++)
            sb.append("x");
        s = new String(sb); //将可变类封装成不变类.虽然可以调用toString(),但那不是可变到不变的转换.

在将可变类封装到不变类的时候要特别小心.因为你传入的引用在外面是可以被修改的.所以即使你不变类本身不能去改变属
性但属性有一个外部引用.可以在外面修改:

final class MutableDog{
    private String name;
    private int age;
    public MutableDog(String name,int age){
        this.name = name;
        this.age = age;
    }
    public synchronized void setDog(String name,int age){
        this.name = name;
        this.age = age;
    }
    public String getName(){return this.name;}
    public int getAge(){return this.age;}

    public synchronized String toString(){
        return "Dog's name = " + this.name + ",age = " + this.age;
    }
    
     public synchronized ImmatableDog getImmatableDog(){
         return new ImmatableDog(this);
     }
}

final class ImmatableDog{
    private final String name;
    private final int age;
    public ImmatableDog(String name,int age){
        this.name = name;
        this.age = age;
    }
    
    public ImmatableDog(MutableDog dog){
        this.name = dog.getName();
        this.age = dog.getAge();
    }    
    
    public String getName(){return this.name;}
    public int getAge(){return this.age;}
    
    public String toString(){
        return "Dog's name = " + this.name + ",age = " + this.age;
    }
}

MutableDog类是可变的,可以满足我们利用对象的缓冲来让对象成为表示另一个实体的功能.但它们之间
随时可以根据需要相互转换,但是我们发现:
  

 public ImmatableDog(MutableDog dog){
        this.name = dog.getName();
        this.age = dog.getAge();
    }

这个方法是不安全的.当一个属性为"Sager",100的dog被传进来后,执行this.name = dog.getName();后,
如果线程切换到其它线程执行,那么dog的属性就可能是"p4",80,这时再执行this.age = dog.getAge();
我们就会得到一个属性为"Sager",80的这样一个错误的不可变对象.这是一个非常危险的陷井.在这里我们
可以通过同上来解决:
  

 public ImmatableDog(MutableDog dog){
        synchronized(dog){
            this.name = dog.getName();
            this.age = dog.getAge();
        }
    }

注意这里同步的MutableDog,它将会和MutableDog的setDog产生互斥.它们都需要获取同一MutableDog对象的
锁,如果MutableDog的setDog不是方法同步(synchronized(this)),即使ImmatableDog(MutableDog dog)中同步
了dog,也不能保证安全,它们需要在同一对象上互斥.

但同步也并不一定能保证传入的参数不可变:

我曾以下面这个例子来作为对一个Java程序员的终极测试,终极测试的意思是说,如果你不懂并不说明你水平
差,但如何你懂这个问题那就没有必要测试其它问题了.

   

public static void test(Object[] objs){
        java.security.BasicPermission bp  =  xxxxx;

        for(Object o: objs){
            bp.checkGuard(o);
        }
        for(Object o: abjs){
            o.xxx;
        }
    }

当一个数据被传入后我们需要对其中的每个元素做安全性检查,如果通不过bp.checkGuard(o);自己会抛出
异常的.但如果objs[0]被bp.checkGuard(o);过后,外面的线程通过objs去修改objs[0],这时就会把一个没有
经过安全检查的对象绕过bp.checkGuard(o);而直接被调用.假如Runtime.exec(String[] args)就是这样实
现我们可以想象会出现什么问题.

所以对于这样的传入参数,我们可以将其在方法类复制为本地变量(数组).或使用它的深度clone,打断与方法
外的联系:

  

 public static void test(Object[] objs){
 Object tmp = new Object[objs.lenth];
 System.arrayCopy(objs,tmp,0,0,objs.lenth);
 java.security.BasicPermission bp  =  xxxxx;

        for(Object o: tmp){
            bp.checkGuard(o);
        }
        for(Object o: tmp){
            o.xxx;
        }
    }

呵呵 你没理解为什么这里用final关键字的。lz.主要是可见性问题，和有没有setter无关的

说明转载哦
http://dev.csdn.net/author/axman/6f0a40330ab349b7915a8247c0f9c3cc.html

另：他这里说的不变模式的定义也是一家之言吧。。。
看看java与模式中关于不变模式的定义：不变模式只涉及到一个类，一个类的内部创建之后，在整个生命周期都不会发生变化时，这样的类就是不变类，这种使用不变类的做法就是不变模式。当然他说的强不变模式就是你这里第一个帖子中涉及的person类。

运动设计模式 - 三轮

三轮车比支着车踢子的自行车在运动中稳定性要好