本文深入讲解Java单例模式的各种实现方式，包括饿汉式、懒汉式、DCL模式等，探讨HashMap、ConcurrentHashMap、HashTable的区别，解析垃圾回收机制、Java新特性，以及多线程、序列化、事务处理等核心概念。
1.写出几种常见的单例实现
单例模式的关键点
-
构造方法不对外开放,为private
-
确保单例类只有一个对象,尤其是多线程模式下
-
通过静态方法或枚举返回单例对象
-
确保单例类在反序列化是不会重新创建新的对象
饿汉式，懒汉式，DCL模式，静态内部类实现单例模式,枚举实现单例模式,使用容器实现单例,
①饿汉式
public class Singleton1{
private static Singleton1 instance =new Singleton1();
private Singleton1{
}
public Singleton1 getInstance(){
return instance;
}
}
②懒汉式
public class Singleton2{
private static Singleton2 instance;
private Singleton2{
}
public static synchronized Singleton2 getIntance(){
if(instance==null){
instance= new Singleton2();
}
return instance;
}
}
懒汉式缺点：即使instance已经被创建，但是每次调用getIntance方法还是会发生同步，浪费资源。
③DCL模式
public class Singleton3{
private static Singleton3 instance;
private Singleton2{
}
public static Singleton3 getIntance(){
if(instance==null){
synchronized(Singleton3.class){
if(instance==null){
instance= new Singleton2();
}
}
}
return instance;
}
}
DCL优点：资源利用率高，效率高
缺点：第一次加载慢，由于Java处理器允许乱序执行，偶尔会失败
④静态内部类
public class Singleton4{
private Singleton4{
}
public Singleton4 getIntance(){
return SinglentonHolder.instance;
}
private static class SinglentonHolder{
private static Singleton4 instance =new Singleton4();
}
}
当第一次加载Singleton类时并不会初始化SINGLRTON,只有第一次调用getInstance方法的时候才会初始化SINGLETON 第一次调用getInstance 方法的时候虚拟机才会加载SingletonHoder类,这种方式不仅能够保证线程安全,也能够保证对象的唯一，还延迟了单例化，推荐使用这种方法。
⑥枚举
public enum SingletonEnum{
instance;
}
最为简单的。
⑦容器实现单例
public class Singleton5 {
/**
* 将多种类型的单例放到统一的Map将集合中,根据相应的Key获取对应的对象
*
* 这种方式是我们可以管理多种类型的单例,可以使用统一接口进行获取操作
* 降低了使用成本,也隐藏了具体实现,降低了耦合度
*/
public static Map<String, Object> objMap = new HashMap<String, Object>();
private Singleton5() {
}
public static void registerInstance(String key, Object instance) {
if (!objMap.containsKey(key)) {
objMap.put(key, instance);
}
}
public static Object getInstance(String key) {
return objMap.get(key);
}
}
反序列化会重新生成对象的问题
已上几种方法里面 枚举任何一种情况都是单例,不存在这个问题,容器模式只是承载单例的容器所以它本身也不存在这个问题,只有其他三种方式种存在这个反序列话的问题,怎么解决呢?加入如下代码
// 防止反序列化获取多个对象的漏洞
// 实现Serializable接口，当从I/O流中读取对象时，readResolve()方法都会被调用到
//用readResolve()中返回的对象直接替换在反序列化过程中创建的对象
private Singleton4 readResolve() throws ObjectStreamException {
return SingletonHolder.SINGLETON;
}
2.HashMap、ConcurrentHashMap、HashTable相关
答：HashMap:它是一个基于哈希表实习的，每一个元素都是一个键值对，他是数组+链表的结构，当容量不足时（达到了阀值），就会扩容。默认初始容量为16,加载因子为0.75f,，默认扩容一倍，是一个线程不安全的映射。建和值可以为Null,它实现了Serializable接口 可以序列化，还实现了cloneable接口可以被克隆。
HashMap的存储过程：它的内部有维护了一个Entry数组，并且以链表的形式解决冲突问题，每一个Entry数组都是单链表。当添加一个键值对的时候，他会先使用hash方法计算hash值，然后通过indexfor方法计算出它的存储位置，这个计算方法是先使用hash&0x7FFFFFFF,然后在对leath取模，这保证每一个都能存入HashMap中，当存储位置相同时，由于存的是一个链表，则把这个键值对插入链表头，如果键值对重复则不存储。key为null的键值对永远都放在以table[0]为头结点的链表中。
HashTable,也是一个机遇哈希表实现的，每一个元素也是一个键值对，他是数组+链表的结构，当容量不足时（达到了阀值），也会扩容。默认初始容量为11，加载因子为0.75f，每次扩容都是在原有的基础上增加一倍再加一，是一个线程安全的映射。键和值不可以为Null,它同样实现了Serializable接口 可以实例化，也实现了cloneable接口，可以被克隆。
ConcurrentHashMap 和HashTable 都是用于多线程的，但是当数据过大时，因为HashTable中锁的整个哈map，所以很长时间都是被锁的时间，性能急剧下降。而ConcurrentHashMap 很好的解决了这个问题，紧紧锁定的map的某个部分，而其它的线程不需要等到迭代完成才能访问map。
3.垃圾分代回收机制
答：垃圾回收机制主要是对堆内存的。
当对象不在使用，或使用完的时候，在某一个时期会被GC回收。
Java程序启动的时候，GC就同时启动并时刻监视着堆内存，当堆内存使用达到0.75的临界值时，GC就会将一些无用的对象回收。
堆内存被分为新生代和老生代，新生代又被分为伊甸园区和幸存区，当对象被加载时，会被放到新生代，开启扫描，当发现对象不再使用，就会被回收，如还在使用就被移入幸存区，再次扫描发现对象不再使用，就会被回收，多次扫描发现还被引用，就被移入老生代，再次扫描，不再使用，就被回收。若还在使用，则存留到老生代。新生代的扫描率大于老生代，达到4:1这样的比率。回收老生代的对象可能会导致系统崩溃。
如果新的对象大于伊甸园区，就会被直接放入老生代，如比老生代还大就会报错。
4. 1.5、1.7和1.8 Java 新特性
1.5新特性：自动装箱/拆箱 增强for循环 静态导入 可变参数 枚举 泛型 反射（Jdk 1.4出现，1.5增强）动态代理 内省 注解
1.7新特性：1.二进制：0b010，2.整数使用_进行分位：1_000_015，3.switch_case中允许使用String，4.异常的分组：|，5.泛型的推导：<>，6.try(){}catch(){}
1.8新特性:Lambda表达式,函数式接口,方法引用和构造器调用,Stream API,接口中的默认方法和静态方法,新时间日期API
5.多线程相关
背：http://www.importnew.com/12773.html
6.final, finally, finalize 的区别
final:final是修饰符，来修饰类，成员变量，成员方法的。用final修饰的类是不能够被继承的，而且里面的所有的方法都不能被重写，都不能同时使用abstract和final修饰。因为抽象类的是有其子类的和final相反；用final修饰的方法是不能够被重写的，但是子类可以使用父类中的final修饰的方法；用final修饰的成员变量，如果是基本类型的，则值不能够被改变，如果成员变量是引用类型，那么它只能指向初始化时指向的那个对象，不能再指向别的对象，但是对象中的内容是允许改变的。
finally：finally是在异常处理时提供finally块来执行任何清除操作。不管有没有异常被抛出、捕获都会被执行。try块中的内容是在无异常时执行到结束。catch块中的内容，是在try块内容发生catch所声明的异常时，跳转到catch块中执行。finally块则是无论异常是否发生都会执行finally块的内容，所以在代码逻辑中有需要无论发生什么都必须执行的代码，可以放在finally块中。
finalize:finalize是方法名，java技术允许使用finalize（）方法在垃圾收集器将对象从内存中清楚出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的，它是在Object类中定义的，因此所有的类都继承了它。子类覆盖finalize（）方法以整理系统资源或者执行其他清理工作。finalize（）方法是在垃圾收集器删除对象之前对这个对象调用的。
7.序列化
什么是序列化？什么是反序列化？
答：序列化：把对象转换为字节序列的过程称为对象的序列化。
反序列化：把字节序列恢复为对象的过程称为对象的反序列化。
什么情况下需要序列化？
答：当你想把内存中的对象状态保存到一个文件或者数据库中的时候；
当你想利用套间字在网络上传送对象的时候，
当你想通过RMI传输 对象的时候；
如何实现序列化?
答：实现Serializable接口即可
注意：transient 修饰的属性是不会被序列化的，静态static的属性也不序列化
serialVersionUID如果不设置，Java会自动添加，但是反序列化时Java再次自动生成，两个UID不一致会报错。 所以必须设置private static final long serialVersionUID = 1L；这个数字是可以随机的，但是写1L比较简单，L必须大写。
8 事物
什么是事物？
事物就是访问数据库的一个操作序列，数据库应用系统根据事物集来完成对数据库的存取
事物必须服从ACID原则，也就是原子性，一致性，隔离性，和持久性
原子性：要么所有事物都执行完，要么都不执行，执行了一班儿出错，需要回滚操作。
一致性：事物的执行是使数据库从一种正确状态转变为另一种正确状态
隔离性：事物在正确提交之前，不给其他用户访问
持久性：事物提交后，结果永久保存在数据库中，就算事物提交后，机器故障了，也会把处理的结果保存。
事物的作用
事物对于企业管理至关重要，它保证了用户每一次操作都是可靠的，即使出现了异常情况，也要保证数据的完整性。比如ATM机,事物保证了用户和银行的利益不受损失
并发下，事物的问题：
有以下几个问题：
脏读：就是A读到了B还没提交的事物，比如ATM机取钱，A开启了事物，此时B也开启了事物，并取走了100元，但是还没有提交，A此时读到了数据，因为事物未提交，余额还是原来的数据。
不可重复读： 在一次开始事物后，读取数据了两次，但两次读取数据不一致， 比如A开启了事物，查询了一次余额为1000，B此时也开启了事物，并取走了100，然后事物提交了，此时A有查询了一次，发现余额为900，发送了不可重复读。
幻读：在一次事物中发现了未被操作的数据。A开启事物，修改一些信息，此时B也开启事物，并添加了一条信息，此时A提交事物发现出现了自己没有操作的数据。
利用数据隔离级别解决以上问题，事物隔离级别越高，并发下问题就会越少，但相反性能消耗也就越大，所以需要在性能和并发性之间做一个权衡。
隔离级别
1.default(spring)
如果Spring配置事物时将isolation设置为这个值的话，那么将使用底层数据库的默认事物隔离级别
2.read uncommited
读未提交，即能够读取到没有被提交的数据，所以很明显这个级别的隔离机制无法解决脏读、不可重复读、幻读中的任何一种，因此很少使用
3.read commited
读已提交，即能够读到那些已经提交的数据，自然能够防止脏读，但是无法限制不可重复读和幻读
4.repeatable read
重复读取，即在数据读出来之后加锁，类似"select * from XXX for
update"，明确数据读取出来就是为了更新用的，所以要加一把锁，防止别人修改它。REPEATABLE_READ的意思也类似，读取了一条数据，这个事物不结束，别的事物就不可以改这条记录，这样就解决了脏读、不可重复读的问题，但是幻读的问题还是无法解决
5.serializable
串行化，最高的事物隔离级别，不管多少事物，挨个运行完一个事物的所有子事物之后才可以执行另外一个事物里面的所有子事物，这样就解决了脏读、不可重复读和幻读的问题了
不是事物隔离级别设置得越高越好，事物隔离级别设置得越高，意味着势必要花手段去加锁用以保证事物的正确性，那么效率就要降低，因此实际开发中往往要在效率和并发正确性之间做一个取舍，一般情况下会设置为READ_COMMITED，此时避免了脏读，并发性也还不错，之后再通过一些别的手段去解决不可重复读和幻读的问题就好了。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
