单例模式、观察者模式、生产者消费者模式

一、单例模式

单例模式是实际项目中使用最多的一种设计模式，有着非常广泛的使用场景，单例模式能够保证整个应用中有且只有一个实例。

1.懒汉模式

import java.util.HashMap;
import java.util.Map;

public class Singleton {
    private static Singleton instance;
    private Singleton() {      
    }
    public static Singleton getInstance() {
        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

2.饿汉模式

import java.util.HashMap;
import java.util.Map;

public class Singleton {
    private static Singleton instance = new Singleton();
    private Singleton() {
        
    }
    public static synchronized Singleton getInstance() {
        return instance;
    }
}

饿汉模式与懒汉模式相比较起来，一上来就直接将实例初始化，不存在延迟加载的问题。 

---

以上两种都不能保证线程安全，当多个线程去调用getInstance的时候，同样会生成多个多个实例。

3.双重锁校验(double checked locking pattern)

public class Singleton {

    private static Singleton instance;

    private Singleton() {}

    public static  Singleton getInstance() {
        if(instance == null) {
            synchronized(Singleton.class) {
                if(instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

双重检验，一次在同步块外，一次在同步块内

这样可以避免两个线程同时进入同步块内，生成多个实例。

4.禁止指令重排优化的双重校验锁

尽管双重检验所可以解决多线程访问问题，但是他还是存在指令重排的问题。

在instance = new Singleton(); 中，并不是一个原子操作，在JVM中实际上它会完成以下的操作：

1.给instance分配内存

2.调用构造方法初始化成员变量

3.将instance指向分配的空间（此时instance就不为Null了）

由于不是原子操作，因此2/3可能会调换顺序。则在 3 执行完毕、2 未执行之前，被线程二抢占了，这时 instance 已经是非 null 了（但却没有初始化），所以线程二会直接返回 instance，然后使用，然后顺理成章地报错。

public class Singleton {

    private volatile static Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if(instance == null) {
            synchronized(Singleton.class) {
                if(instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

二、工厂模式

使用户不必关心类的实例化过程，而可以直接使用它。

三、观察者模式

定义对象之间一对多的依赖，当一个对象更新时，他的所有依赖都会得到通知并自动更新。

增加代码的可拓展性

四、生产者消费者模式

生产者和消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通信，而是通过阻塞队列来进行通信。相当于一个缓冲区，平衡了生产者和消费者的处理能力。

-》线程池的处理用到类似的功能，任务到来时先交给corePoolSize的消费者线程去处理，处理不完交给阻塞队列，队列满了才使用普通线程。

/**
 * 生产者和消费者，wait()和notify()的实现
 * @author ZGJ
 * @date 2017年6月22日
 */
public class Test1 {
    private static Integer count = 0;
    private static final Integer FULL = 10;
    private static String LOCK = "lock";
    
    public static void main(String[] args) {
        Test1 test1 = new Test1();
        new Thread(test1.new Producer()).start();
        new Thread(test1.new Consumer()).start();
        new Thread(test1.new Producer()).start();
        new Thread(test1.new Consumer()).start();
        new Thread(test1.new Producer()).start();
        new Thread(test1.new Consumer()).start();
        new Thread(test1.new Producer()).start();
        new Thread(test1.new Consumer()).start();
    }
    class Producer implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(3000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                synchronized (LOCK) {
                    while (count == FULL) {
                        try {
                            LOCK.wait();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                    count++;
                    System.out.println(Thread.currentThread().getName() + "生产者生产，目前总共有" + count);
                    LOCK.notifyAll();
                }
            }
        }
    }
    class Consumer implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (LOCK) {
                    while (count == 0) {
                        try {
                            LOCK.wait();
                        } catch (Exception e) {
                        }
                    }
                    count--;
                    System.out.println(Thread.currentThread().getName() + "消费者消费，目前总共有" + count);
                    LOCK.notifyAll();
                }
            }
        }
    }
}

结果:

Thread-0生产者生产，目前总共有1
Thread-4生产者生产，目前总共有2
Thread-3消费者消费，目前总共有1
Thread-1消费者消费，目前总共有0
Thread-2生产者生产，目前总共有1
Thread-6生产者生产，目前总共有2
Thread-7消费者消费，目前总共有1
Thread-5消费者消费，目前总共有0
Thread-0生产者生产，目前总共有1
Thread-4生产者生产，目前总共有2
Thread-3消费者消费，目前总共有1
Thread-6生产者生产，目前总共有2
Thread-1消费者消费，目前总共有1
Thread-7消费者消费，目前总共有0
Thread-2生产者生产，目前总共有1
Thread-5消费者消费，目前总共有0
Thread-0生产者生产，目前总共有1
Thread-4生产者生产，目前总共有2
Thread-3消费者消费，目前总共有1
Thread-7消费者消费，目前总共有0
Thread-6生产者生产，目前总共有1
Thread-2生产者生产，目前总共有2
Thread-1消费者消费，目前总共有1
Thread-5消费者消费，目前总共有0
Thread-0生产者生产，目前总共有1
Thread-4生产者生产，目前总共有2
Thread-3消费者消费，目前总共有1
Thread-1消费者消费，目前总共有0
Thread-6生产者生产，目前总共有1
Thread-7消费者消费，目前总共有0
Thread-2生产者生产，目前总共有1