java基础--多线程之线程安全的单例模式

最新推荐文章于 2021-01-27 15:59:59 发布
最新推荐文章于 2021-01-27 15:59:59 发布
阅读量136 收藏
点赞数
分类专栏： Java
Java 同时被 3 个专栏收录
7 篇文章 0 订阅
订阅专栏
多线程
2 篇文章 0 订阅
订阅专栏
线程安全
1 篇文章 0 订阅
订阅专栏

java多线程之线程安全的单例模式


概念：
　　java中单例模式是一种常见的设计模式，单例模式分三种：懒汉式单例、饿汉式单例、登记式单例三种。
　　单例模式有一下特点：
　　1、单例类只能有一个实例。
　　2、单例类必须自己创建自己的唯一实例。
　　3、单例类必须给所有其他对象提供这一实例。
　　单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机，但只能有一个Printer Spooler，以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。总之，选择单例模式就是为了避免不一致状态，避免政出多头。

这里主要详细介绍两种：懒汉式和饿汉式

一、立即加载/饿汉式

在调用方法前，实例就已经被创建，代码：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.weishiyao.learn.day8.singleton.ep1;
 
public class MyObject {
   // 立即加载方式==恶汉模式
   private static MyObject myObject = new MyObject();
 
   private MyObject() {
   }
   
   public static MyObject getInstance() {
     // 此代码版本为立即加载
     // 此版本代码的缺点是不能有其他实例变量
     // 因为getInstance()方法没有同步
     // 所以有可能出现非线程安全的问题
     return myObject;
   }
}

创建线程类

?
1
2
3
4
5
6
7
8
package com.weishiyao.learn.day8.singleton.ep1;
 
public class MyThread extends Thread {
   @Override
   public void run() {
     System.out.println(MyObject.getInstance().hashCode());
   }
}

创建运行类

?
1
2
3
4
5
6
7
8
9
10
11
12
package com.weishiyao.learn.day8.singleton.ep1;
 
public class Run {
   public static void main(String[] args) {
     MyThread t1 = new MyThread();
     MyThread t2 = new MyThread();
     MyThread t3 = new MyThread();
     t1.start();
     t2.start();
     t3.start();
   }
}

运行结果
 167772895
 167772895
 167772895
hashCode是同一个值，说明对象也是同一个，说明实现了立即加载型的单利模式

二、延迟加载/懒汉式

在调用方法以后实例才会被创建，实现方案可以是将实例化放到无参构造函数当中，这样只有当调用的时候才会创建对象的实例，代码：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.weishiyao.learn.day8.singleton.ep2;
 
public class MyObject {
   private static MyObject myObject;
   
   private MyObject() {
     
   }
   
   public static MyObject getInstance() {
     // 延迟加载
     if (myObject != null ) {
       
     } else {
       myObject = new MyObject();
     }
     return myObject;
   }
}

创建线程类

?
1
2
3
4
5
6
7
8
package com.weishiyao.learn.day8.singleton.ep2;
 
public class MyThread extends Thread {
   @Override
   public void run() {
     System.out.println(MyObject.getInstance().hashCode());
   }
}

创建运行类

?
1
2
3
4
5
6
7
8
package com.weishiyao.learn.day8.singleton.ep2;
 
public class Run {
   public static void main(String[] args) {
     MyThread t1 = new MyThread();
     t1.start();
   }
}

运行结果

167772895

这样虽然取出了一个对象的实例，但是如果在多线程的环境中，就会出现多个实例的情况，这样就不是单例模式了

运行测试类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.weishiyao.learn.day8.singleton.ep2;
 
public class Run {
   public static void main(String[] args) {
     MyThread t1 = new MyThread();
     MyThread t2 = new MyThread();
     MyThread t3 = new MyThread();
     MyThread t4 = new MyThread();
     MyThread t5 = new MyThread();
     t1.start();
     t2.start();
     t3.start();
     t4.start();
     t5.start();
   }
}

运行结果

980258163
1224717057
1851889404
188820504
1672864109
既然出现问题，就要解决问题，在懒汉模式中的多线程的解决方案，代码：

