【设计模式】- 单例模式

1、饿汉式

//饿汉式单例:一进来就会创建对象,可能会浪费时间
public class Hungry {

    private Hungry(){

    }
	//创建对象
    public final static Hungry hungry = new Hungry();

    public static Hungry getHungry(){
        return hungry;
    }
}

2、懒汉式

1)基本的懒汉式

//懒汉式单例
public class Lazy {

    private Lazy(){
       System.out.println(Thread.currentThread().getName() + "lazy线程启动");
	}
        
	if (lazy!=null){
		throw new RuntimeException("不要试图用凡是破坏单例!");
	}
       
    private static Lazy lazy;

    public static Lazy getLazy(){
		if (lazy==null){
		lazy = new Lazy(); 
	}
        return lazy; 
    }

    //单线程下,没有问题,但是多线程会存在问题
	public static void main(String[] args) {
		for (int i = 0; i < 10; i++) {
			new Thread(()->{
				lazy.getLazy();
			}).start();
		}
	}
}

2)解决多线程不安全加双重检测锁

//懒汉式单例
public class Lazy {

    private Lazy(){
		System.out.println(Thread.currentThread().getName() + "lazy线程启动");
   }

    private static Lazy lazy;

    public static Lazy getLazy(){
        //双重检测锁模式,懒汉式,DCL懒汉式
        if (lazy==null){
            synchronized (Lazy.class){
                if (lazy==null){
                    lazy = new Lazy(); 
                }
            }
        }
        return lazy; //此时lazy会有可能未构造
    }

    //单线程下,没有问题,但是多线程会存在问题
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                lazy.getLazy();
            }).start();
        }
    }
}

3)针对懒汉式在创建对象时,不是原子性操作,避免指令重排,将属性定义为volatile类型(双重检测锁+原子操作)

//懒汉式单例
public class Lazy {

    private Lazy(){
		System.out.println(Thread.currentThread().getName() + "lazy线程启动");
   }

    private volatile static Lazy lazy;

    public static Lazy getLazy(){
        //双重检测锁模式,懒汉式,DCL懒汉式
        if (lazy==null){
            synchronized (Lazy.class){
                if (lazy==null){
                    lazy = new Lazy(); //不是原子性操作,会发生指令重排现象,期望1-2-3
                    /**
                     * 1.分配内存空间
                     * 2.执行构造方法,初始化对象
                     * 3.把这个对象指向这个空间
                     *
                     * 123
                     * 132 A
                     *     B //此时lazy还没有构造,就返回了
                     *
                     * 所以避免指令重排,要加volatile(原子性操作)
                     */
                }
            }
        }
        return lazy; //此时lazy会有可能未构造
    }

    //单线程下,没有问题,但是多线程会存在问题
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                lazy.getLazy();
            }).start();
        }
    }
}

4)初步解决反射破坏懒汉式(三重检测)

//懒汉式单例
//道高一尺魔高一丈
public class Lazy {

    private Lazy(){

        synchronized (Lazy.class){
			if (lazy!=null){
				throw new RuntimeException("不要试图用凡是破坏单例!");
			}
		}
    }

    private volatile static Lazy lazy;

    public static Lazy getLazy(){
        //双重检测锁模式,懒汉式,DCL懒汉式
        if (lazy==null){
            synchronized (Lazy.class){
                if (lazy==null){
                    lazy = new Lazy(); //不是原子性操作,会发生指令重排现象,期望1-2-3
                    /**
                     * 1.分配内存空间
                     * 2.执行构造方法,初始化对象
                     * 3.把这个对象指向这个空间
                     *
                     * 123
                     * 132 A
                     *     B //此时lazy还没有构造,就返回了
                     *
                     * 所以避免指令重排,要加volatile(原子性操作)
                     */
                }
            }
        }
        return lazy; //此时lazy会有可能未构造
    }
    
    //反射
    public static void main(String[] args) throws Exception {

        Lazy instant = lazy.getLazy(); //懒汉式中拿到的对象

        Constructor<Lazy> declaredConstructor = Lazy.class.getDeclaredConstructor(null);//反射获取无参构造器
        declaredConstructor.setAccessible(true); //破坏权限无视构造器
        Lazy lazy = declaredConstructor.newInstance(); //反射构造的对象

        System.out.println(instant.hashCode());
        System.out.println(lazy.hashCode());
    }
}

