使用java写一个简单的借口 用java写一个singleton

java面试：写一个单例Singleton实例
1.什么是singleton？

• Singleton：在Java中是指单例设计模式，他是软件开发中最常见的设计模式之一
• 单例设计模式：即某个类在整个系统中只能有一个实例对象可被获取和使用的代码模式。

2.要点

• 一是某个类只能有一个实例；
  构造器私有化
• 二是他必须自行创建这个实例；
  含有一个该类的静态变量来保存这个唯一实例
• 三是他必须自行向整个系统提供这个实例；
  对外提供获取该实例对象的方式：
  1.直接暴露
  2.用静态变量的get方法获取

3.饿汉式：直接创建对象，不存在线程安全问题
3.1直接实例化饿汉式（简洁直观）

/**
 * 
 * 饿汉式
 * 	在类初始化时直接创建实例对象，不管你是否需要这个对象，都会创建
 * 	不存在线程安全问题
 *
 * 	直接实例化饿汉式（简洁直观）
 * 
 * （1）构造器私有化
 * （2）自行创建，并且使用静态变量保存
 * （3）向外提供这个实例
 * （4）强调这是一个单例，我们可以用final修饰
 */
public class Singleton1 {
	//自行创建，并且使用静态变量保存
	//强调这是一个单例，我们可以用final修饰
	//向外提供这个实例		public
	public static final Singleton1 INSTANCE=new Singleton1();
	//构造器私有化
	private Singleton1() {
		
	}
}

测试方法：

public class TestSingleton1 {
	public static void main(String[] args) {
		Singleton1 s=Singleton1.INSTANCE;
		System.out.println(s);
	}

}

3.2枚举式（最简洁）

/**
 *
 * 枚举式（最简洁）
 *
 * 枚举类型：表示该类型的对象是有限的几个
 * 我们可以限定为一个，就成了单例
 *
 */
public enum Singleton2 {
	INSTANCE
}

测试方法：

public class TestSingleton2 {
	public static void main(String[] args) {
		Singleton2 s=Singleton2.INSTANCE;
		System.out.println(s);
	}

}

3.3静态代码块饿汉式（适合复杂实例化）

/**
 * 
 * 饿汉式
 * 	在类初始化时直接创建实例对象，不管你是否需要这个对象，都会创建
 *
 *
 * 	静态代码块饿汉式（适合复杂实例化）
 * 
 * 
 * （1）构造器私有化
 * （2）自行创建，并且使用静态变量保存
 * （3）向外提供这个实例
 * （4）强调这是一个单例，我们可以用final修饰
 */
public class Singleton3 {
	//自行创建，并且使用静态变量保存
	//强调这是一个单例，我们可以用final修饰
	//向外提供这个实例		public
	public static final Singleton3 INSTANCE;
	private String info;
	static {

		try {
			Properties properties = new Properties();
			properties.load(Singleton3.class.getClassLoader().getResourceAsStream("single.properties"));
			INSTANCE = new Singleton3(properties.getProperty("info"));
		} catch (IOException e) {
			throw new RuntimeException(e);
		}

	}
	//构造器私有化
	private Singleton3(String info) {
		this.info=info;
	}

	@Override
	public String toString() {
		return "Singleton3{" +
				"info='" + info + '\'' +
				'}';
	}

	public String getInfo() {
		return info;
	}

	public void setInfo(String info) {
		this.info = info;
	}
}

测试方法：

public class TestSingleton3 {
	public static void main(String[] args) {
		Singleton3 s=Singleton3.INSTANCE;
		System.out.println(s);
	}

}

4.懒汉式：延迟创建对象
4.1线程不安全（适用于单线程）

/**
 * 懒汉式：
 *  延迟创建这个实例对象
 *
 *  存在线程安全问题----适合于单线程
 *
 *  （1）构造器私有化
 *  （2）用一个静态变量保存这个唯一实例
 *  （3）提供一个静态方法，获取这个实例对象
 */
public class Singleton4 {

    //（2）用一个静态变量保存这个唯一实例
    private static Singleton4 instance;

    //（1）构造器私有化
    private Singleton4(){

    }

    //（3）提供一个静态方法，获取这个实例对象
    public static Singleton4 getInstance(){
        if (instance==null){
            //休眠100ms
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            instance=new Singleton4();
        }
        return instance;
    }

}

测试方法：

public class TestSingleton4 {
	public static void main(String[] args) throws ExecutionException, InterruptedException {
//		Singleton4 s1=Singleton4.getInstance();
//		Singleton4 s2=Singleton4.getInstance();
//
//		System.out.println(s1==s2);
//		System.out.println(s1);
//		System.out.println(s2);

		//测试线程安全问题
		//匿名内部类
		Callable<Singleton4> c = new Callable<Singleton4>(){

			@Override
			public Singleton4 call() throws Exception {
				return Singleton4.getInstance();
			}
		};
		//创建两个线程的线程池
		ExecutorService es = Executors.newFixedThreadPool(2);
		Future<Singleton4> f1 = es.submit(c);
		Future<Singleton4> f2 = es.submit(c);

		Singleton4 s1 = f1.get();
		Singleton4 s2 = f2.get();

		System.out.println(s1==s2);
		System.out.println(s1);
		System.out.println(s2);
		//关闭线程
		es.shutdown();

	}

}

4.2线程安全（适用于多线程）

/**
 * 懒汉式：
 *  延迟创建这个实例对象
 *
 *  线程安全----适合于多线程
 *
 *  （1）构造器私有化
 *  （2）用一个静态变量保存这个唯一实例
 *  （3）提供一个静态方法，获取这个实例对象
 */
public class Singleton5 {

    //（2）用一个静态变量保存这个唯一实例
    private static Singleton5 instance;

    //（1）构造器私有化
    private Singleton5(){

    }

    //（3）提供一个静态方法，获取这个实例对象
    public static Singleton5 getInstance(){
        //提高性能
        if (instance==null) {
            //同步
            synchronized (Singleton5.class) {
                if (instance == null) {
                    //休眠100ms
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    instance = new Singleton5();
                }
            }
        }
        return instance;
    }

}

测试方法：

public class TestSingleton5 {
	public static void main(String[] args) throws ExecutionException, InterruptedException {
		//匿名内部类
		Callable<Singleton5> c = new Callable<Singleton5>(){

			@Override
			public Singleton5 call() throws Exception {
				return Singleton5.getInstance();
			}
		};
		//创建两个线程的线程池
		ExecutorService es = Executors.newFixedThreadPool(2);
		Future<Singleton5> f1 = es.submit(c);
		Future<Singleton5> f2 = es.submit(c);

		Singleton5 s1 = f1.get();
		Singleton5 s2 = f2.get();

		System.out.println(s1==s2);
		System.out.println(s1);
		System.out.println(s2);
		//关闭线程
		es.shutdown();

	}

}

4.3静态内部类形式（适用于多线程）

/**
 * 在内部类被加载和初始化时，才创建INGLETON实例对象
 * 静态内部类不会随着外部类的加载和初始化而初始化，它是单独去加载和初始化的。
 * 因为是在内部类加载和初始化时，创建的，因此时线程安全的
 */
public class Singleton6 {

    private Singleton6(){

    }

    private static class Inner{
        private static final Singleton6 INGLETON=new Singleton6();
    }

    public static Singleton6 getInstance(){
        return Inner.INGLETON;
    }

}