设计模式是什么
设计模式(Design Pattern)是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。
为什么要使用设计模式
提高代码可重用性、让代码更容易被他人理解、保证代码的可读性。也是软件工程的基石,设计模式也是一种思想,使用任何一门面向对象的语言。目前共有23种设计模式。
单例模式解决的问题是什么: 保证类的对象在内存中唯一
步骤:
1.私有化该类的构造函数
2.通过new在本类中创建一个本类对象。
3.定义一个共有的方法将创建的对象返回。
单例模式具体两种实现,分别是饿汉模式、懒汉模式。
饿汉模式
/**
* @Classname Singleton1
* @Description 单例模式-饿汉模式
* @Created by xiangty
* 1. 私有化类的构造方法
* 2. 创建本类的对象实例
* 3. 定义一个公共的方法将创建的对象返回
*/
public class Singleton1 {
// 1. 私有化类的构造方法
private Singleton1() {
}
// 2. 创建本类的对象实例
private static Singleton1 singleton1 = new Singleton1();
// 3. 定义一个公共的方法将创建的对象返回
public static Singleton1 getInstance() {
return singleton1;
}
}
懒汉模式
/**
* @Classname Singleton2
* @Description 单例模式-懒汉模式
* @Created by xiangty
* 1. 私有化类的构造方法
* 2. 定义一个类的对象
* 3. 定义一个公共方法将创建的对象返回
*/
public class Singleton2 {
// 1. 私有化类的构造方法
private Singleton2() {
}
// 2. 定义一个类的对象
private static Singleton2 singleton2 = null;
// 3. 定义一个公共方法将创建的对象返回
public static Singleton2 getInstance() {
if (singleton2 == null) {
singleton2 = new Singleton2();
}
return singleton2;
}
}
测试
/**
* @Classname SingletonTest
* @Description 单例模式验证
* @Date 2019/5/11 23:20
* @Created by xiangty
*/
public class SingletonTest {
public static void main(String[] args) {
method1();
method2();
}
/**
* 验证饿汉模式
*/
public static void method1(){
Singleton1 singleton1 = Singleton1.getInstance();
Singleton1 singleton2 = Singleton1.getInstance();
if(singleton1 == singleton2){
System.out.println("饿汉模式:singleton1和singleton2是同一个实例");
} else {
System.out.println("饿汉模式:singleton1和singleton2不是同一个实例");
}
}
/**
* 验证懒汉模式
*/
public static void method2(){
Singleton2 singleton1 = Singleton2.getInstance();
Singleton2 singleton2 = Singleton2.getInstance();
if(singleton1 == singleton2){
System.out.println("懒汉模式:singleton1和singleton2是同一个实例");
} else {
System.out.println("懒汉模式:singleton1和singleton2不是同一个实例");
}
}
}
输出如下:
/**
* @Classname SingletonThreadTest
* @Description 单例模式多线程验证,验证饿汉模式线程安全、懒汉模式线程不安全
* @Date 2019/5/11 23:20
* @Created by xiangty
*/
public class SingletonThreadTest implements Runnable{
public static void main(String[] args) throws Exception {
SingletonThreadTest singletonThreadTest = new SingletonThreadTest();
Thread thread1 = new Thread(singletonThreadTest);
Thread thread2 = new Thread(singletonThreadTest);
Thread thread3 = new Thread(singletonThreadTest);
Thread thread4 = new Thread(singletonThreadTest);
Thread thread5 = new Thread(singletonThreadTest);
Thread thread6 = new Thread(singletonThreadTest);
thread1.start();
thread2.start();
thread3.start();
thread4.start();
thread5.start();
thread6.start();
thread1.join();
thread2.join();
thread3.join();
thread4.join();
thread5.join();
thread6.join();
}
/**
* 验证饿汉模式
*/
public static void method1(){
Singleton1 singleton1 = Singleton1.getInstance();
Singleton1 singleton2 = Singleton1.getInstance();
if(singleton1 == singleton2){
println(Thread.currentThread().getName()+"饿汉模式:singleton1和singleton2是同一个实例");
} else {
println(Thread.currentThread().getName()+"饿汉模式:singleton1和singleton2不是同一个实例");
}
}
/**
* 验证懒汉模式
*/
public static void method2(){
Singleton2 singleton1 = Singleton2.getInstance();
Singleton2 singleton2 = Singleton2.getInstance();
if(singleton1 == singleton2){
println(Thread.currentThread().getName()+"懒汉模式:singleton1和singleton2是同一个实例");
} else {
println(Thread.currentThread().getName()+"懒汉模式:singleton1和singleton2不是同一个实例");
}
}
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
method2();
}
}
/**
* 输出信息
*/
private static void println(Object obj){
System.out.println(obj);
}
}
输出如下:(测试了很多次才出现的)
饿汉模式和懒汉模式区别
饿汉模式加载类的时候比较慢,获取对象速度快;懒汉加载类时过快,获取对象速度过慢。
饿汉模式线程安全、懒汉模式线程不安全
懒汉式在多线程中的安全隐患以及解决方案、优化策略。
上图在验证懒汉模式的时候,出现了创建多个实例的安全隐患。
原因是懒汉式多加了一次判断(如下图),导致了线程安全性隐患。因为CPU很有可能在执行完if语句之后切向其它线程。解决线程安全性问题的关键就是加上同步锁。
方法1:使用同步函数,使用synchronized关键字修饰方法
Singleton2.java类中添加代码如下:
/**
* (优化方法1:使用同步函数) 定义一个公共方法将创建的对象返回
*/
public static synchronized Singleton2 getInstance() {
if (singleton2 == null) {
singleton2 = new Singleton2();
}
return singleton2;
}
方法1的不足之处,直接使用synchronized关键字修饰方法效率比较低,因为每次调用getInstance方法需要先判断锁。
方法2:使用同步代码块
/**
* (优化方法2:使用同步代码块)
*/
public static Singleton2 getInstanceNew2(){
synchronized(Singleton2.class){
if(singleton2 == null){
singleton2 = new Singleton2();
}
return singleton2;
}
}
不足之处,与方法1相比效率基本没有变化
方法3:使用同步代码块解决效率问题
/**
* 优化方法3
*/
public static Singleton2 getInstance(){
if(singleton2 == null) { // 解决效率问题
synchronized (Singleton2.class) {
if (singleton2 == null) { // 第二次判空操作是为了保证单例对象的唯一性
singleton2 = new Singleton2();
}
}
}
return singleton2;
}
与方法2相比,代码块外多了一层判断,主要是为了解决被多次执行代码块的效率问题。
方法3实现步骤:
如果没有创建对象,即singleton2 ==null,通过第一层判断;再进入同步代码块,进入同步代码块则其它线程则要创建实例就需要获取锁;等当前线程创建好对象后,释放锁以后,假如有其它线程已经进入代码块,那么会通过第二层if判断来判断对象实例的唯一性。没有进入第一层if判断的时候,判空操作之后不满足条件,直接放回对象。后续调用getInstance方法,只会执行第一层if判断,不会再执行同步代码块了,大大提高了执行效率。
如有问题,请指正,谢谢!