java singleton example

Reprinted please indicate the source: http://blog.csdn.net/sinyu890807/article/details/8860649 When writing software, you often need to use the log printing function, which can help you debug and locate problems. After the project is launched, it can also help you analyze data. However, Java Native systems. out. the println () method is rarely used in real project development. Even code check tools such as findbugs think that system is used. out. prin

Concept:　　In Java, the singleton pattern is a common design pattern, there are several types of single-instance pattern, here are 2 kinds: Lazy Type single case, a hungry man type single case.The singleton mode has the following characteristics:1. A singleton class can have only one instance.2. The

The singleton pattern in Java is a widely used design pattern and is one of 23 design patterns in Java. The role of Singleton mode is to ensure that in a Java program, only one program exists for a class.Here is a brief introduction to its two basic ways: a hungry man-style

The following is an implementation of the singleton mode.Public class station {Private Static station ST = new station ();Private int num = 10;Private station (){}Public static station getinstance (){Return st;}Public void upload (){If (St. Num> 0 ){Num --;System. Out. println ("with tickets ");} Else {System. Out. println ("tickets sold out ");}}} Public class demo { Public static void main (string [] ARGs ){ Station ST = station. getinstance ();For

Single-Case mode:Ensure that a class has only one instance and provides a global access pointA Hungry Man: (Thread-safe)public class Singleton {private static Singleton uniqueinstance = new Singleton ();Private Singleton () {}public static Singleton getinstance () {return un

1 PackageCom.dawning.gridview.app.resourcemanagement.service.servicemanagement.discoverresourceutil;2 3 ImportJava.util.concurrent.ExecutorService;4 Importjava.util.concurrent.Executors;5 6 /**7 * Thread pool single case8 * @class Singletontheadpool9 * @date 2015-7-7 pm 3:29:04Ten * @authorWANGHC One */ A Public classSingletontheadpool { - /** - * Single Case the */ - Private Static classsingletonholder{ - Private Static FinalExecutorservice Mypool = Executors.newfixedth

Static voidTest () {System.out.println ("Test invoked."); }}Note: This solves the problem of synchronization, but when the static test () method is called or the static variable i is called, even if you do not need to use the Singleton object, he is already loaded into memory .4. The recommended wording is as follows: using an internal class approach, the JVM guarantees that its member variables are initialized and thread-safe when used with internal

Import Java.util.concurrent.locks.Lock;Import Java.util.concurrent.locks.ReentrantLock;public class Singleton4 {Private Singleton4 () {};private static Singleton4 single = NULL;private static lock lock = new Reentrantlock ();public static Singleton4 getinstance () {if (single = null) {Getsingle ();}return single;}private static void Getsingle () {Bondage 1Lock.lock ();if (single = null) {Single = new Singleton4 ();}Lock.unlock ();Bondage 2 synchronized (singleton4.class)//{ if (single = null)

1. Lazy type Single case/*** Lazy Single case: the most common way of writing * Disadvantage: There will be problems in multithreaded situations, so when multithreading is usually preceded by the getinstance () method with the Synchronized keyword*/classlazysingleton{Private StaticLazysingleton Lazysingleton =NULL; PrivateLazysingleton () {} Public StaticLazysingleton getinstance () {if(lazysingleton==NULL) return NewLazysingleton (); returnLazysingleton; }}2. A hungry man type single

When there are many variables that need to be shared, it takes too long to use a static variable for the entire life cycle of the class. The object is only present in the entire life cycle of the object. // a hungry man type class Single// class once loaded, the object already exists. {privatestaticnewprivatepublic static single getinstance () {return s;}}//Lazy TypeclassSingle2//class is loaded, there are no objects, and only objects are created when the GetInstance method is called. //defer

example instance = new Singleton () can be decomposed into the following pseudo-code:Memory = allocate (); 1: Allocating the object's memory space ctorinstance; 2: Initialize object instance = memory; 3: Set instance to point to the memory address just allocatedHowever, after reordering, the following are:Memory = allocate (); 1: Allocating the object's memory space instance = Memories; 3: Set

StaticMyObject getinstance () {if(MyObject = =NULL) {synchronized(MyObject.class) { if(MyObject = =NULL) {MyObject=NewMyObject (); } } } returnMyObject; }}Output:132019484913201948491320194849But is thread safety at this point?no~ but I can't give a counter-example push to, we have experience, please advise ~Fifth attempt:We also need to add the volatile keyword to the "sin