5)如果两个对象都是用单例创建的,通过红绿灯解决

//懒汉式单例
//道高一尺魔高一丈
public class Lazy {

    //红绿灯
    private static boolean bool = false;

    private Lazy(){
        synchronized (Lazy.class){
            if (!bool){
                bool = true;
            }else{
                throw new RuntimeException("不要试图用凡是破坏单例!");
            }
        }

    }

    private volatile static Lazy lazy;

    public static Lazy getLazy(){
        //双重检测锁模式,懒汉式,DCL懒汉式
        if (lazy==null){
            synchronized (Lazy.class){
                if (lazy==null){
                    lazy = new Lazy(); //不是原子性操作,会发生指令重排现象,期望1-2-3
                    /**
                     * 1.分配内存空间
                     * 2.执行构造方法,初始化对象
                     * 3.把这个对象指向这个空间
                     *
                     * 123
                     * 132 A
                     *     B //此时lazy还没有构造,就返回了
                     *
                     * 所以避免指令重排,要加volatile(原子性操作)
                     */
                }
            }
        }
        return lazy; //此时lazy会有可能未构造
    }

    //反射
    public static void main(String[] args) throws Exception {

        Lazy instant = lazy.getLazy(); //懒汉式中拿到的对象

        Constructor<Lazy> declaredConstructor = Lazy.class.getDeclaredConstructor(null);//反射获取无参构造器
        declaredConstructor.setAccessible(true); //破坏权限无视构造器
        Lazy lazy = declaredConstructor.newInstance(); //反射构造的对象
        Lazy lazy2 = declaredConstructor.newInstance(); //反射构造的对象
        System.out.println(lazy.hashCode());
        System.out.println(lazy2.hashCode());
    }
}

6)如果红绿灯标志被反射获取,用枚举解决

//懒汉式单例
//道高一尺魔高一丈
public class Lazy {

    //红绿灯
    private static boolean bool = false;

    private Lazy(){
        synchronized (Lazy.class){
            if (!bool){
                bool = true;
            }else{
                throw new RuntimeException("不要试图用凡是破坏单例!");
            }
//            if (lazy!=null){
//                throw new RuntimeException("不要试图用凡是破坏单例!");
//            }
        }

    }

    private volatile static Lazy lazy;

    public static Lazy getLazy(){
        //双重检测锁模式,懒汉式,DCL懒汉式
        if (lazy==null){
            synchronized (Lazy.class){
                if (lazy==null){
                    lazy = new Lazy(); //不是原子性操作,会发生指令重排现象,期望1-2-3
                    /**
                     * 1.分配内存空间
                     * 2.执行构造方法,初始化对象
                     * 3.把这个对象指向这个空间
                     *
                     * 123
                     * 132 A
                     *     B //此时lazy还没有构造,就返回了
                     *
                     * 所以避免指令重排,要加volatile(原子性操作)
                     */
                }
            }
        }
        return lazy; //此时lazy会有可能未构造
    }

    //单线程下,没有问题,但是多线程会存在问题
//    public static void main(String[] args) {
//        for (int i = 0; i < 10; i++) {
//            new Thread(()->{
//                lazy.getLazy();
//            }).start();
//        }
//    }

    //反射
    public static void main(String[] args) throws Exception {

        Lazy instant = lazy.getLazy(); //懒汉式中拿到的对象

        Field bool = Lazy.class.getDeclaredField("bool"); //反射获取类中的字段
        bool.setAccessible(true); //破坏属性的私有权限

        Constructor<Lazy> declaredConstructor = Lazy.class.getDeclaredConstructor(null);//反射获取无参构造器
        declaredConstructor.setAccessible(true); //破坏权限无视构造器
        Lazy lazy = declaredConstructor.newInstance(); //反射构造的对象

        bool.set(instant,false); //给字段重新赋值

        Lazy lazy2 = declaredConstructor.newInstance(); //反射构造的对象

        System.out.println(instant.hashCode());
        System.out.println(lazy.hashCode());
        System.out.println(lazy2.hashCode());
    }
}

