1、说说常见的设计模式有哪些？
单例模式、工厂模式、代理模式、观察者模式、装饰器模式、适配器模式等
2、什么是单例模式
简单来说，单列模式是为了保证某个对象在程序的生命周期内，在内存中只存在一个实例。即一个类只有一个对象。
它提供了全局访问的方法。
3、为什么要用单例模式？
① 节省内存资源
② 节省时间（分配对象的时间）
4、单例模式的实现方式
饿汉、懒汉、双重检验锁、静态内部类、枚举
5、手写一个单例模式(结合你的面试时间，写双重检验锁可以延伸出更多问题的提问)
对并发熟悉，可以
写双重检验锁，这样就有更多的面试提问点了
也可以写饿汉式
要求懒加载，也写静态内部类
/* 双重检验锁 */
public class Singleton{
private Singleton(){}//构造器私有化，防止new，导致多个实例
private static volatile Singleton singleton;
public static Singleton getInstance(){//向外暴露一个静态的公共方法 getInstance
//第一层检查
if(singleton == null){
//同步代码块
synchronized (Singleton.class){
//第二层检查
if(singleton == null) {
singleton = new Singleton();
}
}
}
return singleton;
}
}
--------------------------------------------------------------------------------------------
/**
* 饿汉式
*/
public class Singleton{
private static final Singleton singleton = new Singleton();//饿汉式，初始化时就创建好了实例[使用了final常量-->饿汉式(静态常量)]
private Singleton(){}//构造器私有化，防止new，导致多个实例
public static Singleton getInstance(){//向外暴露一个静态的公共方法 getInstance
return singleton;
}
}
--------------------------------------------------------------------------------------------
/**
* 饿汉式
*/
public class Singleton{
private Singleton(){}//构造器私有化，防止new，导致多个实例
/**
* 静态内部类,在其内部以静态常量的方式实例化对象
*/
private static class SingletonInstance{
private static final Singleton singleton = new Singleton();//常量静态属性，实例化对象[初始化]
}
public static Singleton getInstance(){//向外暴露一个静态的公共方法 getInstance
return SingletonInstance.singleton;
}
}
双重检验锁
☆ volatile 关键字，可深入到Java VM内存相关
☆ synchronized 关键字，可深入到Java锁机制，高并发相关
☆ new 关键字，可深入到Java VM类加载机制相关
★ 你写的这个程序是怎么保证线程安全的？
首先构造器私有化， 向外暴露一个静态的公共方法 getSingleton，来向系统提供对象实例。
getSingleton 方法 首先先判断实例是否存在，存在直接返回；不存在加 synchronized 锁，为了进一步判断实例是否已经存在，需要再次进行非空判断，判断为null，不存在实例，再创建实例。
★ synchronized起到了什么作用？
锁定对象，限制当前对象只能被一个线程访问。
★ synchronized里你传Singleton.class这个参数，起到什么作用，换成别的行不行？
对当前类加锁，使得这个代码块一次只能被一个线程访问。
可以换成别的，这里Singleton.class可以换成一个常量字符串或者自己定义一个内部静态Object。
★ 那传Singleton.class，常量字符串，自己定义一个内部静态Object有区别吗？
没啥区别，因为这是一个静态方法，相当于是类锁。类锁（全局锁）对应的就是可以锁在该类的class可以锁在classloader对象上。
类锁是所有线程共享的锁，所以同一时刻，只能有一个线程使用加了锁的方法或方法体，不管是不是同一个实例。
★ volatile 起到了什么作用？
加volatile，是为了 禁止指令重排 。
在执行new 创建单例对象[ singleton = new Singleton();]，
指令1分配对象内存空间；指令2初始化对象；指令3设置singleton 引用指向分配好的对象内存空间；
由于指令重排的优化， 可能初始化的指令还没有执行，就先执行了设置引用指向分配好对象的内存空间的指令了。
- 在单线程环境下是没有问题的，但在多线程环境下会出现问题：另外一个线程会看到一个还没有被初始化的对象
★ 为什么要进行两次非空检查？
保证线程安全，假设有两个线程同时到达 synchronized 语句块，那么实例化代码只会由其中先抢到锁的线程执行一次，
而后抢到锁的线程会在第二个 if 判断中发现 singleton 不为 null，所以跳过创建实例的语句。
再后面的其他线程再来调用 getInstance 方法时，只需判断第一次的 if (singleton == null) ，然后会跳过整个if块，直接return实例化后的对象。
双重检查：
- 实现：线程安全，延迟加载、效率也更高
★ 那你知道synchronized关键字实现同步的原理吗？
synchronized在Java虚拟机中使用监视器锁来实现。每个对象都有一个监视器锁，当监视器锁被占用时就会处于锁定状态。
线程执行一条叫monitorenter的指令来获取监视器锁的所有权。如果此监视器锁的进入数为0，则线程进入并将进入数设置为1，成为线程所有者。如果线程已经拥有该锁，因为是可重入锁，可以重新进入，则进入数加1.如果线程的监视器锁被其他线程占用，则阻塞直到此监视器锁的进入数为0时才能进入该锁。
线程执行一条叫monitorexit的指令来释放所有权。执行monitorexit的必须是线程的所有者。每次执行此指令，线程进入数减1，直到进入数为0。监视器锁被释放。
★ 你刚才提到的可重入锁是什么概念，有不可重入锁吗？
我说的可重入锁是广义的可重入锁，当然jdk1.5引入了concurrent包，里面有Lock接口，它有一个实现叫ReentrantLock。广义的可重入锁也叫递归锁，是指同一线程外层函数获得锁之后，内层还可以再次获得此锁。可重入锁的设计是为了避免死锁。sun的corba里的mutex互斥锁是一种不可重入锁的实现。自旋锁也是一种不可重入锁，本质上是一种忙等锁，CPU一直循环执行"测试并设置"直到可用并取得该锁，在递归的调用该锁时必然会引起死锁。另外，如果锁占用时间较长，自旋锁会过多的占用CPU资源，这时使用基于睡眠原理来实现的锁更加合适。
★ 你刚才提到了concurrent包，它里面有哪些锁的实现？
常用的有ReentrantLock,它是一种独占锁。ReadWriteLock接口也是一个锁接口，和Lock接口是一种关联关系，它返回一个只读的Lock和只写的Lock。读写分离，在没有写锁的情况下，读锁是无阻塞的，提高了执行效率，它是一种共享锁。ReadWriteLock的实现类为ReentrantReadWriteLock。ReentrantLock和ReentrantReadWriteLock实现都依赖于AbstractQueuedSynchronizer这种抽象队列同步器。