第一种方案，最常见的，加synchronized，而synchronized可以加到不同的位置

第一种，方法锁

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package com.weishiyao.learn.day8.singleton.ep3;
 
public class MyObject {
   private static MyObject myObject;
   
   private MyObject() {
     
   }
   
   synchronized public static MyObject getInstance() {
     // 延迟加载
     try {
       if (myObject != null ) {
         
       } else {
         // 模拟在创建对象之前做一些准备性的工作
         Thread.sleep( 2000 );
         myObject = new MyObject();
       }
       
     } catch (InterruptedException e) {
       e.printStackTrace();
     }
     return myObject;
   }
}

这种synchronized的同步方案导致效率过于低下，整个方法都被锁住

第二种synchronized使用方案

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package com.weishiyao.learn.day8.singleton.ep3;
 
public class MyObject {
   private static MyObject myObject;
   
   private MyObject() {
     
   }
   
   public static MyObject getInstance() {
     // 延迟加载
     try {
       synchronized (MyObject. class ) {
         if (myObject != null ) {
           
         } else {
           // 模拟在创建对象之前做一些准备性的工作
           Thread.sleep( 2000 );
           myObject = new MyObject();
         }
       }
       
       
     } catch (InterruptedException e) {
       e.printStackTrace();
     }
     return myObject;
   }
}

这种方法效率一样很低，方法内的所有代码都被锁住，只需要锁住关键代码就好，第三种synchronized使用方案
package com.weishiyao.learn.day8.singleton.ep3;

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class MyObject {
   private static MyObject myObject;
   
   private MyObject() {
     
   }
   
   public static MyObject getInstance() {
     // 延迟加载
     try {
         if (myObject != null ) {
           
         } else {
           // 模拟在创建对象之前做一些准备性的工作
           Thread.sleep( 2000 );
           synchronized (MyObject. class ) {
             myObject = new MyObject();
           }
       }
       
       
     } catch (InterruptedException e) {
       e.printStackTrace();
     }
     return myObject;
   }
}

这么写看似是最优方案了，但是，运行一下结果，发现，其实它是非线程安全的

结果：

1224717057
971173439
1851889404
1224717057
1672864109
Why？

虽然锁住了对象创建的语句，每次只能有一个线程完成创建，但是，当第一个线程进来创建完成Object对象以后，第二个线程进来还是可以继续创建的，因为我们紧紧只锁住了创建语句，这个问题解决方案

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package com.weishiyao.learn.day8.singleton.ep3;
 
public class MyObject {
   private static MyObject myObject;
   
   private MyObject() {
     
   }
   
   public static MyObject getInstance() {
     // 延迟加载
     try {
         if (myObject != null ) {
           
         } else {
           // 模拟在创建对象之前做一些准备性的工作
           Thread.sleep( 2000 );
           synchronized (MyObject. class ) {
             if (myObject == null ) {
               myObject = new MyObject();
             }
           }
       }
       
       
     } catch (InterruptedException e) {
       e.printStackTrace();
     }
     return myObject;
   }
}

只需要在锁里面再添加一个判断，就可以保证单例了，这个是DCL双检查机制

结果如下：

1224717057
1224717057
1224717057
1224717057
1224717057
 三、使用内置静态类实现单例

主要代码

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.weishiyao.learn.day8.singleton.ep4;
 
public class MyObject {
   // 内部类方式
   private static class MyObjectHandler {
     private static MyObject myObject = new MyObject();
   }
 
   public MyObject() {
   }
   
   public static MyObject getInstance() {
     return MyObjectHandler.myObject;
   }
}

线程类代码

?
1
2
3
4
5
6
7
8
package com.weishiyao.learn.day8.singleton.ep4;
 
public class MyThread extends Thread {
   @Override
   public void run() {
     System.out.println(MyObject.getInstance().hashCode());
   }
}

运行类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.weishiyao.learn.day8.singleton.ep4;
 
