public class UnsafePublish {
    private String[] states = {"a","b","c"};
    public String[] getStates(){
        return states;
    }

    /**
     * 通过new UnsafePublish()发布了一个UnsafePublish类的实例
     * 通过实例的public方法得到了私有域states数组的引用
     * 可以在其他任何线程里修改这个数组里的值
     * 这样在其他线程中想使用states数组时，它的值是不完全确定的
     * 因此这样发布的对象是线程不安全的，因为无法保证是否有其他线程对数组里的值进行了修改
     * @param args
     */
    public static void main(String[] args) {
        UnsafePublish unsafePublish = new UnsafePublish();
        for (String i : unsafePublish.getStates()) {
            System.out.print(i+" ");
        }
        unsafePublish.getStates()[0] = "d";
        System.out.println();
        for (String i : unsafePublish.getStates()) {
            System.out.print(i+" ");
        }
    }
}

@NotThreadSafe
public class Escape {
    private int thisCanBeEscape = 0;
    public Escape(){
        new InnerClass();
    }

    /**
     * 内部类的实例里面包含了对封装内容thisCanBeEscape的隐含引用
     * 这样在对象没有被正确构造之前，他就会被发布，有可能有不安全的因素在
     * 一个导致this引用在构造期间逸出的错误   是在构造的函数过程中启动了一个线程
     * 无论是隐式的启动还是显示地启动都会造成this引用的逸出，新线程总是会在对象构造完毕
     * 之前就已经看到this引用    所以要再构造函数中使用线程，就不要启动它而应该专有的start或初始化的方法来统一启动线程，
     * 可以采用工厂方法和私有构造函数来完成对象创建和监听器的注册等
     *
     *
     * 在对象未完成构造之前   不可以将其发布
     */
    private class InnerClass{
        public InnerClass(){
            System.out.println(Escape.this.thisCanBeEscape);
        }
    }

    public static void main(String[] args) {
        new Escape();
    }
}

public class Client {
    public Holder holder;
    
    public void initialize(){
        holder = new Holder(42);//这个代码不是原子的
    }
}

public class Holder {
    int n;
    public Holder(int n) {
        this.n = n;
    }
    public void assertSanity() {
        if(n != n)
             throw new AssertionError("This statement is false.");
    }
}

/**
    在Client类中，Holder对象被发布了，但是这是一个不正确的发布。由于可见性问题，其他线程看到的Holder对象将处于不一致的状态，即使在该对象的构成构函数中已经正确的该构建了不变性条件，这种不正确的发布导致其他线程看到尚未创建完成的对象。主要是Holder对象的创建不是原子性的，可能还未构造完成，其他线程就开始调用Holder对象。

    由于没有使用同步的方法来却确保Holder对象（包含引用和对象状态都没有）对其他线程可见，因此将Holder成为未正确发布。问题不在于Holder本身，而是其没有正确的发布。上面没有正确发布的可能导致的问题：

    别的线程对于holder字段，可能会看到过时的值，这样就会    导致空引用，或者是过时的值（即使holder已经被设置了）（引用本身没有被别的线程看到）

    更可怕的是，对于已经更新holder，及时能够看到引用的更新，但是对于对象的状态，看到的却可能是旧值，对于上面的代码，可能会抛出AssertionError异常

    主要是holder = new Holder(42);这个代码不是原子性的，可能在构造未完成时，其他线程就会调用holder对象引用，从而导致不可预测的结果。
*/

public class EventListener { 
    public EventListener(EventSource eventSource) { 
        // do our initialization ... 
        // register ourselves with the event source 
        eventSource.registerListener(this); 
    } 
    public onEvent(Event e) { // handle the event } 
} 
public class RecordingEventListener extends EventListener { 
    private final ArrayList list; 
    public RecordingEventListener(EventSource eventSource) { 
        super(eventSource); 
        list = Collections.synchronizedList(new ArrayList()); 
    } 
    public onEvent(Event e) { 
        list.add(e); 
        super.onEvent(e); 
    } 
    public Event[] getEvents() { 
        return (Event[]) list.toArray(new Event[0]); 
    }  
} 

public class EventListener2 { 
    public EventListener2(EventSource eventSource) { eventSource.registerListener( 
            new EventListener() { 
                public onEvent(Event e) { 
                    eventReceived(e); 
                } 
     }); 
    } 
    public eventReceived(Event e) { } 
} 
同样也是子类化问题

/**

   不变性： 某个对象在被创建后其状态就不能被修改，那么这个对象就称为不可变对象，不可变对象一定是线程安全的。不可变对象很简单。他们只有一种状态，并且该状态由构造函数来控制。

　　当满足以下条件时，对象才是不可变的：

　　　　1)对象创建以后其状态就不能改变；

　　　　2)对象的所有域都是final类型；

　　　　3)对象是正确创造的(在对象创建期间，this引用没有溢出)。

（1）Java中存在三种对象
   a）不变对象：对象状态创建后不能再修改，对象的所有域为final，对象是正确构造的
   b）基本不变对象：不满足不变对象的约束，但是初始化后不再变化
   c）可变对象：不满足上述不变对象和基本不变对象的约束

（2）安全发布技术
   a）即确保对象引用和状态对其他线程正确可见
   b）方式
      静态初始化器初始化对象引用
      将引用存储到volatile域
      将引用存储到正确创建对象的final域
      将引用存储到由锁正确保护的域

（3）三种对象安全发布方式
   a）不变对象：任何形式机制发布
   b）基本不变对象：保证安全发布即可
   c）可变对象：不仅要保证安全发布，而且要确保对象状态的正确改变（即用锁或其他方式，保证对象状态的正确改变）

　　通常，要发布一个静态构造的对象，最简单和最安全的方式是使用静态初始化器： public static Holder = new Holder(42);

　　静态初始化器由JVM在类的初始化阶段执行，由于JVM内部存在同步机制，所以这种方式初始化对象都可以被安全的发布。

　　对于可变对象，安全的发布之时确保在发布当时状态的可见性，而在随后的每次对象的访问时，同样需要使用同步来确保修改操作的可见性。（状态可见性+同步）

**/