Singleton

习题：

单例模式在日常编程中的优先级还是比较高的。具体的优点就是：1.减少资源生成销毁的开销；2.想到了古代中央集权的管理方法，统一权力，集中管理；3.防止出现多个实例去操作，导致丢失操作或者冲突死锁的问题。
其实只要在编写程序的时候确保只调用一次new MyClass()，就可以达到只生成一个实例的目的。但是如果不想要一直去注意这个，就需要：

确保任何情况下都绝对只有1个实例；
想在程序上表现出“只存在一个实例”

首先在Singleton类中定义了static修饰的singleton类的实例，初始化行为只会在类被加载时进行一次，保证了值实例化一次。
Singleton的构造函数是private修饰的，代表着其禁止从外部调用构造函数进行实例化对象。又是对于一次实例化的保证。
定义一个public修饰的获取实例，在被调用时返回唯一的一个实例对象。
```
 public static Singleton getInstance(){
     return singleton;
 }
```
在很多设计模式中，多数情况下也只会生成一个实例对象，例如：

AbstractFactory模式
Builder模式
Facade模式
Prototype模式
习题：

创建一个买票类，从1000开始卖，单例模式； ```java public class TicketMarket { private int ticket = 1000; private static TicketMarket singleton = new TicketMarket(); private TicketMarket(){

} public static TicketMarket getInstance(){
```
 return singleton;
```
} public synchronized int getNextTicketNumber(){
```
 return ticket++;
```
}

}


2. 创建一下Triple类，实现最多只能生成3个Triple类的实例，实例编号分别为1，2，3。
```java
public class Triple {
    private static Triple[] triples = new Triple[]{
            new Triple(0),
            new Triple(1),
            new Triple(2),
    };
    private int id;
    private Triple(int id){
        System.out.println("The instance"+id+"is create");
        this.id = id;
    }
    public static Triple getInstance(int id){
        return triples[id];
    }
    public String toString(){
        return "[Triple id="+id+"]";
    }
}

Singleton模式寻找问题。

public class Singleton_error {
 private static Singleton_error singletonError = null;
 private Singleton_error(){
     System.out.println("生成了一个实例对象");
 }
 public static  Singleton_error getInstance(){
     if(singletonError==null){
         singletonError = new Singleton_error();
     }
     return singletonError;
 }
}

public class Main extends Thread{
 public static void main(String[] args) {
     System.out.println("start");
     new Main("A").start();
     new Main("B").start();
     new Main("C").start();
     System.out.println("end");
 }
 public void run(){
     Singleton_error instance = Singleton_error.getInstance();
     System.out.println(getName()+":obj="+instance);
 }
 public Main(String name){
     super(name);
 }
}

这样做的时候会生成多个实例对象，而加入synchronized可以解决多个线程同时，同时判断的问题。

习题：