public class Run {
   public static void main(String[] args) {
     MyThread t1 = new MyThread();
     MyThread t2 = new MyThread();
     MyThread t3 = new MyThread();
     MyThread t4 = new MyThread();
     MyThread t5 = new MyThread();
     t1.start();
     t2.start();
     t3.start();
     t4.start();
     t5.start();
   }
}

结果

1851889404
1851889404
1851889404
1851889404
1851889404
通过内部静态类，得到了线程安全的单例模式

四、序列化和反序列化单例模式

内置静态类可以达到线程安全的问题，但如果遇到序列化对象时，使用默认方式得到的结果还是多例的

MyObject代码

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package com.weishiyao.learn.day8.singleton.ep5;
 
import java.io.Serializable;
 
public class MyObject implements Serializable {
   
   /**
    *
    */
   private static final long serialVersionUID = 888L;
 
   // 内部类方式
   private static class MyObjectHandler {
     private static MyObject myObject = new MyObject();
   }
 
   public MyObject() {
   }
   
   public static MyObject getInstance() {
     return MyObjectHandler.myObject;
   }
   
//  protected MyObject readResolve() {
//    System.out.println("调用了readResolve方法！");
//    return MyObjectHandler.myObject;
//  }
}

业务类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
package com.weishiyao.learn.day8.singleton.ep5;
 
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
 
public class SaveAndRead {
   public static void main(String[] args) {
     try {
       MyObject myObject = MyObject.getInstance();
       FileOutputStream fosRef = new FileOutputStream( new File( "myObjectFile.txt" ));
       ObjectOutputStream oosRef = new ObjectOutputStream(fosRef);
       oosRef.writeObject(myObject);
       oosRef.close();
       fosRef.close();
       System.out.println(myObject.hashCode());
     } catch (FileNotFoundException e) {
       e.printStackTrace();
     } catch (IOException e) {
       e.printStackTrace();
     }
     FileInputStream fisRef;
     try {
       fisRef = new FileInputStream( new File( "myObjectFile.txt" ));
       ObjectInputStream iosRef = new ObjectInputStream(fisRef);
       MyObject myObject = (MyObject) iosRef.readObject();
       iosRef.close();
       fisRef.close();
       System.out.println(myObject.hashCode());
     } catch (FileNotFoundException e) {
       e.printStackTrace();
     } catch (IOException e) {
       e.printStackTrace();
     } catch (ClassNotFoundException e) {
       e.printStackTrace();
     }
     
     
   }
}

结果

 970928725
 1099149023
两个不同的hashCode，证明并不是同一个对象，解决方案，添加下面这段代码

?
1
2
3
4
protected MyObject readResolve() {
    System.out.println( "调用了readResolve方法！" );
    return MyObjectHandler.myObject;
  }

在反序列化的时候调用，可以得到同一个对象

 System.out.println(myObject.readResolve().hashCode());
结果

 1255301379
 调用了readResolve方法！
 1255301379
相同的hashCode，证明得到了同一个对象

五、使用static代码块实现单例

静态代码块中的代码在使用类的时候就已经执行了，所以可以应用静态代码快这个特性来实现单利模式

MyObject类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.weishiyao.learn.day8.singleton.ep6;
 
public class MyObject {
   private static MyObject instance = null ;
 
   private MyObject() {
     super ();
   }
   
   static {
     instance = new MyObject();
   }
   
   public static MyObject getInstance() {
     return instance;
   }
}

线程类

?
1
2
3
4
5
6
7
8
9
10
package com.weishiyao.learn.day8.singleton.ep6;
 
public class MyThread extends Thread {
   @Override
   public void run() {
     for ( int i = 0 ; i < 5 ; i++) {
       System.out.println(MyObject.getInstance().hashCode());
     }
   }
}

运行类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.weishiyao.learn.day8.singleton.ep6;
 
public class Run {
   public static void main(String[] args) {
     MyThread t1 = new MyThread();
     MyThread t2 = new MyThread();
     MyThread t3 = new MyThread();
     MyThread t4 = new MyThread();
     MyThread t5 = new MyThread();
     t1.start();
     t2.start();
     t3.start();
     t4.start();
     t5.start();
   }
}

