单例模式是非常常用的设计模式，他确保了一个类只有一个对象，并且这个对象是自己创建的，外界可以获取使用到这个对象。
单例模式一般有两种：懒汉式，饿汉式（其实还有一种登记式，把创建的对象放在map集合中，有就直接用，没有就创建）
单例模式通过构造方法私有化，外界无法创建对象，下面是两种单例的实现
饿汉式：
package demo_singleton;
public class SingletonHungry {
private static SingletonHungry singletonhunary = new SingletonHungry();
public static SingletonHungry getinstance() {
return singletonhunary;
}
private SingletonHungry() {
}
}
懒汉式：
package demo_singleton;
/*懒汉式的单例模式，有线程安全问题，当多线程访问的时候，会出现多个实例*/
public class SingletonLazy {
private static SingletonLazy instance = null;
public static SingletonLazy getInstance() {
if (instance == null) {
instance = new SingletonLazy();
}
return instance;
}
private SingletonLazy() {
}
}
多线程环境下的测试：
懒汉式测试：
package demo_singleton;
public class TestLary extends Thread{
public static void main(String[] args) {
TestLary t1 = new TestLary();
TestLary t2 = new TestLary();
TestLary t3 = new TestLary();
t1.start();
t2.start();
t3.start();
}
public void run() {
System.out.println(SingletonLazy.getInstance());
}
}
输出结果：
demo_singleton.SingletonLazy@529e3fc2 demo_singleton.SingletonLazy@529e3fc2 demo_singleton.SingletonLazy@136c03ee
通过输出结果可以看到，其实创建了两个对象
饿汉式测试：
package demo_singleton;
public class TestHungry extends Thread {
public static void main(String[] args) {
TestHungry t1 = new TestHungry();
TestHungry t2 = new TestHungry();
TestHungry t3 = new TestHungry();
t1.start();
t2.start();
t3.start();
}
@Override
public void run() {
System.out.println(SingletonHungry.getinstance());
}
}
输出结果：
demo_singleton.SingletonHungry@6d15a113 demo_singleton.SingletonHungry@6d15a113 demo_singleton.SingletonHungry@6d15a113在多线程下饿汉式没有出现问题
在单线程的环境下，单例可以实现，当在多线程的条件下，懒汉式的单例就会出现线程安全问题，而饿汉式不会出现。饿汉式代码简单所以线程安全，在类加载的时候创建对象，懒汉式不会再在载的时候创建对象，效率高。代码中有判断对象是否存在的代码，所以线程不安全饿汉式不需要关注多线程问题，写法简单，但是有个缺点，就是不管你用或者不用，在类加载的时候他都会创建对象，而懒汉式的特点是延时加载，但是又带来了线程问题。既然这样我们就要解决它
开始解决懒汉式的问题，最开始想到的是同步，加上synchronized关键字：
优化一：
package demo_singleton;
public class SingletonLazy1 {
private static SingletonLazy1 instance1 = null;
public static synchronized SingletonLazy1 getInstance() {
if (instance1 == null) {
instance1 = new SingletonLazy1();
}
return instance1;
}
private SingletonLazy1() {
}
}
优化二：
加入同步块，对代码进行操作
package demo_singleton;
/*加同步块的单例，效率有问题*/
public class SingletonLazy2 {
private static SingletonLazy2 instance2 = null;
public static SingletonLazy2 getInstance() {
synchronized (SingletonLazy2.class) {
if (instance2 == null) {
instance2 = new SingletonLazy2();
}
}
return instance2;
}
private SingletonLazy2() {
}
}
优化三：
package demo_singleton;
public class SingletonLazy3 {
private static SingletonLazy3 instace3 = null;
public static SingletonLazy3 getInstance() {
if (instace3 == null) {
synchronized (SingletonLazy3.class) {
if (instace3 == null) {
instace3 = new SingletonLazy3();
}
}
}
return instace3;
}
private SingletonLazy3() {
}
}
相对于前两个优化，利用同步解决线程问题，第三个利用两个判断，当程序判断对象没有创建的时候进入执行同步代码块，创建对象。在下次判断对象存在的时候，不会再执行同步代码块中的代码，相对于前两个效率会搞一些
优化四：
package demo_singleton;
public class SingletonLazy4 {
private static SingletonLazy4 instance4 = null;
static{
instance4 = new SingletonLazy4();
}
public static SingletonLazy4 getInstance() {
return instance4;
}
private SingletonLazy4() {
}
}
利用static静态代码块的特点，创建对象，static代码块在类加载的时候最开始执行并且只会执行一次
优化五：
package demo_singleton;
public class SingletonLazy5 {
private static class Sing {
private static SingletonLazy5 instance = new SingletonLazy5();
}
public static SingletonLazy5 getInstance() {
return Sing.instance;
}
private SingletonLazy5() {
}
}
利用静态内部类，内部类在编译的时候也是一个单独的class文件，在调用的时候会执行，不调用的时候不会执行
注意：利用Java的反射机制也是可以破坏单例的