浅谈单例模式的实现方式
2 m2 |& s/ D5 S- _, h! }单例模式(来自菜鸟教程)
4 o5 ]& I" O$ J6 T1 m) V1 w3 Y9 c' g7 c. G
单例模式(Singleton Pattern)是Java中最简单的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象。
) E( |3 w6 S. G t* D1 h单例模式的要求3 y$ K: i3 r% L! W$ M/ M8 [
0 m2 C1 {7 b( i+ G/ k
构造方法必须私有化(确保只有自己能创建)
( y& f' {; l& K: c( ]以静态方法返回实例(外界不能通过new来获取到对象)" o' u# l+ m- J: s3 t2 q9 M
确保对象实例只有一个(只对类进行一次实例化,以后都直接获取第一次实例化的对象)) z& g0 Q( c" l8 K1 M9 [5 B
单例模式的实现: B- \- R; J( O5 S6 u: h T3 u1 G! H
f" }- S3 T2 V+ R% p# t* R1、懒汉式(线程不安全)
5 g# }9 y e# _5 t6 N) W' P- R) k
描述:这种方式是最基本的实现方式,但是不支持多线程。因为没有加锁,在多线程不能正常工作6 m! ]: G* Z) M; Z9 U
//懒汉式(线程不安全)
0 f7 j: y( x6 Q0 J( Jpublic class Singleton { * m: u; t7 X, u- _0 R8 {
private static Singleton instance;
. w, n3 d9 L ^" a: E2 l% ]
7 d9 r. K3 c1 G$ U9 T4 K( t private Singleton (){} ! k9 t7 i+ _2 o/ h/ N
5 G1 R! _% v, X2 g6 v. i
public static Singleton getInstance() {
- \$ t, X) @! q' {2 i5 n) e if (instance == null) {
4 ?. W5 v5 r) a instance = new Singleton();
, w# [1 Y3 S1 {% P: s5 u6 O7 \! O% ~7 Q }
. G* k; S& ]; d+ F: Q9 M* G return instance; 3 }- w' V/ l1 a5 G$ B4 O
} + f) p. G) z/ w7 E: t' {
}
' G! t! G+ H9 T7 x0 |2、懒汉式(线程安全) 描述:能够在多线程下正常工作,但是,效率极低 //懒汉式(线程安全)
& J$ |4 C9 \0 Wpublic class Singleton { , g5 x1 W4 s' \
private static Singleton instance; ' n( k! N6 f% l0 r y
9 P' ?- a3 ^# \& R t private Singleton (){} 3 i6 L/ h. m' u4 O
% P! }* y8 a! j6 X1 W' S public static synchronized Singleton getInstance() { 3 X) d6 B% ?0 h
if (instance == null) {
[" T- W) t- B4 C4 H* c: a1 g instance = new Singleton();
- H3 y4 ]5 F/ U; J0 r7 z }
8 `0 \$ C# M) @" h) e* E1 z: e* j return instance;
8 l( x6 l! V0 g/ Q/ m } 4 _% M" {2 o0 N- u/ n
}1 H- {% ~" w" e3 s( m: n
6 c V. J4 B( y. \. Y3 v3、双重校验锁(DCL,即double-checked locking)(线程安全) 描述:对懒汉式(线程安全)的优化,采用双锁的机制,安全且在多线程情况下能保持高性能 - v# D; g" T" K
//双重校验锁
2 Z: p6 p4 k/ k& E7 @6 x& kpublic class Singleton {. d$ k J0 `% L( i8 s2 R
private volatile static Singleton instance;
5 s: g* u) P8 n3 V# y# \' {" j5 [, J& [ D6 _0 p5 }3 U
private Singleton() {5 p! X6 o4 g! |2 l8 u# X
) C! |/ o' n8 m3 ]% ^8 A }
/ Y9 l; J; F& B( v7 |: [
7 W8 W' k6 K8 R- f% a public static Singleton getInstance() {3 Y: F4 M1 z! S; e3 x) I8 u) X
if (instance == null) {
H: ~/ X s/ i synchronized (Singleton.class) {3 M+ H' `0 R* L7 O4 {
if (instance == null) {& j/ p+ \5 |9 ^$ h% V) W) }/ p
instance = new Singleton(); r! q, W% Y6 r/ s w/ W$ y9 a
}
# x# z- U( j0 E' F) Y! o" w8 Z }( ~9 b5 ?; n' M: \8 x
}4 V+ N! B- W2 M- I- _7 Y
return instance;
+ {7 `% \+ F' w3 ~: C5 F- z }" W' e4 g9 l$ c$ ?, L2 W
}
5 w0 J K4 W7 |; j+ q, ]+ o4 O, G* d! }; i
- ^$ ? e# R& p, J! u4、饿汉式(线程安全) 描述:这种方式比较常用,但容易产生垃圾对象
' s8 r$ o# u; }' o//饿汉式5 z ?1 o* X" ^' B C
public class Singleton {' X3 u4 o+ G) H& w1 u
private static Singleton instance = new Singleton();
' j0 j3 _* h( \3 K( j4 b/ l* z( H3 t+ x
private Singleton() {
: ]* S& M; R/ ?3 J
; |+ Q" p2 I# V% O }+ u$ n3 F9 u; u* G2 P' H
7 }* y" U) s5 ?) Y public static Singleton getInstance() {
B6 e9 C {( z+ u return instance;7 [: K" i8 X( I2 y7 b
}6 Z: L. n4 v( s7 U ~
}+ F& T( d5 M# \6 d9 H1 T0 \1 E0 ~! I
4 r5 a5 Q: ]; c) c) [
' I3 v0 z, I" m/ X5 j, H) ]: B5、静态内部类(线程安全) 描述:这种方式达到跟双重校验锁一样的效果,这种方式只适用于静态域的情况,双重校验锁可在实例域需要延迟初始化时使用 //静态内部类
/ _. \. A+ v$ S% y9 w- `5 f4 J Ppublic class Singleton {# R( S6 B7 F6 d( l+ ~) s- D) k
private static class SingletonHolder {% a3 V# B5 X, X
private static final Singleton INSTANCE = new Singleton();2 t; I" ]. H1 K' F! q
}$ {5 D/ D- M, x Z
2 B! z/ X1 a5 t" f% U private Singleton() {/ }$ j. |% \" g/ q) X( H2 m/ H
, j* y1 N# ^+ C }
; O/ a% s" t4 I! ?
; A3 w& Q2 o+ n4 g* x7 V public static final Singleton getInstance() {$ ^: e, z5 M% r/ c
return SingletonHolder.INSTANCE;( [ a' e- p& l! R
}
* h B. u) M; N9 q}, Y/ h% b. V$ r) F# {
! Z- D$ H( ^( H% n% g6、枚举(线程安全) 描述:这种方式还没有被广泛采用,但是这种实现是单例模式的最佳方法。更简洁、自动支持序列化机制、绝对防止多次实例化
$ ^5 y! b; {" W4 d/ y, j! o' g//枚举
! w/ A( R0 K/ F- r7 gpublic enum Singleton {
; Y5 t; T8 q( W% u INSTANCE;
" l* ~; I5 e$ s# ?$ [2 X. |/ S, C& c y; [& r
public void whateverMethod() {- w: q, [8 B* b
% g- e- a) a4 x
}2 R5 y! D- Y9 u+ q* f$ W2 ]
}
3 C- K E$ l l# C9 l5 D9 r$ U: z4 w! t! @9 V6 C
6 g) _; x9 H y a9 O* u1 R总结
: N8 L" z; P0 m* {' Z- i# Q
+ T, F2 I; O; D- a* T: D一般情况下,不建议使用第1种和第2种懒汉方式,建议使用第4种饿汉方式。只有在明确实现lazy loading时,才会使用第5种静态内部类方式。如果涉及到反序列化创建对象时,可以使用第6种枚举方式。如果有其他需求,可以考虑使用第3种双重校验锁方式。! u1 p4 K+ }* u& F
PS:开始面临着春招,好多面经都有说到设计模式。最常见的面试题就是讲一讲单例模式的实现和理解,所以我写一下,加深我对单例模式的理解和印象。觉得对你有帮助的话可以点点赞,谢谢啦~~~+ ?7 \5 q* Z M7 Y6 A, j
————————————————: o: U& S- L4 o: G' A8 E2 h
. u1 H, G2 s5 V
" K; k) ~. {: g5 m0 h( t8 T) E% w
! B* M, @# S+ q2 t8 j7 s/ l
, S5 A+ I1 ~% d2 T- K; `( U( z) b
6 L+ T; X! ^& j5 n, {7 E, l( V9 Y
/ E* R0 J2 d0 o2 W& \. f" S$ F3 q
. f8 s+ ]. ~ X* S; ]7 U! a5 T O- |( s$ T
原文链接:https://blog.csdn.net/weixin_37686415/article/details/105164764# y# j. h* b7 p/ Q7 Q5 V! ]0 X* |
( O- R8 h6 d J& W& v O
: P5 }/ }, ~# Q! Q9 k: y5 n4 w1 X |