运行结果：

1678885403
1678885403
1678885403
1678885403
1678885403
1678885403
1678885403
1678885403
1678885403
1678885403
1678885403
1678885403
1678885403
1678885403
1678885403
1678885403
1678885403
1678885403
1678885403
1678885403
1678885403
1678885403
1678885403
1678885403
1678885403
通过静态代码块只执行一次的特性也成功的得到了线程安全的单例模式

六、使用enum枚举数据类型实现单例模式

枚举enum和静态代码块的特性类似，在使用枚举时，构造方法会被自动调用，也可以用来实现单例模式

MyObject类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package com.weishiyao.learn.day8.singleton.ep7;
 
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
 
 
public enum MyObject {
   connectionFactory;
   
   private Connection connection;
   
   private MyObject() {
     try {
       System.out.println( "调用了MyObject的构造" );
       String url = "jdbc:mysql://172.16.221.19:3306/wechat_1?useUnicode=true&characterEncoding=UTF-8" ;
       String name = "root" ;
       String password = "111111" ;
       String driverName = "com.mysql.jdbc.Driver" ;
       Class.forName(driverName);
       connection = DriverManager.getConnection(url, name, password);
     } catch (ClassNotFoundException e) {
       e.printStackTrace();
     } catch (SQLException e) {
       e.printStackTrace();
     }
   }
   
   public Connection getConnection() {
     return connection;
   }
}

线程类

?
1
2
3
4
5
6
7
8
9
10
package com.weishiyao.learn.day8.singleton.ep7;
 
public class MyThread extends Thread {
   @Override
   public void run() {
     for ( int i = 0 ; i < 5 ; i++) {
       System.out.println(MyObject.connectionFactory.getConnection().hashCode());
     }
   }
}

运行类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.weishiyao.learn.day8.singleton.ep7;
 
public class Run {
   public static void main(String[] args) {
     MyThread t1 = new MyThread();
     MyThread t2 = new MyThread();
     MyThread t3 = new MyThread();
     MyThread t4 = new MyThread();
     MyThread t5 = new MyThread();
     t1.start();
     t2.start();
     t3.start();
     t4.start();
     t5.start();
   }
}

运行结果

调用了MyObject的构造
56823666
56823666
56823666
56823666
56823666
56823666
56823666
56823666
56823666
56823666
56823666
56823666
56823666
56823666
56823666
56823666
56823666
56823666
56823666
56823666
56823666
56823666
56823666
56823666
56823666
上面这种写法将枚举类暴露了，违反了“职责单一原则”，可以使用一个类将枚举包裹起来

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
package com.weishiyao.learn.day8.singleton.ep8;
 
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
 
 
public class MyObject {
   
   public enum MyEnumSingleton {
     connectionFactory;
     
     private Connection connection;
     
     private MyEnumSingleton() {
       try {
         System.out.println( "调用了MyObject的构造" );
         String url = "jdbc:mysql://172.16.221.19:3306/wechat_1?useUnicode=true&characterEncoding=UTF-8" ;
         String name = "root" ;
         String password = "111111" ;
         String driverName = "com.mysql.jdbc.Driver" ;
         Class.forName(driverName);
         connection = DriverManager.getConnection(url, name, password);
       } catch (ClassNotFoundException e) {
         e.printStackTrace();
       } catch (SQLException e) {
         e.printStackTrace();
       }
     }
     
     public Connection getConnection() {
       return connection;
     }
   }
   
   public static Connection getConnection() {
     return MyEnumSingleton.connectionFactory.getConnection();
   }
}

更改线程代码

?
1
2
3
4
5
6
7
8
9
10
package com.weishiyao.learn.day8.singleton.ep8;
 
public class MyThread extends Thread {
   @Override
   public void run() {
     for ( int i = 0 ; i < 5 ; i++) {
       System.out.println(MyObject.getConnection().hashCode());
     }
   }
}

