一,静态常量饿汉式
1.所谓类的单例设计模式,就是采用一定的方法保证在整个系统软件中,对某个类只能实例化一个对象,并且该类只提供一个取得其对象实例的方法(静态方法)
2.步骤
<1>构造器私有化
<2>类的内部创建对象
<3>向外暴露一个静态的公共方法
<4>代码
package 设计模式.单例设计模式.静态常量饿汉式;
import javax.print.attribute.standard.Finishings;
public class Test1 {
public static void main(String []args){
Singleton singleton1=Singleton.getInstance();
Singleton singleton2=Singleton.getInstance();
System.out.println(singleton1==singleton2);
}
}
class Singleton{
//1构造器私有化
private Singleton(){
}
//本类内部创建实例
private final static Singleton simple=new Singleton();
//提供一个共有的静态方法,返回实例对象
public static Singleton getInstance(){
return simple;
}
}
<5>分析
优点:写法简单,就是在类加载的时候实现实例化,避免了线程同步问题
缺点:在类加载的时候就实现实例化可能会导致资源浪费
二,静态代码快饿汉式
package 设计模式.单例设计模式.静态代码快饿汉式;
public class Test1 {
public static void main(String []args){
Singleton singleton1=Singleton.getInstance();
Singleton singleton2=Singleton.getInstance();
System.out.println(singleton1==singleton2);
}
}
class Singleton{
private Singleton(){
}
private static Singleton singleton;
static{
singleton=new Singleton();
}
public static Singleton getInstance(){
return singleton;
}
}
三,线程不安全懒汉式
1.代码
package 设计模式.单例设计模式.线程不安全懒汉式;
public class Test1 {
public static void main(String []args){
Singleton singleton1=Singleton.getInstance();
Singleton singleton2=Singleton.getInstance();
System.out.print("sdas"+(singleton1==singleton2));
}
}
class Singleton{
private static Singleton singleton;
private Singleton(){}
//提供一静态的公有方法
public static Singleton getInstance(){
if(singleton==null){
singleton=new Singleton();
}
return singleton;
}
}
2.优缺点分析
优点:起到了懒加载的效果,与饿汉式相比改善了资源浪费的缺点
缺点:只能在单线程下使用,如果在多线程下使用,一个线程进入到if(singleton==null)判断语句块,还未来得及往下执行,另一个线程也通过了这个判断语句,这时就会产生多个实例
四,线程安全懒汉式
1.代码
package 设计模式.单例设计模式.线程安全懒汉式;
import com.sun.org.apache.xpath.internal.axes.SelfIteratorNoPredicate;
public class Test1 {
public static void main(String []args){
Singleton singleton1=Singleton.getInstance();
Singleton singleton2=Singleton.getInstance();
System.out.println("");
}
}
class Singleton{
private static Singleton singleton;
private Singleton(){}
public static synchronized Singleton getInstance(){
if(singleton==null){
singleton=new Singleton();
}
return singleton;
}
}
2.优缺点分析
优点:解决了线程安全问题
缺点:效率太低
五,双重检查
1.代码
package 设计模式.单例设计模式.双重检查;
public class Test1 {
public static void main(String []args){
Thread2 thread2 =new Thread2();
new Thread(thread2).start();
Thread1 thread1=new Thread1();
new Thread(thread1).start();
}
}
class Thread1 implements Runnable{
public static Singleton singleton;
@Override
public void run() {
int t=100;
while(t>0){
singleton=Singleton.getInstance();
System.out.println(singleton==Thread2.singleton);
t--;
}
}
}
class Thread2 implements Runnable{
public static Singleton singleton;
@Override
public void run() {
int t=100;
while(t>0){
singleton=Singleton.getInstance();
t--;
}
}
}
class Singleton{
private static volatile Singleton singleton;
private Singleton() {
}
public static Singleton getInstance(){
if(singleton==null){
synchronized(Singleton.class){
if(singleton==null){
singleton=new Singleton();
}
}
}
return singleton;
}
}
2.优缺点
优点:保证了线程安全,同时效率也比较高
六,静态内部类
1.代码
package 设计模式.单例设计模式.静态内部类;
public class Test {
public static void main(String []args){
Singleton singleton1=Singleton.getInstance();
Singleton singleton2=Singleton.getInstance();
System.out.println(singleton1==singleton2);
}
}
class Singleton{
//private static volatile Singleton singleton;
private static class SingleDemo{
private static final Singleton sinple=new Singleton();
}
public static synchronized Singleton getInstance(){
return SingleDemo.sinple;
}
}
七,枚举
1.代码
package 设计模式.单例设计模式.枚举;
public class Test {
public static void main(String []args){
Singleton singleton1=Singleton.INSTANCE;
Singleton singleton2=Singleton.INSTANCE;
System.out.println(singleton1==singleton2);
}
}
enum Singleton{
INSTANCE;
public void sayOk(){
System.out.println("ok");
}
}
2.优缺点
优点:避免了多线程同步问题,同时防止反序列化重新创建新的对象