Shulou(Shulou.com)06/03 Report--

This article mainly explains the "brief introduction to Java delayed initialization". The content in the article is simple and clear, and it is easy to learn and understand. Please follow the editor's train of thought to study and learn "Java delayed initialization brief introduction".

Delayed initialization

There are generally several scenarios where initialization is delayed:

For objects that consume more resources: this can not only save some resources, but also speed up the creation of objects, thereby improving overall performance.

Some data cannot be obtained at startup: for example, some context information may only be set in other interceptors or processing, so that the current bean may not be able to get the value of the corresponding variable when it is loaded. Using deferred initialization can be obtained when it is actually called, and the validity of the data can be ensured by delay.

Lambda introduced in Java8 provides great convenience for us to implement deferred operations, such as Stream, Supplier, and so on. Here are a few examples.

Lambda

Supplier

The purpose of _ delayed initialization _ is achieved by calling the get () method to calculate and generate and return specific objects instead of calculating when Supplier is defined. However, concurrency often needs to be considered in use, that is, to prevent multiple instantiations, just like the @ Lazy annotation of Spring.

Public class Holder {/ / by default, the synchronization method private Supplier heavy = ()-> createAndCacheHeavy () triggered when heavy.get () is called for the first time; public Holder () {System.out.println ("Holder created");} public Heavy getHeavy () {/ / heavy has pointed to the new instance after the first call, so synchronized return heavy.get () will not be executed later. } / /... Class is defined in the private synchronized Heavy createAndCacheHeavy () {/ / method. Note the difference between the class and the nested class in the class when loading. Class HeavyFactory implements Supplier {/ / initialize private final Heavy heavyInstance = new Heavy (); public Heavy get () {/ / returns a fixed value return heavyInstance each time }} / / the first call to the method will redirect heavy to the new Supplier instance if (! HeavyFactory.class.isInstance (heavy)) {heavy = new HeavyFactory ();} return heavy.get ();}}

When an instance of Holder is created, an instance of Heavy has not yet been created. Let's assume that three threads will call the getHeavy method, with the first two threads calling at the same time and the third thread calling at a later time.

When the current two threads call this method, they both call the createAndCacheHeavy method, because the method is synchronous. So the first thread enters the method body and the second thread begins to wait. In the method body, it is first determined whether the current heavy is an instance of HeavyInstance.

If not, the heavy object is replaced with an instance of type HeavyFactory. Obviously, when the first thread performs the judgment, the heavy object is just an instance of Supplier, so the heavy is replaced with an instance of HeavyFactory, and the heavy instance is actually instantiated.

By the time the second thread enters to execute the method, heavy is already an instance of HeavyFactory, so it immediately returns (that is, heavyInstance). When the third thread executes the getHeavy method, because the heavy object is already an instance of HeavyFactory, it directly returns the desired instance (that is, heavyInstance), which has nothing to do with the synchronization method createAndCacheHeavy.

The above code actually implements a lightweight virtual proxy pattern (Virtual Proxy Pattern). It ensures the correctness of lazy loading in various environments.

There is also a delegate-based implementation that is easier to understand:

Https://gist.github.com/taichi/6daf50919ff276aae74f

Import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; import java.util.function.Supplier; public class MemoizeSupplier implements Supplier {final Supplier delegate; ConcurrentMap

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.