延迟加载java（延迟加载JS有哪些方式）

今天给各位分享延迟加载java的知识，其中也会对延迟加载JS有哪些方式进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

微信号：cloud7591
如需了解更多，欢迎添加客服微信咨询。
复制微信号

本文目录一览：

• 1、JAVA单例模式的延迟加载疑问
• 2、asp中如何实现延迟加载JAVA?
• 3、java Annotation @lazy是什么意思
• 4、java中 延迟加载的作用？
• 5、如何在java中实现singleton模式
• 6、java编写一个延迟加载的单例设计模式。

JAVA单例模式的延迟加载疑问

1.首先 所有的类都是第一次被引用时才会加载到JVM中。也就是说全都是延迟加载，而不是预先加载。

2.“静态类将只会随JVM装载一次，所以只会创建一个Foo对象”，这句话的意思是说，随着类LazyFoo被第一次引用，JVM会载入类LazyFoo，同时执行类的静态初始化。

什么是类的静态初始化？

类被载入JVM之后，各个语句之间的执行顺序是如何的呢？

#当第一次引用类之后#

1.类的静态初始化（包括类的静态块）

#当创建类的对象后#

2.类的非静态初始化（同样包括类的非静态块）

3.类的构造函数

public static Foo foo = new Foo();

这一句就是类的静态初始化，他仅会在类被载入时执行一次。

实际上你的这个单例模式的代码还是有些问题的。似乎不能达成单例效果，除非添加一个private Foo()构造函数。

我写一个单例模式给你看看吧。

public class Foo {

private static Foo sc;

private Foo() {

}

public static Foo getSC() {

if (sc == null) {

sc = new Foo();

}

return sc;

}

}

asp中如何实现延迟加载JAVA?

首先：SCRIPT language=JavaScript src="js/photo.js" /SCRIPT

这不是java，这是JavaScript，简称js。

你要的功能：

SCRIPT language=JavaScript src="" id="aaa" /SCRIPT

script

function oOpen(){

document.getElementById("aaa").src="js/photo.js";

}

var oTime = window.setTimeout("oOpen()",5000);

/script

5000表示5秒后，你也可以自己设置时间。

java Annotation @lazy是什么意思

首先要说明的是，@lazy这个注解通常指的是hibernate库的lazy，通常称为懒加载。

在Hibernate框架中，当我们要访问的数据量过大时，明显用缓存不太合适， 因为内存容量有限 ，为了减少并发量，减少系统资源的消耗，这时Hibernate用懒加载机制来弥补这种缺陷，但是这只是弥补而不是用了懒加载总体性能就提高了。

我们所说的懒加载也被称为延迟加载，它在查询的时候不会立刻访问数据库，而是返回代理对象，当真正去使用对象的时候才会访问数据库。

下面几种可以实现懒加载功能：

1、 通过Session.load()实现懒加载

load(Object, Serializable)：根据id查询 。查询返回的是代理对象，不会立刻访问数据库，是懒加载的。当真正去使用对象的时候才会访问数据库。

用load()的时候会发现不会打印出查询语句，而使用get()的时候会打印出查询语句。

使用load()时如果在session关闭之后再查询此对象，会报异常：could not initialize proxy - no Session。处理办法：在session关闭之前初始化一下查询出来的对象：Hibernate.initialize(user);

使用load()可以提高效率，因为刚开始的时候并没有查询数据库。但很少使用。

2、 one-to-one(元素)实现了懒加载。

在一对一的时候，查询主对象时默认不是懒加载。即：查询主对象的时候也会把从对象查询出来。

需要把主对象配制成lazy="true" constrained="true" fetch="select"。此时查询主对象的时候就不会查询从对象，从而实现了懒加载。

一对一的时候，查询从对象的是默认是懒加载。即：查询从对象的时候不会把主对象查询出来。而是查询出来的是主对象的代理对象。

