**
单例模式:
**
在Java开发过程中单例模式是一种简单常见的设计模式。单例模式确保某个类只有一个实例,而且自行实例化并向整个系统提供这个实例。在计算机系统中,线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。
单例所具备的特点:
- 1.私有化的构造函数
2. 私有的静态的全局变量
3. 公有的静态的方法
4. 单例类必须自己创建自己的唯一实例。
5.单例类只能有一个实例。
8.单例类必须给所有其他对象提供这一实例。
实现单例模式的方式
1.饿汉模式:
/**
* 饿汉式单例--初始化立即加载
*/
public class Singleton01 {
//私有化的构造函数
private Singleton01(){}
//私有化的静态全局变量
private static int value = 0;
//自己创建对象
private static final Singleton01 ONLY
= new Singleton01();
//公有静态工厂方法
public static Singleton01 getInstance(){
return ONLY;
}
public int getValue() {
return value;
}
public void setValue(int value) {
Singleton01.value = value;
}
}
测试代码:
public class Test {
public static void main(String[] args) {
Singleton01 a = Singleton01.getInstance();
Singleton01 b = Singleton01.getInstance();
System.out.println("判断a和b的地址是否相同:"+a.equals(b));
a.setValue(5);
System.out.println("输出中b的value:"+b.getValue());
}
}
2.懒汉模式:
/**
* 懒汉式单例--延时加载
*/
public class Singleton02 {
//私有化的构造函数
private Singleton02(){}
//私有化的静态全局变量
private static int value = 0;
//自己创建对象
private static Singleton02 ONLY;
//公有静态工厂方法
public static Singleton02 getInstance(){
if(ONLY==null){
ONLY = new Singleton02();
}
return ONLY;
}
public int getValue() {
return value;
}
public void setValue(int value) {
Singleton02.value = value;
}
}
测试代码:
public class Test {
public static void main(String[] args) {
Singleton02 a = Singleton02.getInstance();
Singleton02 b = Singleton02.getInstance();
System.out.println("判断a和b的地址是否相同:"+a.equals(b));
a.setValue(5);
System.out.println("输出中b的value:"+b.getValue());
}
}
3.使用synchronized同步锁
/**
* 懒汉式单例--延时加载
*/
public class Singleton03 {
//私有化的构造函数
private Singleton03(){}
//私有化的静态全局变量
private static int value = 0;
//自己创建对象
private static Singleton03 ONLY;
//加锁的公有静态工厂方法
synchronized public static Singleton03 getInstance(){
if(ONLY==null){
ONLY = new Singleton03();
}
return ONLY;
}
public int getValue() {
return value;
}
public void setValue(int value) {
Singleton03.value = value;
}
}
- 在方法上加synchronized同步锁或是用同步代码块对类加同步锁,此种方式虽然解决了多个实例对象问题,但是该方式运行效率却很低下,下一个线程想要获取对象,就必须等待上一个线程释放锁之后,才可以继续运行。
4.懒汉式双重检查:
public class Singleton04 {
// 私有构造 private Singleton04() {}
private static Singleton4 ONLY;
// 双重检查 public static Singleton04
getInstance() {
if (ONLY == null) {
synchronized (Singleton04.class) {
if (ONLY == null) {
ONLY = new Singleton04();
}
}
}
return ONLY; } }
- 使用双重检查进一步做了优化,可以避免整个方法被锁,只对需要锁的代码部分加锁,可以提高执行效率。