lazy-initialization

What does Hibernate.initialize do? Usually referred documentation talk only about Hibernate.initialize(entity.lazyCollection) Is there any sense in Hibernate.initialize(entity) I would say yes if the Entity has a lazily initialized field e.g. some large BLOB or CLOB data or a lazy one-to-one association. See 20.1.8. in the documentation for the former and 20.1.3 for the latter. See also: 20.1.4. Initializing collections and proxies I agree with Alan Hay, here is my experience, I've had this problem when running the JUNit tests, some of the lazy objects were not loading when trying to load the

I want to use Lazy initialization for some of my properties in Swift. My current code looks like this: lazy var fontSize : CGFloat = { if (someCase) { return CGFloat(30) } else { return CGFloat(17) } }() The thing is that once the fontSize is set it will NEVER change. So I wanted to do something like this: lazy let fontSize : CGFloat = { if (someCase) { return CGFloat(30) } else { return CGFloat(17) } }() Which is impossible. Only this works: let fontSize : CGFloat = { if (someCase) { return CGFloat(30) } else { return CGFloat(17) } }() So - I want a property that will be lazy loaded but will

Possible Duplicate: What's the (hidden) cost of lazy val? (Scala) Scala allows the definition of lazy values lazy val maybeUnusedValue = someCostlyInitialization where someCostlyInitialization is evaluated only on the first use of maybeUnusedValue . That is, it is evaluated at most once, and if maybeUnusedValue is never used, it is also never evaluated at all. Is this threadsafe? What are the performance implications of this? If this is to be threadsafe, it has to use some kind of syncronization / use Java volatile in some way. Unfortunately the Scala language specification says nothing about

So I use kotlin for android, and when inflating views, I tend to do the following: private val recyclerView by lazy { find<RecyclerView>(R.id.recyclerView) } This method will work. However, there is a case in which it will bug the app. If this is a fragment, and the fragment goes to the backstack, onCreateView will be called again, and the view hierarchy of the fragment will recreated. Which means, the lazy initiated recyclerView will point out to an old view no longer existent. A solution is like this: private lateinit var recyclerView: RecyclerView And initialise all the properties inside

If a singleton is implemented as follows, class Singleton { private static Singleton instance = new Singleton(); public static Singleton getInstance() { return instance; } } How is this implementation different from the lazy initialization approach? In this case,the instance will be created when the class is loaded and the class itself is loaded only on the first active use (for example, Singleton.getInstance() not when you declare for instance Singleton singleton = null;) Even with lazy initialization approach, the instance is created on the call to getInstance() Am i missing something here?

I usually implement the singleton pattern this way : class Singleton { public: virtual ~Singleton() {} static Singleton& GetInstance() { static Singleton instance; return instance; } private: Singleton(); Singleton(const Singleton&); Singleton& operator=(const Singleton&); } Recently, I ran into this implementation, which is slightly different : class Singleton { public: Singleton(); virtual ~Singleton() {} static Singleton& GetInstance() { return instance; } private: Singleton(const Singleton&); Singleton& operator=(const Singleton&); static Singleton instance; } Singleton Singleton::instance