3、静态内部类实现

//静态内部类实现
public class Holder {

    private Holder(){

    }

    private static Holder getHolder(){
        return InnerClass.holder;
    }

    public static class InnerClass{
        private final static Holder holder = new Holder();
    }
}

4、枚举

//enum: 1.5出现的,本身也是一个class类
public enum EnumSingle {

    INSTANCE;

    public EnumSingle getInstance(){
        return INSTANCE;
    }

    public static void main(String[] args) throws Exception {

        EnumSingle e1 = EnumSingle.INSTANCE;
        
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class, int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle enumSingle = declaredConstructor.newInstance();

        System.out.println(e1);
        System.out.println(enumSingle);
    }
}
在探索智慧旅游的新纪元中,一个集科技、创新与服务于一体的整体解决方案正悄然改变着我们的旅行方式。智慧旅游,作为智慧城市的重要分支,旨在通过新一代信息技术,如云计算、大数据、物联网等,为游客、旅游企业及政府部门提供无缝对接、高效互动的旅游体验与管理模式。这一方案不仅重新定义了旅游行业的服务标准,更开启了旅游业数字化转型的新篇章。 智慧旅游的核心在于“以人为本”,它不仅仅关注技术的革新,更注重游客体验的提升。从游前的行程规划、信息查询,到游中的智能导航、个性化导览,再到游后的心情分享、服务评价,智慧旅游通过构建“一云多屏”的服务平台,让游客在旅游的全过程中都能享受到便捷、个性化的服务。例如,游客可以通过手机APP轻松定制专属行程,利用智能语音导览深入了解景点背后的故事,甚至通过三维GIS地图实现虚拟漫游,提前感受目的地的魅力。这些创新服务不仅增强了游客的参与感和满意度,也让旅游变得更加智能化、趣味化。 此外,智慧旅游还为旅游企业和政府部门带来了前所未有的管理变革。通过大数据分析,旅游企业能够精准把握市场动态,实现旅游产品的精准营销和个性化推荐,从而提升市场竞争力。而政府部门则能利用智慧旅游平台实现对旅游资源的科学规划和精细管理,提高监管效率和质量。例如,通过实时监控和数据分析,政府可以迅速应对旅游高峰期的客流压力,有效预防景区超载,保障游客安全。同时,智慧旅游还促进了跨行业、跨部门的数据共享与协同合作,为旅游业的可持续发展奠定了坚实基础。总之,智慧旅游以其独特的魅力和无限潜力,正引领着旅游业迈向一个更加智慧、便捷、高效的新时代。
内容概要:本文详细介绍了大模型的发展现状与未来趋势,尤其聚焦于DeepSeek这一创新应用。文章首先回顾了人工智能的定义、分类及其发展历程,指出从摩尔定律到知识密度提升的转变,强调了大模型知识密度的重要性。随后,文章深入探讨了DeepSeek的发展路径及其核心价值,包括其推理模型、思维链技术的应用及局限性。此外,文章展示了DeepSeek在多个行业的应用场景,如智能客服、医疗、金融等,并分析了DeepSeek如何赋能个人发展,具体体现在公文写作、文档处理、知识搜索、论文写作等方面。最后,文章展望了大模型的发展趋势,如通用大模型与垂域大模型的协同发展,以及本地部署小模型成为主流应用渠道的趋势。 适合人群:对人工智能和大模型技术感兴趣的从业者、研究人员及希望利用DeepSeek提升工作效率的个人用户。 使用场景及目标:①了解大模型技术的最新进展和发展趋势;②掌握DeepSeek在不同领域的具体应用场景和操作方法;③学习如何通过DeepSeek提升个人在公文写作、文档处理、知识搜索、论文写作等方面的工作效率;④探索大模型在特定行业的应用潜力,如医疗、金融等领域。 其他说明:本文不仅提供了理论知识,还结合实际案例,详细介绍了DeepSeek在各个场景下的应用方式,帮助读者更好地理解和应用大模型技术。同时,文章也指出了当前大模型技术面临的挑战,如模型的局限性和数据安全问题,鼓励读者关注技术的持续改进和发展。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值