结果
调用了MyObject的构造
1948356121
1948356121
1948356121
1948356121
1948356121
1948356121
1948356121
1948356121
1948356121
1948356121
1948356121
1948356121
1948356121
1948356121
1948356121
1948356121
1948356121
1948356121
1948356121
1948356121
1948356121
1948356121
1948356121
1948356121
1948356121

文章转自：http://www.jb51.net/article/81629.htm

关于serialVersionUID的介绍：https://blog.csdn.net/qq_27093465/article/details/78544505

白马非马啊
关注
专栏目录
java单例模式线程安全_Java单例模式以及线程安全性的保证
weixin_32006655的博客
02-15 229
1.单例模式有什么用处？有一些对象只能使用一个，例如：数据库连接、线程池(threadpool)、缓存(cache)、对话框、处理偏好(preferences)设置和这侧表(registry)的对象、日志对象、充当打印机、显卡等设备的驱动程序的对象，即用于管理共享的资源。这种对象只能有一个实例，制造多个会导致问题。2.最经典的单例模式？/***1.利用一个私有静态变量来记录Singleton类的...
java线程安全定义了什么单例_Java中四种线程安全的单例模式实现方式
weixin_36016076的博客
02-28 229
第一种：饿汉模式(线程安全)publicclassSingle2{privatestaticSingle2instance=newSingle2();privateSingle2(){System.out.println("Single2:"+System.nanoTime());}publicstaticSingle2getInstance(){returnin...
(Java多线程学习)单例模式与多线程
Geoooo的博客
04-07 499
单例模式在应用中比较常见，比如我们的web系统中service层和dao层的对象就是单例模式，如果控制层采用的是struts的话是多例模式，如果是SpringMVC的话就是单例模式。（这里涉及的是spring的作用域） 　　本文主要研究在多线程环境中如何确保在多线程环境下使用单例模式是安全的、正确的。 1.立即加载/"饿汉模式" 　　立即加载就是使用类的时候已经将对象创建完毕，常用的办法就...
五种单例模式与线程安全
weixin_33737134的博客
12-03 162
2019独角兽企业重金招聘Python工程师标准>>> ...
java线程安全的单例模式分析
qq_24693491的博客
05-21 192
本文针对于单例模式中对象创建中的线程安全问题。主要以懒汉式，饿汉式，静态内部类，枚举类分析在调用时创建对象的线程安全问题。 1.饿汉式 类加载会导致该单实例对象被创建 // 问题1：为什么加 final // 问题2：如果实现了序列化接口, 还要做什么来防止反序列化破坏单例 public final class HungrySingleton implements Serializable { // 问题3：为什么设置为私有? 是否能防止反射创建新的实例? private
Java 单例模式线程安全问题
08-29
然而，在多线程环境下，单例模式可能会遇到线程安全问题，因为多个线程可能会同时访问同一个实例，从而导致数据不一致和其他问题。 在 Java 中，单例模式的实现可以使用双重检查锁机制、静态内部类和枚举类型等方式...
java多线程之线程安全的单例模式
09-02
在多线程环境下，线程安全的单例模式尤其重要，因为如果不正确地实现，可能会导致多个线程创建多个实例，违反了单例模式的基本原则。本文将详细介绍Java中线程安全的单例模式，包括懒汉式和饿汉式两种实现方式。 1....
Java多线程-解决单例模式中的懒汉式的线程安全问题
最新发布
02-01
### Java多线程—解决单例模式中的懒汉式的线程安全问题 #### 一、单例设计模式的线程安全问题 ##### （1）饿汉式没有线程安全问题 **饿汉式**是一种非常典型的单例模式实现方式，其特点是在类加载时就完成了实例...
Java多线程实战之单例模式与多线程的实例详解
08-26
Java多线程实战之单例模式与多线程的实例详解 单例模式是Java多线程编程中最...Java多线程实战之单例模式与多线程的实例详解中，我们讨论了立即加载/饿汉模式和延迟加载/懒汉模式，并且讨论了如何解决线程安全问题。
计算机后端-Java-Java核心基础-第20章 多线程 11. 线程安全的单例模式之懒汉式.avi
05-22
计算机后端-Java-Java核心基础-第20章 多线程 11. 线程安全的单例模式之懒汉式.avi
Java中创建单例模式的五种方法及线程安全
wk51920的专栏
09-04 908
背景        单例模式在日常工程项目中应用十分广泛，但是如果没有考虑线程安全的问题，可能会在多线程环境下产生错误的结果，生成多个实例。公共类        以下两个类，是本次实验中用到的两个公共类，SingletonFactory用于创建各种单例对象，SingletonTest用于测试各种单例模式的线程安全性。public interface SingletonFactory { pu
高并发下线程安全的单例模式（最全最经典）
热门推荐
05-11 14万+
在所有的设计模式中，单例模式是我们在项目开发中最为常见的设计模式之一，而单例模式有很多种实现方式，你是否都了解呢？高并发下如何保证单例模式的线程安全性呢？如何保证序列化后的单例对象在反序列化后任然是单例的呢？这些问题在看了本文之后都会一一的告诉你答案，赶快来阅读吧！
Java 线程安全的单例模式
克念的blog
05-14 1162
第一种，通过synchronized 关键字双重非空判断 public class ThreadSafeSingleton { //使用volatile关键字，可以保证当ThreadSafeSingleton对象在第一个线程中创建完毕的时候，其它的线程可以立马感知到 private static volatile ThreadSafeSingleton threadSafeS...
java单例模式与线程安全
hb_csu的博客
05-30 8210
设计模式在软件架构设计中被经常使用，掌握常用的设计模式对于设计软件系统非常重要。单例模式作为设计模式中最简单和常用的一种模式，java中单例模式具有多种实现方式，以下会对各种实现进行解析。 1、单例模式概念： 顾名思义，单例模式指的是在软件系统运行过程中，某个类只存在一个实例。因此一个类实现单例模式时需要具备以下3个条件： 1）类的内部定义一个该类的静态私有成员变量； 2）构造方法为私...
线程安全的单例模式
szl的专栏
10-27 1041
单例模式单例模式是一种常见的设计模式，单例模式分三种：懒汉式单例、饿汉式单例、登记式单例三种。单例模式有一下特点：1、单例类只能有一个实例。2、单例类必须自己自己创建自己的唯一实例。3、单例类必须给所有其他对象提供这一实例。一、懒汉式单例在类被加载的时候，唯一实例已经被创建。这个设计模式在Java中容易实现，在别的语言中难以实现。单例模式-懒汉式单例public class LazySingleton {        /*** 私有静态对象,加载时候不做初始化      */        private
Java多线程之单例模式在多线程环境下的安全问题
努力努力再努力L
05-26 3986
Java基础之单例模式在多线程环境下的安全问题 目录： 单线程下的单例模式 多线程下的单例模式 单例模式volatile分析 1. 单线程下的单例模式 1. 单线程下单例模式代码 public class SingletonDemo { private static SingletonDemo instance = null; private SingletonDemo...
java写一个线程安全的单例模式Singleton
Autumn匆的博客
07-18 8894
1.饿汉式单例 指在方法调用前，实例就已经创建好了 package jichu; public class Singleton { private static Singleton instance=new Singleton(); private Singleton(){ } public static Singleton getInstance(){ return i...
mysql jdbc 单利_java多线程(一)——线程安全的单例模式
weixin_39943370的博客
01-27 204
概念：java中单例模式是一种常见的设计模式，单例模式分三种：懒汉式单例、饿汉式单例、登记式单例三种。单例模式有一下特点：1、单例类只能有一个实例。2、单例类必须自己创建自己的唯一实例。3、单例类必须给所有其他对象提供这一实例。单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都...
Java多线程实现线程安全单例模式解析
"本文主要探讨了Java多线程环境下的线程安全单例模式，包括其概念、特点以及两种常见的实现方式：懒汉式和饿汉式。" 在Java编程中，单例模式是一种常用的设计模式，其核心目标是确保一个类在整个应用程序中只有一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值