标签：Singleton 静态 创建 笔记 instance 线程 new 设计模式
目录
创建型设计模式
- 创建型设计模式介绍
- 创建型设计模式分类
简单工厂设计模式
抽象工厂设计模式
创建者模式
原型模式
创建型设计模式介绍
这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是使用 new 运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活。
创建型设计模式分类
- 简单工厂模式（SimpleFactoryPattern）
- 工厂模式（Factory Pattern）
- 抽象工厂模式（Abstract Factory Pattern）
- 单例模式（Singleton Pattern）
- 建造者模式（Builder Pattern）
- 原型模式（Prototype Pattern）
简单工厂设计模式
简单工厂设计模式介绍
说的是定义一个工厂类，根据不同的参数，创建并返回不同的类。其中这些类具有一个公共的父类或是一个接口。简单工厂模式不属于GoF四人组提出的23种设计模式，它是最简单的工厂模式。非常适合我们从此处学习设计模式。
优点：解耦，代码更容易维护
缺点：违反了开闭原则
适用场景：
- 客户如果只知道传入工厂类的参数，对于如何创建对象的逻辑不关心时；
- 当工厂类负责创建的对象（具体产品）比较少时。
简单工厂设计模式实现
简单工厂设计模式中包含：
-
actory：工厂类，内部有是个精通的方法，根据参数选择创建的对象
-
Product：抽象产品类，其作为具体产品的父类，负责定义产品的公共接口
-
ConcreteProduct：具体产品类，有多个，都是继承与抽象产品类，工厂就是创建该类对象
代码示例
假设现在我们是一家快餐工厂，专门生产快餐
/**
* 抽象产品类：快餐
*/
abstract class FastFood {
abstract void show();
}
我们的产品有KFC和MDL
/**
* 具体产品类
*/
class KFC extends FastFood {
@Override
void show() {
System.out.println("生产了KFC");
}
}
class MDL extends FastFood {
@Override
void show() {
System.out.println("生产了MDL");
}
}
快餐工厂可以根据用户的需求来创建对应的品牌
/**
* 快餐工厂
*/
public class FastFoodFactory {
/***
* 用于实现不同类型快餐品牌的创建
* @param brand 类型
* @return 快餐品牌
*/
public static FastFood GetFastFood(String brand) {
switch (brand) {
case "KFC":
return new KFC();
case "Mac":
return new Mac();
default:
throw new IllegalArgumentException("没有该品牌");
}
}
}
于是我们迎来了我们的第一位客人
/**
* 学生
*/
public class Student {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
System.out.print("您想吃什么：");
String brand=input.next();
FastFood kfc = FastFoodFactory.GetFastFood(brand);
kfc.show();
}
}
单例设计模式
单例设计模式介绍
单例设计模式说的是采取一定方法保证在整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法（静态方法）。这是设计模式中最简单的一种，没准无意中就使用到过。
适用场景：
-
非常耗资源的对象创建时（比如读取大文件）
-
资源的创建比较昂贵（比如数据库的连接）
-
逻辑上只应该有一个（比如winform中某些窗口只应打开一次）
单例模式的实现方式
单例模式主要分为：
1）饿汉模式
2）懒汉模式
标红为推荐使用的方式
饿汉模式
饿汉模式是指在类的加载的时候就创建一个实例。饿汉模式又分两种实现方式：
1）通过静态常量实现
优点：写法比较简单，就是在类转载的时候就完成实例化。避免了线程同步问题。
缺点：是在类转载的时候就完成实例化，如果从头到尾未使用过这个实例，则会照成内存的浪费。
结论：这种单例模式可用，可能造成资源浪费，所以一般在确定一定会用到这个类时采用。
代码示例
步骤如下：
1）构造器私有化（防止 new）
2）类的内部创建对象
3）向外暴露一个静态的公共方法。getInstance
class Singleton{
//1.构造器私有化，外部不能new
private Singleton(){
}
//2.本类内部创建对象实例
private final static Singleton instance = new Singleton();
//3.提供一个公有的静态方法，放回实例对象
public static Singleton getInstance(){
return instance;
}
}
2）通过静态代码块实现。
这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也就是类转载的时候，就执行静态代码块中的代码，初始化类的实例。优缺点和上面一样
结论：这种单例模式可用，但是会造成资源浪费
代码示例
1）构造器私有化（防止 new）
2）类的内部声名静态对象
3）在静态代码块中，创建单例对象
4）提供一个公有的静态方法，放回实例对象
class Singleton{
private static Singleton instance;
private Singleton(){
}
static {// 在静态代码块中，创建单例对象
instance = new Singleton();
}
public static Singleton getInstance(){
return instance;
}
}
懒汉模式
懒汉模式是指在调用方法的时候进行实例化的工作。实现方式有六种：
1）线程不安全
优点：起到了懒加载的效果，但是只能在单线程下使用。
缺点：如果在多线程下，一个线程进入了if(singletion == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式
结论：在实际开发中，不要使用这种方式（多线程环境下，线程不安全）
代码示例
实现步骤
1）构造器私有化（防止 new）
2）类的内部声名静态对象
3）提供一个静态的公有方法，当使用到该方法时，才去创建 instance
class Singleton{
private static Singleton instance;
private Singleton(){
}
//提供一个静态的公有方法，当使用到该方法时，才去创建 instance
//即懒汉式
public static Singleton getInstance(){
if(instance == null){
instance = new Singleton();
}
return instance;
}
}
2）线程安全，同步方法
优点：解决了线程不安全问题
缺点：效率太低了，每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想要获得该类实例，直接return就行了。
结论：在实际开发中，不推荐使用这种方法（方法进行同步效率太低）
代码示例
实现步骤
1）构造器私有化（防止 new）
2）类的内部声名静态对象
3）
class Singleton{
private static Singleton instance;
private Singleton(){
}
//提供一个静态的公有方法，加入同步处理的代码，解决线程安全问题
//即懒汉式
public static synchronized Singleton getInstance(){
if(instance == null){
instance = new Singleton();
}
return instance;
}
}
3）线程安全，同步代码块
这种方法，本意是对上一种实现方法的改进，因为前面方法效率太低，改为同步产生实例化的代码块。但这种同步方法并不能起到线程同步的作用。跟第一种实现方法情形一致，假如一个线程进入了if(singletion == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。
结论：在实际开发中，不能使用这种方式
代码示例
实现步骤
1）构造器私有化（防止 new）
2）类的内部声名静态对象
3）提供一个静态的公有方法，在代码块中加入同步处理的代码（synchronized）
class Singleton{
private static Singleton singleton;
private Singleton(){
}
//提供一个静态的公有方法，在代码块中加入同步处理的代码（synchronized）
//即懒汉式
public static Singleton getInstance(){
if(singleton == null){
synchronized(Singleton.class){
singleton = new Singleton();
}
}
return singleton;
}
}
4）双重检查
优点：线程安全，延迟加载，效率较高
缺点：无！！！
结论：在实际开发中，推荐使用这种单例设计模式
代码示例
实现步骤
1）构造器私有化（防止 new）
2）类的内部声名静态对象并用volatile（用来确保将变量的更新操作通知到其他线程）关键字修饰
3）提供一个静态的公有方法，加入双重检查代码，解决线程安全问题，同时解决懒加载问题
class Singleton{
private static volatile Singleton instance;
private Singleton(){
}
//提供一个静态的公有方法，加入双重检查代码，解决线程安全问题，同时解决懒加载问题
public static synchronized Singleton getInstance(){
if(instance == null){
synchronized(Singleton.class){//当第一个线程执行完对象实例化操作后
if(instance == null) {//后面的线程来到这里时判断
instance = new Singleton();
}
//else 到下面返回 instance
}
}
//而当再后面的线程来时在最上方的判断语句中就直接来到这里返回instance
return instance;
}
}
5）静态内部类
优点：
- 线程安全（在类进行初始化时，别的线程是无法进来的。）
- 延迟加载（外部类的装载不会导致静态内部类的装载）
- 效率高
缺点：无 ！！！
结论：实际开发中，推荐使用这种单例设计模式
代码示例
实现步骤
1）构造器私有化（防止 new）
2）类的内部声名静态对象
3）写一个静态内部类，该类中有一个静态属性外部类的静态常量
4）提供一个静态的公有方法，直接返回静态内部类常量属性
class Singleton{
private static Singleton instance;
private Singleton(){
}
//写一个静态内部类，该类中有一个静态属性 Singleton
private static class SingletonInstance{
private static final Singleton INSTANCE = new Singleton();
}
//提供一个静态的公有方法，直接返回 SingletonInstance.INSTANCE
public static synchronized Singleton getInstance(){
return SingletonInstance.INSTANCE;
}
}
6）枚举
这是借助JDK1.5中添加的枚举来实现单例模式。
优点：保证了线程安全、防止了反序列化重新创建新的对象
缺点：无 ！！！
结论：推荐使用
代码示例
//使用枚举，可以实现单例，推荐
enum Singleton{
INSTANCE;//属性
public void sayOK(){
System.out.println("ok~");
}
}
饿汉与懒汉的区别
| 区别 | 饿汉 | 懒汉 |
|---|---|---|
| 线程 | 安全 | 不安全（不过有解决方案） |
| 资源加载 | 占据一定的内存相应的在调用时速度也会更快 | 第一次掉用时要初始化如果要做的工作比较多性能上会有些延迟 |
标签：Singleton,静态,创建,笔记,instance,线程,new,设计模式 来源： https://www.cnblogs.com/kakaji/p/16178372.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。