什么是Singleton?
- Singleton:在Java中即指单例设计模式,它是软件开发中最常用的设计模式之一。
- 单:唯一
- 例:实例
- 单例设计模式,即某个类在整个系统中只能有一个实例对象可被获取和使用的代码模式。
- 例如: 代码JVM运行环境的Runtime类
要点
- 一是,某个类只能有一个实例
构造器私有化 - 二是,它必须自行创建这个实例
含有一个该类的静态变量来保存这个唯一的实例 - 三是,它必须自行向整个系统提供这个实例;
对外提供获取该实例对象的方式:
① 直接暴露; ② 用静态变量的get方法获取
几种常见形式
饿汉式
直接创建对象,不存在线程安全问题
直接实例化饿汉式(简洁直观)
package com.single;
/**
* 饿汉式:
* 在类初始化时直接创建实例对象,不管你是否需要这个对象都会创建
*
*
* (1)、构造器私有化: private Singleton1() {}
* (2)、自行创建,并且用静态变量保存: static Singleton1 INSTANCE = new Singleton1();
* (3)、向外提供这个实例: public static Singleton1 INSTANCE = new Singleton1();
* (4)、强调这是一个单例,我们可以用final修改: public static final Singleton1 INSTANCE = new Singleton1();
* @author ouyang
*
*/
public class Singleton1 {
public static final Singleton1 INSTANCE = new Singleton1();
private Singleton1() {
}
}
测试
package com.single;
public class TestSingleton1 {
public static void main(String[] args) {
Singleton1 s1 = Singleton1.INSTANCE;
Singleton1 s2 = Singleton1.INSTANCE;
System.out.println(s1);
System.out.println(s2);
System.out.println(s1 == s2);
}
}
枚举式(最简洁)
枚举本身就是私有构造方法,并且重写了toString方法为变量名。
package com.single;
/**
* 饿汉式:
* 枚举类型:表示该类型的对象是有限的几个
* 我们可以限定为一个,就成了单例
*
* @author ouyang
*
*/
public enum Singleton2 {
INSTANCE
}
测试
package com.single;
public class TestSingleton2 {
public static void main(String[] args) {
Singleton2 s1 = Singleton2.INSTANCE;
Singleton2 s2 = Singleton2.INSTANCE;
System.out.println(s1);
System.out.println(s2);
System.out.println(s1 == s2);
}
}
静态代码块饿汉式(适合复杂实例化)
当实例对象创建需要参数,并且参数来自配置文件时。
创建一个配置文件 single.properties
注意文件在src下
#key=value
info=singleTest
package com.single;
import java.io.IOException;
import java.util.Properties;
/**
* 饿汉式:
* 静态代码块饿汉式(适合复杂实例化)
* @author ouyang
*
*/
public class Singleton3 {
public static final Singleton3 INSTANCE;
private String info;
static {
try {
Properties pro = new Properties();
pro.load(Singleton3.class.getClassLoader().getResourceAsStream("single.properties"));
INSTANCE = new Singleton3(pro.getProperty("info"));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
private Singleton3(String info) {
this.info = info;
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
@Override
public String toString() {
return "Singleton3 [info=" + info + "]";
}
}
测试
package com.single;
public class TestSingleton3 {
public static void main(String[] args) {
Singleton3 s1 = Singleton3.INSTANCE;
Singleton3 s2 = Singleton3.INSTANCE;
System.out.println(s1);
System.out.println(s2);
System.out.println(s1 == s2);
}
}
懒汉式
线程不安全(适用于单线程)
package com.single;
/**
* 懒汉式:
* 线程不安全(适用于单线程)
*
* (1)、构造器私有化: private Singleton4() {}
* (2)、用静态变量保存这个唯一的实例: private static Singleton4 instance;
* (3)、提供一个静态方法,获取这个实例对象:
* public static Singleton4 getInstance() {
* if(instance == null) {
* instance = new Singleton4();
* }
* return instance;
* }
*
*
* @author ouyang
*
*/
public class Singleton4 {
private static Singleton4 instance;
private Singleton4(){
}
public static Singleton4 getInstance() {
if(instance == null) {
//为了看效果,线程休眠100毫秒
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
instance = new Singleton4();
}
return instance;
}
}
测试
package com.single;
public class TestSingleton4 {
public static void main(String[] args) {
Singleton4 s1 = Singleton4.getInstance();
Singleton4 s2 = Singleton4.getInstance();
System.out.println(s1);
System.out.println(s2);
System.out.println(s1 == s2);
}
}
如果是多线程呢?
package com.single;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class TestSingleton4 {
public static void main(String[] args) throws InterruptedException, ExecutionException {
Callable<Singleton4> c = new Callable<Singleton4>() {
@Override
public Singleton4 call() throws Exception {
return Singleton4.getInstance();
}
};
//线程池
ExecutorService es = Executors.newFixedThreadPool(2);
Future<Singleton4> f1 = es.submit(c);
Future<Singleton4> f2 = es.submit(c);
Singleton4 s1 = f1.get();
Singleton4 s2 = f2.get();
System.out.println(s1);
System.out.println(s2);
System.out.println(s1 == s2);
}
}
线程安全(适用于多线程)
package com.single;
/**
* 懒汉式:
* 线程安全(适用于多线程)
*
* @author ouyang
*
*/
public class Singleton5 {
private static Singleton5 instance;
private Singleton5(){
}
public static Singleton5 getInstance() {
//为了性能多判断一次
if(instance == null) {
synchronized (Singleton5.class) {
if(instance == null) {
//为了看效果,线程休眠100毫秒
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
instance = new Singleton5();
}
}
}
return instance;
}
}
测试
package com.single;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class TestSingleton5 {
public static void main(String[] args) throws InterruptedException, ExecutionException {
Callable<Singleton5> c = new Callable<Singleton5>() {
@Override
public Singleton5 call() throws Exception {
return Singleton5.getInstance();
}
};
//线程池
ExecutorService es = Executors.newFixedThreadPool(2);
Future<Singleton5> f1 = es.submit(c);
Future<Singleton5> f2 = es.submit(c);
Singleton5 s1 = f1.get();
Singleton5 s2 = f2.get();
System.out.println(s1);
System.out.println(s2);
System.out.println(s1 == s2);
}
}
静态内部类形式(适用于多线程)
package com.single;
/**
* 懒汉式:
* 静态内部类形式(适用于多线程)
* 在内部类被加载和初始化时,才创建INSTANCE实例对象
* 因为静态内部类不会自动随着外部类的加载和初始化而初始化,它是要单独去加载和初始化的。
* 因为是在内部类加载和初始化时,才创建,因此是线程安全的。
* @author john
*
*/
public class Singleton6 {
private Singleton6() {
}
private static class Inner{
private static final Singleton6 INSTANCE = new Singleton6();
}
public static Singleton6 getInstance() {
return Inner.INSTANCE;
}
}
测试
package com.single;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class TestSingleton6 {
public static void main(String[] args) throws InterruptedException, ExecutionException {
Callable<Singleton6> c = new Callable<Singleton6>() {
@Override
public Singleton6 call() throws Exception {
return Singleton6.getInstance();
}
};
//线程池
ExecutorService es = Executors.newFixedThreadPool(2);
Future<Singleton6> f1 = es.submit(c);
Future<Singleton6> f2 = es.submit(c);
Singleton6 s1 = f1.get();
Singleton6 s2 = f2.get();
System.out.println(s1);
System.out.println(s2);
System.out.println(s1 == s2);
}
}