安全发布对象

发布对象：

import com.example.annoations.NotThreadSafe;
import lombok.extern.slf4j.Slf4j;
import java.util.Arrays;

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

    public static void main(String[] args) {
        UnsafePublish unsafePublish=new UnsafePublish();
        log.info("{}", Arrays.toString(unsafePublish.getStates()));

        unsafePublish.getStates()[0]="d";
        log.info("{}",Arrays.toString(unsafePublish.getStates()));
    }
}

　　

import com.example.annoations.NotRecommend;
import com.example.annoations.NotThreadSafe;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@NotThreadSafe
@NotRecommend
public class Escape {
      public int thisCanBeEscape=0;
      public Escape(){
       new InnerClass();
      }
      private class InnerClass{
          public InnerClass(){
              log.info("{}",Escape.this.thisCanBeEscape);
        }
    }

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

　　安全发布对象：

import com.example.annoations.NotThreadSafe;

//懒汉模式，单例的实例在第一次使用的时候进行创建
@NotThreadSafe
public class SingletonExample1 {
    //私有的构造函数
    private SingletonExample1 (){

    }
    //单例对象
    private static  SingletonExample1 instance=null;
    //静态的工厂方法
    public static SingletonExample1 getInstance(){
        if(instance==null){
            instance=new SingletonExample1();
        }
        return instance;
    }
}

　　

import com.example.annoations.ThreadSafe;

//恶汉模式，单例实例在类装载使用时创建
@ThreadSafe
public class SingletonExample2 {
    //私有构造函数
    private SingletonExample2(){

    }
    //单例对象
    private static SingletonExample2 instance=new SingletonExample2();
    //静态的工厂方法
    public static SingletonExample2 getInstance(){
        return instance;
    }
}

　　

//懒汉模式，单例的实例在第一次使用的时候进行创建
@NotThreadSafe
public class SingletonExample3 {
    //私有的构造函数
    private SingletonExample3 (){

    }
    //单例对象
    private static  SingletonExample3 instance=null;
    //静态的工厂方法
    public static synchronized SingletonExample3 getInstance(){
        if(instance==null){
            instance=new SingletonExample3();
        }
        return instance;
    }
}

　　线程不安全

import com.example.annoations.NotThreadSafe;

//懒汉模式，双重同步锁的单例模式，单例的实例在第一次使用的时候进行创建
@NotThreadSafe
public class SingletonExample4 {
    //私有的构造函数
    private SingletonExample4 (){

    }
    //1.memory=allocate(),分配内存空间
    //2.ctorInstance()初始对象
    //3.instance=memory 设置instance指向刚分配的内存

    //JVM和cpu优化，发生了指令重拍
    //1.memory=allocate(),分配内存空间
    //3.instance=memory 设置instance指向刚分配的内存
    //2.ctorInstance()初始对象
    //单例对象
    private static  SingletonExample4 instance=null;
    //静态的工厂方法
    public static  SingletonExample4 getInstance(){
        if(instance==null){//双重检测机制
            synchronized (SingletonExample4.class){  //同步锁
                if(instance==null){  //多线程发生指令重拍
                    instance=new SingletonExample4();
                }
            }
        }
        return instance;
    }
}

　　volatile+双重检测，线程安全

import com.example.annoations.ThreadSafe;

@ThreadSafe
public class SingletonExample5 {
    //私有的构造函数
    private SingletonExample5(){

    }

    //单例对象  volatile+双重检测机制
    private volatile  static  SingletonExample5 instance=null;
    //静态的工厂方法
    public static  SingletonExample5 getInstance(){
        if(instance==null){//双重检测机制
            synchronized (SingletonExample5.class){  //同步锁
                if(instance==null){  //多线程发生指令重拍
                    instance=new SingletonExample5();
                }
            }
        }
        return instance;
    }
}

　　

//饿汉模式
public class SingletonExample6 {
    //私有构造函数
    private SingletonExample6(){

    }
    //单例对象
    private static  SingletonExample6 instance=null;
    static  {
        instance=new SingletonExample6();
    }

    //静态工厂的方法
    public static SingletonExample6 getInstance(){
        return instance;
    }

    public static void main(String[] args) {
        System.out.println(getInstance().hashCode());
        System.out.println(getInstance().hashCode());
    }
}

　　

import com.example.annoations.ThreadSafe;

//枚举模式  最安全
@ThreadSafe
public class SingletonExample7 {
    //私有构造函数
    private SingletonExample7(){

    }
    public static SingletonExample7 getInstance(){
        return Singleton.INSTANCE.getInstance();
    }
    public enum Singleton{
        INSTANCE;
        //构造函数JVM保证这个方法只能被调用一次
        private SingletonExample7 singleton;
        Singleton(){
            singleton=new SingletonExample7();
        }
        public SingletonExample7 getInstance(){
            return singleton;
        }
    }
}

　　

import com.example.annoations.NotThreadSafe;
import com.google.common.collect.Maps;
import lombok.extern.slf4j.Slf4j;
import java.util.Map;

@Slf4j
@NotThreadSafe
public class ImmutableExample1{
    private final static Integer a=1;
    private final static String b="2";
    private final static Map<Integer,Integer> map = Maps.newHashMap();
    static {
        map.put(1,2);
        map.put(3,4);
        map.put(5,6);
    }
   //值可修改
    public static void main(String[] args) {
        map.put(1,3);
        log.info("{}",map.get(1));
    }
    private void test(final int a){
       // a=1;
    }
}

　另外的不可变对象　

import com.example.annoations.ThreadSafe;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;

@ThreadSafe  //线程安全
public class ImmutableExample3 {
    private final static ImmutableList list=ImmutableList.of(1,2,3);

    private final static ImmutableSet set=ImmutableSet.copyOf(list);

    private final static ImmutableMap<Integer,Integer> map=ImmutableMap.of(1,2,3,4);
    private final  static  ImmutableMap<Integer,Integer> map2=
    ImmutableMap.<Integer,Integer>builder().put(3,4).put(5,6).build();
    public static void main(String[] args) {
        list.add(4);
        map.put(1,4);
        System.out.println(map2.get(2));
    }
}

　　

import com.google.common.collect.Maps;
import java.util.Collections;
import java.util.Map;

public class ImmutableExample2 {
    private  static Map<Integer,Integer> map = Maps.newHashMap();
    static {
        map.put(1,2);
        map.put(3,4);
        map.put(5,6);
        map= Collections.unmodifiableMap(map);
    }
    //值可修改
    public static void main(String[] args) {
        map.put(1,3);
        log.info("{}",map.get(1));
    }
}