3、 many-to-one（元素）实现了懒加载。

多对一的时候，查询主对象时默认是懒加载。即：查询主对象的时候不会把从对象查询出来。

多对一的时候，查询从对象时默认是懒加载。即：查询从对象的时候不会把主对象查询出来。

hibernate3.0中lazy有三个值，true，false，proxy,默认的是lazy="proxy".具体设置成什么要看你的需求，并不是说哪个设置就是最好的。在many-to-one与one-to-one标签上:当为true时,会有懒加载特性,当为false时会产生N+1问题,比如一个学生对应一个班级,用一条SQL查出10个学生,当访问学生的班级属性时Hibernate会再产生10条SQL分别查出每个学生对应的班级.

lazy= 什么时候捉取

fetch= 捉取方式:select=关联查询;join=连接表的方式查询(效率高)

fetch=join时,lazy的设置将没有意义.

4、 one-to-many(元素)懒加载：默认会懒加载，这是必须的，是重常用的。

一对多的时候，查询主对象时默认是懒加载。即：查询主对象的时候不会把从对象查询出来。

一对多的时候，查询从对象时默认是懒加载。即：查询从对象的时候不会把主对象查询出来。

需要配置主对象中的set集合lazy="false" 这样就配置成是不懒加载了。或者配置抓取方式fetch="join"也可以变成不懒加载。

java中 延迟加载的作用？

延迟加载和JAVA没关系。 很多地方都用得到。

主要是为了加快某些过程，让用户等待时间稍微短一些。 比如浏览器一般先加载文本，显示出来以后再加载图片。 这样用户不至于等到所有东西都下载完成以后再显示给用户。

在某些领域，比如软件开发来讲，延迟加载使用合理可以避免CPU和内存高峰。

如何在java中实现singleton模式

单例模式大致有五种写法，分别为懒汉，恶汉，静态内部类，枚举和双重校验锁。

1、懒汉写法，常用写法

class LazySingleton{

    private static LazySingleton singleton;

    private LazySingleton(){

    }

    public static LazySingleton getInstance(){

        if(singleton==null){

            singleton=new LazySingleton();

        }

        return singleton;

    }   

}

2、恶汉写法，缺点是没有达到lazy loading的效果

class HungrySingleton{

    private static HungrySingleton singleton=new HungrySingleton();

    private HungrySingleton(){}

    public static HungrySingleton getInstance(){

        return singleton;

    }

}

3、静态内部类，优点：加载时不会初始化静态变量INSTANCE，因为没有主动使用，达到Lazy loading

class InternalSingleton{

    private static class SingletonHolder{

        private final static  InternalSingleton INSTANCE=new InternalSingleton();

    }   

    private InternalSingleton(){}

    public static InternalSingleton getInstance(){

        return SingletonHolder.INSTANCE;

    }

}

4、枚举，优点：不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象

enum EnumSingleton{

    INSTANCE;

    public void doSomeThing(){

    }

}

5、双重校验锁，在当前的内存模型中无效

class LockSingleton{

    private volatile static LockSingleton singleton;

    private LockSingleton(){}

    public static LockSingleton getInstance(){

        if(singleton==null){

            synchronized(LockSingleton.class){

                if(singleton==null){

                    singleton=new LockSingleton();

                }

            }

        }

        return singleton;

    }

}

java编写一个延迟加载的单例设计模式。

懒汉式单例模式是延迟加载的单例设计模式

public class LazySingleton {

//静态私有的成员变量

private static LazySingleton instance = null;

// 私有的构造方法

private LazySingleton() {}

// 如果不加synchronized会导致对线程的访问不安全

// 双重锁定检查

public static LazySingleton getInstance() {

if (instance == null) {

synchronized (LazySingleton.class) {

if (null == instance) {

instance = new LazySingleton();

}

}

}

return instance;

}

关于延迟加载java和延迟加载JS有哪些方式的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。