Java学习笔记，设计模式篇

1.饿汉式单例设计模式

//饿汉式单例设计模式，不存在线程安全问题
public final class Singleton {
    private static Singleton INSTANCE = new Singleton();
    private Singleton(){};
    public static Singleton getInstance()
    {
        return INSTANCE;
    }
}

饿汉模式在类被初始化时就已经在内存中创建了对象，以空间换时间，故不存在线程安全问题。

2.懒汉式单例设计模式

//懒汉式单例设计模式，存在线程安全问题，因此加上了synchronized，但是锁粒度较大
public final class Singleton {
    private static Singleton INSTANCE = null;
    private Singleton(){};
    public static synchronized Singleton getInstance()
    {
        if(INSTANCE != null)
        {
            return INSTANCE;
        }
        INSTANCE = new Singleton();
        return INSTANCE;
    }
}

3.双重校验锁懒汉式单例设计模式

//双重校验懒汉设计模式，解决线程安全问题，防止创建多个线程，用volatile是防止指令重排。
public final class Singleton {
    private volatile static Singleton INSTANCE = null;
    private Singleton(){};
    public static Singleton getInstance()
    {
        if(INSTANCE == null)
        {
            synchronized (Singleton.class)
            {
                if(INSTANCE == null)
                {
                    INSTANCE = new Singleton();
                }
            }
        }
        return INSTANCE;
    }
}

第一个if语句，用来确认调用getInstance()时instance是否为空，如果不为空即已经创建，则直接返回，如果为空，那么就需要创建实例，于是进入synchronized同步块。
第二个if语句，当第一个线程获得锁之后，其他线程也完成了第一个if判断在锁外等待。然后第一个线程创建对象后，被阻塞的线程被唤醒获得锁后，进行第二次if判断，从而避免再次创建对象。

4.同步模式之保护性暂停

//保护性暂停，用一个线程等待另一个线程执行的结果
public class Guarded {
    private Object response;
    private final Object lock = new Object();
    public Object get()
    {
        synchronized (lock)
        {
            while (response == null)
            {
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return response;
        }
    }
    public Object complete(Object response)
    {
        synchronized (lock)
        {
            this.response = response;
            lock.notifyAll();
        }
        return response;
    }
}

    即 Guarded Suspension，用在一个线程等待另一个线程的执行结果。要点：

    1）有一个结果需要从一个线程传递到另一个线程，让他们关联同一个 GuardedObject

    2）如果有结果不断从一个线程到另一个线程那么可以使用消息队列（见生产者/消费者）

    3）JDK 中，join 的实现、Future 的实现，采用的就是此模式

    4）因为要等待另一方的结果，因此归类到同步模式

5.生产者消费者模式

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class Source
{
    private int num = 0;
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    public void produce(){
        lock.lock();
        try {
            while(num != 0)
            {
                condition.await();
            }
            num++;
            System.out.println(Thread.currentThread().getName() + '\t' + num);
            condition.signalAll();;
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally {
            lock.unlock();
        }
    }
    public void consume()
    {
        lock.lock();
        try {
            while(num == 0)
            {
                condition.await();
            }
            num--;
            System.out.println(Thread.currentThread().getName() + '\t' + num);
            condition.signalAll();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally {
            lock.unlock();
        }
    }
}
public class ProConDemo {
    public static void main(String[] args) {
        Source source = new Source();
        new Thread(()->{
            for(int i = 0;i < 5;i++)
            {
                try {
                    source.consume();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },"t1").start();
        new Thread(() -> {
            for(int i = 0;i < 5;i++)
            {
                try {
                    source.produce();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },"t2").start();
    }
}