java饿汉式有啥作用,java单例模式（饿汉式和懒汉式的几种不同写法）

1.饿汉式(直接创建)三种创建方法代码里面都有

第三种静态代码块方式，需要创建个properties文件

package java2;

import java.io.IOException;

import java.util.Properties;

/**

* 单例模式设计步骤：

* 1.构造器私有化

* 2.内部创建对象实例，并用静态变量保存

* 3.向外提供获取的方法

* 强调这是一个单例，我们可以用final修改

*

*/

/**

* 一、饿汉式：在类初始化时直接创建对象，不管你是否需要这个对象,不存在线程安全问题

*

* (1.1)直接创建实例对象

*/

class Singleton1{

public static final Singleton1 INSTANCE = new Singleton1();

private Singleton1(){}

}

/**

* (1.2)枚举类型，就是该类型对象是有限个

*/

enum Singleton2 {

INSTANCE

}

/**

* (1.3)静态代码块方法

*/

class Singleton3{

public static final Singleton3 INSTANCE;

private String info;

//如何构造器传的值需要从文件里获取，那么就需要用到静态代码来实现单例

static {

try {

Properties pro = new Properties();

pro.load(Singleton3.class.getClassLoader().getResourceAsStream("Single.properties"));

INSTANCE = new Singleton3(pro.getProperty("info"));

} catch (IOException e) {

throw new RuntimeException(e);

}

}

private Singleton3(String info){

this.info = info;

}

}

public class Singleton_e {

public static void main(String []args){

Singleton1 singleton1 = Singleton1.INSTANCE;

System.out.println(singleton1);

//枚举类型这里直接打印出来了，因为枚举重写了toString方法

Singleton2 singleton2 = Singleton2.INSTANCE;

System.out.println(singleton2);

Singleton3 singleton3 = Singleton3.INSTANCE;

System.out.println(singleton3);

}

}

懒汉式(用到的时候才创建)三种创建方法

package java2;

/**

* 二、懒汉式：演示创建这个实例对象

*

* (1)构造器私有化

* (2)用一个静态变量保存这个唯一实例

* (3)提供一个静态方法，获取这个实例对象

*/

import java.util.concurrent.*;

/**

* (2.1)多线程下,线程不安全

*/

class Singleton4{

private volatile static Singleton4 INSTANCE = null;

private Singleton4(){

System.out.println(Thread.currentThread().getName()+"\t线程调用构造");

}

public static Singleton4 getINSTANCE() {

if (INSTANCE == null){

INSTANCE = new Singleton4();

}

return INSTANCE;

}

}

/**

* (2.2)改进版volatile+双端检索机制

*/

class Singleton5{

private volatile static Singleton5 INSTANCE = null;

private Singleton5(){

System.out.println(Thread.currentThread().getName()+"\t线程调用构造");

}

//这里用volatile+双端检索机制

public static Singleton5 getINSTANCE() {

try {TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

if (INSTANCE == null) {

synchronized (Singleton5.class)

{

if (INSTANCE == null){

INSTANCE = new Singleton5();

}

}

}

return INSTANCE;

}

}

/**

*(2.3)静态内部类形式，线程安全的

* 在内部类被加载和初始化时，才会创建INSTANCE实例对象

* 静态内部类不会自动随外部类的加载和初始化而初始化，它是要单独去加载和初始化的

* 因为是在内部类加载和初始化时，创建的，因此是线程安全的

*/

class Singleton6{

private Singleton6() { }

//静态内部类(就是类的内部加了个静态的饿汉式？我是这样理解的)

private static class Inner{

private static final Singleton6 INSTANCE = new Singleton6();

}

//获取

public static Singleton6 getInstance(){

return Inner.INSTANCE;

}

}

public class Singleton_lan {

public static void main(String []args) throws ExecutionException, InterruptedException {

//(2.1)多线程下，线程不安全

Singleton4 singleton4 = Singleton4.getINSTANCE();

//(2.2)改进版

Callable callable = new Callable() {

@Override

public Singleton5 call() throws Exception {

return Singleton5.getINSTANCE();

}

};

ExecutorService threadpool = Executors.newFixedThreadPool(2);

Future f1 = threadpool.submit(callable);

Future f2 = threadpool.submit(callable);

Singleton5 s1 = f1.get();

Singleton5 s2 = f2.get();

threadpool.shutdown();

System.out.println(s1 == s2);

System.out.println(s1);

System.out.println(s2);

//(2.3)静态内部类形式

Singleton6 singleton6 = Singleton6.getInstance();

System.out.println(singleton6);

}

}

春_

发布了84 篇原创文章 · 获赞 61 · 访问量 9489

私信

关注

标签：java,饿汉,private,class,INSTANCE,static,单例,public,Singleton5

来源： https://blog.csdn.net/weixin_43736084/article/details/103946500