单例模式:确保一个类只有一个实例,并提供全局访问点.
1 饿汉式(线程安全)
package com.oo.singleton;
/**
* 饿汉式(线程安全)
*
* @author xyy
* @create 2017-06-15 16:25
**/
public class Singleton0 {
/**
* 在静态初始化的时候创建单件,确保了线程安全
*/
private static Singleton0 singleton0 = new Singleton0();
private Singleton0() {
}
/**
* 已经有实例的直接使用
* @return
*/
public static Singleton0 getInstance() {
return singleton0;
}
}
2.懒汉式(线程不安全)
package com.oo.singleton;
/**
* 懒汉式(线程不安全)
* @author xyy
* @create 2017-06-15 16:06
**/
public class Singleton1 {
/**
* 利用一个静态变量记录Singleton1的唯一实例
*/
private static Singleton1 singleton1;
/**
* 把构造器声明为私有的,只有SingLeon1的内部才可以调用构造器
*/
private Singleton1() {
}
public static Singleton1 getInstance() {
//null.表明还没有创建实例
if (singleton1 == null) {
singleton1 = new Singleton1();
}
//不为null,直接返回
return singleton1;
}
public static void main(String[] args) {
Singleton1 singleton1 = Singleton1.getInstance();
Singleton1 singleton2 = Singleton1.getInstance();
System.out.println(singleton1 == singleton2);
System.out.println(singleton1.equals(singleton2));
}
}
3.懒汉式(线程安全之synchronized关键字)
package com.oo.singleton;
/**
* 懒汉式(线程安全之synchronized关键字)
*
* @author xyy
* @create 2017-06-15 16:17
**/
public class Singleton2 {
private static Singleton2 singleton2;
private Singleton2() {
}
/**
* 1.降低性能
* 2.通过增加synchronized关键字,确保每个线程在进入这个方法之前.要等候别的线程离开这个方法
* 3.其实只有第一次执行这个方法才需要同步,以后再次调用就不需要了,同步是一个累赘
* @return
*/
public static synchronized Singleton2 getInstance() {
if (singleton2 == null) {
return new Singleton2();
}
return singleton2;
}
}
4.懒汉式(线程安全之双重检查锁)
package com.oo.singleton;
/**
* 懒汉式(线程安全之双重检查锁)
*不适用与1.4及其下版本
* @author xyy
* @create 2017-06-15 16:22
**/
public class Singleton3 {
/**
* volatile关键字singleton3被初始化后,多个线程正确的处理singleton3;
*/
private volatile static Singleton3 singleton3;
private Singleton3() {
}
/**
* 1.首先检查实例是否创建了,如果尚未创建,才进行同步,这样一来,只有第一次创建实例时会同步
*
* @return
*/
public static Singleton3 getInstance() {
//1.检查实例,如果不存在,就进入同步区块
if (singleton3 == null) {
//2.只有第一次才执行这里的代码
synchronized (Singleton3.class) {
//3.进入区块后,在检查一次,如果仍为空,创建实例
if (singleton3 == null) {
return new Singleton3();
}
}
}
return singleton3;
}
}
5.静态内部类实现单例(线程安全)
package com.oo.singleton;
/**
* 静态内部类实现单例(线程安全)
*
* @author xyy
* @create 2017-06-15 16:49
**/
public class Singleton4 {
/**
*1.类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例;
* 2.没有绑定关系，而且只有被调用到时才会装载，从而实现了延迟加载。
*/
private Singleton4() {
}
private static class SingletonHolder {
/**
* 静态初始化器，由JVM来保证线程安全
*/
private static Singleton4 singleton4 = new Singleton4();
public static Singleton4 getInstance() {
return SingletonHolder.singleton4;
}
}
public static void main(String[] args) {
/**
* 1.当getInstance方法第一次被调用的时候，它第一次读取SingletonHolder.instance，导致SingletonHolder类得到初始化；
* 2.而这个类在装载并被初始化的时候，会初始化它的静态域，从而创建Singleton的实例，
* 3.由于是静态的域，因此只会在虚拟机装载类的时候初始化一次，并由虚拟机来保证它的线程安全性
*/
Singleton4 singleton41 = Singleton4.SingletonHolder.getInstance();
Singleton4 singleton42 = Singleton4.SingletonHolder.getInstance();
System.out.println(singleton41 == singleton42);
System.out.println(singleton41.equals(singleton42));
}
}
6.单例和枚举
package com.oo.singleton;
/**
* 1.单例和枚举
* 2.参考(http://www.cnblogs.com/java-my-life/archive/2012/03/31/2425631.html)
* Created by 14258 on 2017/6/15.
*/
public enum Singleton5 {
/**
* 定义一个枚举的元素，它就代表了Singleton的一个实例。
*/
instance;
public void getInstance() {
//功能处理
}
public static void main(String[] args) {
}
}
参考:1.《JAVA与模式》之单例模式