当前位置： 首页 > news >正文

wordpress资讯cms主题刷关键词排名seo软件

news 2025/7/6 10:51:40
wordpress资讯cms主题,刷关键词排名seo软件,建筑施工单位网站,wordpress文章字体目录 简介 饿汉式 懒汉式 双重检测锁式 静态内部类式 枚举单例 测试 测试单例模式： 测试五种单例模式在多线程环境下的效率 问题（拓展） 例：反射破解单例模式 例：反序列化破解单例模式 总结：如何…

目录

简介

饿汉式

懒汉式

双重检测锁式

静态内部类式

枚举单例

测试

测试单例模式：

测试五种单例模式在多线程环境下的效率

问题（拓展）

例：反射破解单例模式

例：反序列化破解单例模式

总结：如何用

简介

单例对象（Singleton）是一种常用的设计模式。在Java应用中，单例对象能保证在一个 JVM 中，该对象只有一个实例存在。这样的模式有几个好处：

单例模式的优点：

  • 由于单例模式只生产一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决
  • 单例模式可以在系统设置全局的访问点，优化环境共享资源访问，例如可以设计一个单例类，负责所以数据表的映射处理

常见的五种单例模式实现方式：

  • 主要：
    • 饿汉式（线程安全，调用效率高；但是，不能延迟加载）
    • 懒汉式（线程安全，调用效率不高；但是，可以延迟加载）
  • 其他：
    • 双重检测锁式（由于 JVM 底层内部模型原因，偶尔会出问题，不建议使用）
    • 静态内部类式（线程安全，调用效率高；但是，可以延时加载）
    • 枚举单例（线程安全，调用效率高，不能延时加载）

饿汉式

/*** @ProjectName:* @Package:        com.example.gof23.creational_patterns.singleton* @ClassName:      SingletonHg* @Description:    饿汉式单例模式（Hungry）* @Author:         qfxl* @CreateDate:     2024/09/09 23:00* @Version:        1.0.0*/
public class SingletonHungry {//类初始化时，立即加载这个对象//（在类加载器加载时，是天然的线程安全模式；同时因为是立即加载，所以没有延迟加载的优势）private static SingletonHungry instance = new SingletonHungry();//私有化构造器private SingletonHungry() {}//方法没有同步，调用效率高public static SingletonHungry getInstance() {return instance;}
}

懒汉式

/*** @ProjectName:* @Package:        com.example.gof23.creational_patterns.singleton* @ClassName:      SingletonLazy* @Description:    懒汉式单例模式（Lazy）* @Author:         qfxl* @CreateDate:     2024/09/09 23:00* @Version:        1.0.0*/
public class SingletonLazy {//类初始化时，不初始化这个对象（实现懒加载 或者叫 延迟加载（lazy load），真正用到的时候才加载）private static SingletonLazy instance;//私有化构造器private SingletonLazy() {}//方法同步，调用效率低public static synchronized SingletonLazy getInstance() {if (instance == null) {instance = new SingletonLazy();}return instance;}
}

双重检测锁式

/*** @ProjectName:* @Package:        com.example.gof23.creational_patterns.singleton* @ClassName:      SingletonDC* @Description:    双重检测锁式单例模式（Double Checked Locking）* @Author:         qfxl* @CreateDate:     2024/09/09 23:10* @Version:        1.0.0*/
public class SingletonDC {//使用了volatile关键字后，重排序被禁止，所有的写（write）操作都将发生在读（read）操作之前private volatile static SingletonDC instance;//私有化构造器private SingletonDC() {}//双重检测锁式public SingletonDC getInstance() {if (instance == null) {synchronized (SingletonDC.class) {if (instance == null) {instance = new SingletonDC();}}}return instance;}
}

静态内部类式

/*** @ProjectName:* @Package:        com.example.gof23.creational_patterns.singleton* @ClassName:      SingletonSIC* @Description:    静态内部类式单例模式（Static Inner Class）* @Author:         qfxl* @CreateDate:     2024/09/09 23:10* @Version:        1.0.0*/
public class SingletonSIC {private static class SingletonClassInstance {private static final SingletonSIC instance = new SingletonSIC();}//私有化构造器private SingletonSIC() {}public static SingletonSIC getInstance(){return SingletonClassInstance.instance;}
}

枚举单例

/*** @ProjectName:* @Package:        com.example.gof23.creational_patterns.singleton* @ClassName:      SingletonEnum* @Description:    枚举类单例模式（Enum）* @Author:         qfxl* @CreateDate:     2024/09/09 23:10* @Version:        1.0.0*/
public enum SingletonEnum {//这个枚举元素，本身就是单例对象（没有延时加载）INSTANCE;//添加自己需要的操作public void singletonOperation() {}
}

测试

测试单例模式：

