设计模式
单例模式
- 例1:饿汉式,简单实用,推荐使用
package com.singleton;
/**
* 饿汉式
* 类加载到内存后,就实例化一个单例,JVM保证线程安全
* 简单实用,推荐使用!
* 唯一缺点:不管用到与否,类装载时就完成实例化
* Class.forName("")
* (话说你不用的,你装载它干啥)
*/
public class Singleton1 {
private static final Singleton1 INSTANCE = new Singleton1();
private Singleton1(){};
public static Singleton1 getInstance(){
return INSTANCE;
}
public static void main(String[] args) {
Singleton1 instance = Singleton1.getInstance();
Singleton1 instance1 = Singleton1.getInstance();
System.out.println(instance==instance1);
}
}
- 例2:和例1一个意思
package com.singleton;
/**
* 和例1一个意思
*/
public class Singleton2 {
private static final Singleton2 INSTANCE;
static {
INSTANCE = new Singleton2();
}
private Singleton2(){}
public static Singleton2 getInstance(){
return INSTANCE;
}
public static void main(String[] args) {
Singleton2 instance = Singleton2.getInstance();
Singleton2 instance1 = Singleton2.getInstance();
System.out.println(instance==instance1);
}
}
- 例3:懒汉式,虽然达到了按需初始化的目的,但却带来线程不安全的问题
package com.singleton;
/**
* lazy loading
* 也称懒汉式
* 虽然达到了按需初始化的目的,但却带来线程不安全的问题
*/
public class Singleton3 {
private static Singleton3 INSTANCE;
private Singleton3(){}
public static Singleton3 getInstance(){
if(INSTANCE==null){
INSTANCE= new Singleton3();
}
return INSTANCE;
}
public static void main(String[] args) {
for (int i =0;i<100;i++) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Singleton3.getInstance().hashCode());
}
}).start();
}
}
}
- 例4 :懒汉式,通过synchronized解决,但也带来效率下降
package com.singleton;
/**
* lazy loading
* 也称懒汉式
* 虽然达到了按需初始化的目的,但却带来线程不安全的问题
* 可以通过synchronized解决,但也带来效率下降
*/
public class Singleton4 {
private static Singleton4 INSTANCE;
private Singleton4(){};
public static synchronized Singleton4 getInstance(){
if(INSTANCE==null){
INSTANCE=new Singleton4();
}
return INSTANCE;
}
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Singleton4.getInstance().hashCode());
}
}).start();
}
}
}
例5:妄图通过减小同步代码块的方式提高效率,然后不可行,同样会有线程不安全的问题
package com.mashibing.dp.singleton;
/**
* lazy loading
* 也称懒汉式
* 虽然达到了按需初始化的目的,但却带来线程不安全的问题
* 可以通过synchronized解决,但也带来效率下降
*/
public class Mgr05 {
private static Mgr05 INSTANCE;
private Mgr05() {
}
public static Mgr05 getInstance() {
if (INSTANCE == null) {
//妄图通过减小同步代码块的方式提高效率,然后不可行
synchronized (Mgr05.class) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new Mgr05();
}
}
return INSTANCE;
}
public void m() {
System.out.println("m");
}
public static void main(String[] args) {
for(int i=0; i<100; i++) {
new Thread(()->{
System.out.println(Mgr05.getInstance().hashCode());
}).start();
}
}
}
- 例6:
package com.mashibing.dp.singleton;
/**
* lazy loading
* 也称懒汉式
* 虽然达到了按需初始化的目的,但却带来线程不安全的问题
* 可以通过synchronized解决,但也带来效率下降
*/
public class Mgr06 {
private static volatile Mgr06 INSTANCE; //JIT
private Mgr06() {
}
public static Mgr06 getInstance() {
if (INSTANCE == null) {
//双重检查
synchronized (Mgr06.class) {
if(INSTANCE == null) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new Mgr06();
}
}
}
return INSTANCE;
}
public void m() {
System.out.println("m");
}
public static void main(String[] args) {
for(int i=0; i<100; i++) {
new Thread(()->{
System.out.println(Mgr06.getInstance().hashCode());
}).start();
}
}
}
- 例7:静态内部类方式,JVM保证单例,加载外部类时不会加载内部类,这样可以实现懒加载
package com.mashibing.dp.singleton;
/**
* 静态内部类方式
* JVM保证单例
* 加载外部类时不会加载内部类,这样可以实现懒加载
*/
public class Mgr07 {
private Mgr07() {
}
private static class Mgr07Holder {
private final static Mgr07 INSTANCE = new Mgr07();
}
public static Mgr07 getInstance() {
return Mgr07Holder.INSTANCE;
}
public void m() {
System.out.println("m");
}
public static void main(String[] args) {
for(int i=0; i<100; i++) {
new Thread(()->{
System.out.println(Mgr07.getInstance().hashCode());
}).start();
}
}
}