Java Design Pattern Single example mode (reprint)

Concept:
　　 In Java, the singleton pattern is a common design pattern, and the singleton pattern is divided into three kinds: lazy type single case, a hungry man type single case, registration type single case three kinds.
There are a few features of the Singleton model:
　　 1, the Singleton class can have only one instance.
2, the Singleton class must create its own unique instance on its own.
3, the Singleton class must provide this instance to all other objects.
< Span style= "line-height:1.8; margin:0px; Font-family: Song body; Color:black; padding:0px; " >

First, we look at a classic single-instance implementation.

[Java]View Plaincopyprint?

2. Public class Singleton {
4. private static Singleton uniqueinstance = null;
8. Private Singleton () {
10. //Exists only to defeat instantiation.
12. }
16. public static Singleton getinstance () {
18. if (uniqueinstance = = null) {
20. Uniqueinstance = new Singleton ();
22. }
24. return uniqueinstance;
26. }
28. //Other methods ...
30. }

Singleton by restricting the construction method to private to prevent the class from being instantiated externally, the unique instance of Singleton can only be accessed through the getinstance () method within the same virtual machine scope. (In fact, the Java reflection mechanism is the ability to instantiate a class constructed as private, which basically invalidates all Java Singleton implementations.) This issue is not discussed here, and it is deceiving to assume that the reflection mechanism does not exist. ）

However, the above implementations do not take into account thread safety issues. Thread safety refers to the idea that if your code is in a process where multiple threads are running concurrently, these threads may run the code at the same time. If the result of each run is the same as the single-threaded run, and the value of the other variable is the same as expected, it is thread-safe. Or, the interface provided by a class or program for a thread is an atomic operation or a switchover between multiple threads does not result in ambiguity in the execution of the interface, that is, we do not have to consider the problem of synchronization. Obviously the above implementations do not meet the requirements of thread safety, and many singleton instances are likely to occur in concurrent environments.

[Java]View Plaincopyprint?

2. Package jason.single;
6. Public class Teststream {
8. String name = null;
12. Public String GetName () {
14. return name;
16. }
20. public void SetName (String name) {
22. this.name = name;
24. }
28. Private Teststream () {
30. }
34. private static Teststream ts1 = null;
38. public static Teststream gettest () {
40. if (ts1 = = null) {
42. Ts1 = new Teststream ();
44. }
46. return ts1;
48. }
52. public void Printinfo () {
54. System.out.println ("The name is" + name);
56. }
60. }

[Java]View Plaincopyprint?

2. Package jason.single;
6. Public class Tmain {
8. public static void Main (string[] args) {
10. Teststream ts1 = Teststream.gettest ();
12. Ts1.setname ("Jason");
14. Teststream ts2 = Teststream.gettest ();
16. Ts2.setname ("0539");
20. Ts1.printinfo ();
22. Ts2.printinfo ();
26. if (ts1 = = ts2) {
28. System.out.println ("created is the same instance");
30. }else{
32. System.out.println ("Not the same instance created");
34. }
36. }
38. }

Operation Result:

Conclusion: The result shows that the singleton pattern provides an object-only access point for an object-oriented application, and the entire application can enjoy an instance object regardless of the function it implements.

1. A hungry man type single case class

[Java]View Plaincopyprint?

2. A hungry man Singleton class. When class is initialized, it is self-instantiated
4. Public class Singleton1 {
6. //Private default constructor
8. Private Singleton1 () {}
10. //already self-instantiated
12. private static final Singleton1 single = new Singleton1 ();
14. //Static Factory method
16. public static Singleton1 getinstance () {
18. return single;
20. }
22. }

2. Lazy single-case class

[Java]View Plaincopyprint?

2. Lazy Singleton class. Instantiated at the first call
4. Public class Singleton2 {
6. //Private default constructor
8. Private Singleton2 () {}
10. //Note that there is no final
12. private static Singleton2 single=null;
14. //Static Factory method
16. public synchronized static Singleton2 getinstance () {
18. if (single = null) {
20. Single = new Singleton2 ();
22. }
24. return single;
26. }
28. }

[Java]View Plaincopyprint?

2. Import Java.util.HashMap;
4. Import Java.util.Map;
6. Registered Singleton class.
8. Similar to the method in spring, the class name is registered, the next time from the inside to get directly.
10. Public class Singleton3 {
12. private static map<string,singleton3> Map = new hashmap<string,singleton3> ();
14. static{
16. Singleton3 single = new Singleton3 ();
18. Map.put (Single.getclass (). GetName (), single);
20. }
22. //Protect the default construction child
24. protected Singleton3 () {}
26. //Static factory method to return such unique instances
28. public static Singleton3 getinstance (String name) {
30. if (name = = null) {
32. Name = Singleton3.  Class.getname ();
34. System.out.println ("name = = NULL" +"--->name=" +name);
36. }
38. if (map.get (name) = = null) {
40. try {
42. Map.put (name, (Singleton3) class.forname (name). newinstance ());
44. } catch (Instantiationexception e) {
46. E.printstacktrace ();
48. } catch (Illegalaccessexception e) {
50. E.printstacktrace ();
52. } catch (ClassNotFoundException e) {
54. E.printstacktrace ();
56. }
58. }
60. return Map.get (name);
62. }
64. //A schematic business approach
66. Public String About () {
68. return "Hello, I am Regsingleton.";
70. }
72. public static void Main (string[] args) {
74. Singleton3 single3 = singleton3.getinstance (null);
76. System.out.println (Single3.about ());
78. }
80. }

Java Design Pattern Single example mode (reprint)