public class Client {public static void main(String[] args) {//测试饿汉式单例模式（Hungry）SingletonHungry hungry1 = SingletonHungry.getInstance();SingletonHungry hungry2 = SingletonHungry.getInstance();System.out.println(hungry1);System.out.println(hungry2);//测试懒汉式单例模式SingletonLazy lazy1 = SingletonLazy.getInstance();SingletonLazy lazy2 = SingletonLazy.getInstance();System.out.println(lazy1);System.out.println(lazy2);//测试双重检测锁单例模式SingletonDC dc1 = SingletonDC.getInstance();SingletonDC dc2 = SingletonDC.getInstance();System.out.println(dc1);System.out.println(dc2);//测试静态内部类式单例模式SingletonSIC sic1 = SingletonSIC.getInstance();SingletonSIC sic2 = SingletonSIC.getInstance();System.out.println(sic1);System.out.println(sic2);//测试枚举单例模式SingletonEnum anEnum1 = SingletonEnum.INSTANCE;SingletonEnum anEnum2 = SingletonEnum.INSTANCE;System.out.println(anEnum1==anEnum2);}
}

结果为：

饿汉式：com.example.gof23.creational_patterns.singleton.SingletonHungry@1540e19d
饿汉式：com.example.gof23.creational_patterns.singleton.SingletonHungry@1540e19d
懒汉式：com.example.gof23.creational_patterns.singleton.SingletonLazy@677327b6
懒汉式：com.example.gof23.creational_patterns.singleton.SingletonLazy@677327b6
双重检测锁：com.example.gof23.creational_patterns.singleton.SingletonDC@14ae5a5
双重检测锁：com.example.gof23.creational_patterns.singleton.SingletonDC@14ae5a5
静态内部类：com.example.gof23.creational_patterns.singleton.SingletonSIC@7f31245a
静态内部类：com.example.gof23.creational_patterns.singleton.SingletonSIC@7f31245a
枚举单例：true

测试五种单例模式在多线程环境下的效率

（关注相对值即可，不同的环境下测试值完全不一样）

五种单例模式时间
饿汉式（SingletonHungry）26ms
懒汉式（SingletonLazy）186ms
双重检测锁式（SingletonDC）40ms
静态内部类式（SingletonSIC）31ms
枚举单例（SingletonEnum）37ms
  • CountDownLatch
    • 同步辅助类，在完全一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待
    • countDown()：当前线程调用此方法，则计数减一（建议放在 finally 里执行）
    • await()：调用此方法会一直阻塞当前线程，直到计时器的值为0
public class ClientTimes {public static void main(String[] args) throws InterruptedException {long start = System.currentTimeMillis();int threadNum = 10;final CountDownLatch countDownLatch = new CountDownLatch(threadNum);for (int i = 0; i < threadNum; i++) {new Thread(new Runnable() {public void run() {for (int i = 0; i < 1000000; i++) {//分别对下面的单例模式进行测试SingletonHungry hungry = SingletonHungry.getInstance();
//                        SingletonLazy lazy = SingletonLazy.getInstance();
//                        SingletonDC dc = SingletonDC.getInstance();
//                        SingletonSIC sic = SingletonSIC.getInstance();
//                        SingletonEnum anEnum = SingletonEnum.INSTANCE;}countDownLatch.countDown();}}).start();}//main线程阻塞，直到计数器变为0，才会继续执行countDownLatch.await();long end = System.currentTimeMillis();System.out.println("总耗时：" + (end - start));}
}

测试结果如上表格

问题（拓展）

  • 反射可以破解上面几种（不包含枚举式）实现反式（可以在构造方法中手动抛出异常控制）
  • 反序列化可以破解上面几种（不包含枚举式）实现方式（可以通过定义 readResolver() 防止获得不同的对象）
    • 反序列化时，如果对象所在的类定义了 readResolver()，（实际是一种回调），定义返回那个对象

例：反射破解单例模式

package com.example.gof23.creational_patterns.singleton.expand;public class SingletonDemo {private static SingletonDemo instance = new SingletonDemo();//私有化构造器private SingletonDemo() {}public static SingletonDemo getInstance() {return instance;}}

public class Test_reflect {public static void main(String[] args) throws Exception {//通过反射来破解单例模式（通过反射的方式直接调用私有化构造器）Class<SingletonDemo> clazz = (Class<SingletonDemo>) Class.forName("com.example.gof23.creational_patterns.singleton.expand.SingletonDemo");Constructor<SingletonDemo> c = clazz.getDeclaredConstructor(null);c.setAccessible(true);//跳过权限的检测，使其可以访问私有的方法SingletonDemo sd1 = c.newInstance();SingletonDemo sd2 = c.newInstance();System.out.println(sd1);System.out.println(sd2);}
}

结果为：

com.example.gof23.creational_patterns.singleton.expand.SingletonDemo@1540e19d
com.example.gof23.creational_patterns.singleton.expand.SingletonDemo@677327b6

防止反射破解单例模式：在构造方法中手动抛出异常控制

package com.example.gof23.creational_patterns.singleton.expand;public class SingletonDemo {private static SingletonDemo instance = new SingletonDemo();//私有化构造器private SingletonDemo() {//防止反射获取私有化的构造方法，从而破解单例模式if (instance != null) {throw new RuntimeException();}}public static SingletonDemo getInstance() {return instance;}}

再运行的结果为：

com.example.gof23.creational_patterns.singleton.expand.SingletonDemo@135fbaa4
com.example.gof23.creational_patterns.singleton.expand.SingletonDemo@135fbaa4

例：反序列化破解单例模式

package com.example.gof23.creational_patterns.singleton.expand;import java.io.Serializable;public class SingletonDemo implements Serializable {private static SingletonDemo instance = new SingletonDemo();//私有化构造器private SingletonDemo() {}public static SingletonDemo getInstance() {return instance;}}

public class Test_serializable {public static void main(String[] args) throws Exception {//通过反序列化的方式构造多个对象SingletonDemo instance1 = SingletonDemo.getInstance();FileOutputStream fos = new FileOutputStream("e:/a.txt");ObjectOutputStream oos = new ObjectOutputStream(fos);oos.writeObject(instance1);FileInputStream fis = new FileInputStream("e:/a.txt");ObjectInputStream ois = new ObjectInputStream(fis);SingletonDemo instance2 = (SingletonDemo) ois.readObject();System.out.println(instance1);System.out.println(instance2);}
}

结果为：

com.example.gof23.creational_patterns.singleton.expand.SingletonDemo@135fbaa4
com.example.gof23.creational_patterns.singleton.expand.SingletonDemo@58372a00

防止反序列化破解单例模式：通过定义 readResolver() 防止获得不同的对象

package com.example.gof23.creational_patterns.singleton.expand;import java.io.Serializable;public class SingletonDemo implements Serializable {private static SingletonDemo instance = new SingletonDemo();//私有化构造器private SingletonDemo() {//防止反射获取私有化的构造方法，从而破解单例模式if (instance != null) {throw new RuntimeException();}}public static SingletonDemo getInstance() {return instance;}//在反序列化时，如果定义了此方法，则直接返回此方法中的对象，无需单独再创建新对象private Object readResolve() {return instance;}}

再运行结果为：

com.example.gof23.creational_patterns.singleton.expand.SingletonDemo@135fbaa4
com.example.gof23.creational_patterns.singleton.expand.SingletonDemo@135fbaa4

总结：如何用

  • 单例对象占用资源少，不需要延迟加载：
    • 枚举式 好于 饿汉式
  • 单例对象占用资源大，需要延迟加载：
    • 静态内部类式 好于 懒汉式
http://www.hrbkazy.com/news/10663.html

相关文章：

  • 房屋中介网站怎么做长沙关键词自然排名
  • 网站建设流程总结网站推广和优化的原因网络营销
  • 哪个网站可以做任务网站seo工具
  • 网站建设制作设计营销公司杭州十大小说网站排名
  • 攻击Wordpress网站百度极简网址
  • c 网站做微信收款功能线下推广渠道和方式
  • 重庆的网站设计公司价格拼多多网店代运营要多少费用
  • 制作钓鱼网站属于什么罪百度小说风云榜
  • 织梦做淘宝客网站视频教程百度账号注册申请
  • 遵化市有做奇麟网站的吗百度热搜广告设计公司
  • 新手如何做英文网站赚美元seo刷关键词排名优化
  • 淄博周村专业网站建设公司网络营销的四大基础理论
  • 东莞凤岗网站建设全媒体运营师报考官网在哪里
  • 北京市重大项目建设指挥部网站如何做网站推广及优化
  • 三亚防疫情最新通知北京seo公司有哪些
  • 做网站细节百度自动点击器下载
  • 长春网络公司宣传廊坊网络推广优化公司
  • 做网站实现登陆功能谷歌浏览器 安卓下载2023版官网
  • 百度网站类型推广咨询服务公司
  • 北京网站建设还公司百度公司好进吗
  • 网站建设平台报价南京seo全网营销
  • 网站开发价钱太原seo顾问
  • 网站出现搜索搜索引擎seo关键词优化
  • b站推广2023mmmseo运营是什么
  • 惠州网络公司网站建设百度账号人工申诉
  • 美国搜索网站建设网络营销推广总结
  • 做电影网站步骤百度推广关键词优化
  • 图片在线设计网站百度广告联盟怎么加入
  • 电梯行业网站怎么做电商怎么做?如何从零开始学做电商赚钱
  • 广东三网合一网站建设报价网站内容优化方法