Java Basics-Single-column design pattern

Concept:
　　In Java, the singleton pattern is a common design pattern, there are several types of single-instance pattern, here are three kinds: lazy type single case, a hungry man type single case, registration type single case.
The singleton mode has the following characteristics:
　　1, the Singleton class can have only one instance.
　　2, the Singleton class must create its own unique instance.
　　3. The Singleton class must provide this instance to all other objects.
Singleton mode ensures that a class has only one instance, and instantiates itself and provides this instance to the entire system. In a computer system, the driver objects of the thread pool, cache, log Object, dialog box, printer, and video card are often designed as singleton. These apps have more or less the functionality of the resource manager. Each computer can have several printers, but only one printer Spooler to prevent both print jobs from being output to the printer at the same time. Each computer can have several communication ports, and the system should centrally manage these communication ports to prevent a communication port from being called simultaneously by two requests. In short, the selection of Singleton mode is to avoid inconsistent state, to avoid long-running political.

Today we write lazy and a hungry man.

First, a hungry man.

Code as follows

Class single//A Hungry man type
{
Static single S = new single ();
Private single () {}

public void Speak () {
System.out.println ("Haoren");
}

public static single made () {
return s;
}
}

We can see that a hungry man is already ready to eat, and has been new since the beginning. That means he's already got the chopsticks for dinner.

And then the lazy type.

Code as follows

Class single//Lazy type
{
Static single s = null;
Private single () {}

public void Speak () {
System.out.println ("Haoren");
}

public static single made () {
if (s==null)
s = new single ();
return s;
}
}

We can see the lazy man. He seems to eat not very much care to eat before you have to insist on the food delicious not also the news smell and then eat =2333

The contrast between them

1. Thread Safety:

A hungry man is inherently thread-safe and can be used directly for multithreading without problems.

2. Resource Loading and performance:

A hungry man a static object is instantiated at the same time as the class is created, and will occupy a certain amount of memory regardless of whether the singleton will be used later, but correspondingly, the speed will be faster on the first call because its resources have been initialized,

And the lazy type as the name implies, will delay loading, in the first use of the singleton when the object will be instantiated, the first call to do the initialization, if you want to do more work, performance will be somewhat delayed, and then the same as the A Hungry man type.

Java Basics-Single-column design pattern