java 中多线程下的单例模式

01.package namespace;
02.
03.
04.
05.//单例模式--- 饿汉式
06./*
07.class Person
08.{
09. private Person p=new Person ();
10. private Person () {}
11. public Person GetInstance()
12. {
13. return p;
14. }
15.}
16.*/
17./*
18. * 下面是懒汉式,只在在单线种的情况下,而这种情况在多线程的情况下会多现在不安全现在,因为如果有两个线程同时访问到new Person ,那么我就生成两个对象,这样就违反了
19. * 单例模式下面一个是在多线
20. * */
21./*
22.class Person
23.{
24. private Person person=null;
25. private Person () {}
26. public Person getInstance()
27. {
28. if(person==null)
29. {
30. person =new Person();
31. }
32. return person;
33. }
34.
35.}*/
36.class Person
37.{
38. private Person person=null;
39. private Person () {}
40. public Person getInstance()
41. {
42. if(person==null)
43. {
44. synchronized(this)
45. {
46. if(person==null)
47. person =new Person();
48.
49. }
50. }
51. return person ;
52. }
53.}
54./*
55. *
56. * 这样在synchronized 线程控制块里面进行多线程的控制,就不会再出现多个线程访问时出现多个对象的情况了.
57. * 还有一点就是外面的person ==null 判断是用来提高效率的,不然第一次都要对锁进行判断,消耗浓资源
58. * 这样可以有次的提高效率
59. * */
60.public class Single {
61. public static void main(String args[])
62. {
63. System.out.println("this is java");
64. }
65.}
66./*
67. * 单例模式就是在内存中想只能存在一个对象,而不允许再实例化其他的对象
68. *
69. * */


  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
1. 饿汉式——线程安全的单例模式 这是一种最简单的实现方式。在类加载的时候就创建了实例,因此保证了线程安全。缺点是无论是否需要这个对象,都会在程序启动时被加载,从而浪费了一定的空间。 ```java public class Singleton { //创建 Singleton 的一个对象 private static Singleton instance = new Singleton(); //让构造函数为 private,这样该类就不会被实例化 private Singleton(){} //获取唯一可用的对象 public static Singleton getInstance(){ return instance; } } ``` 2. 懒汉式——线程不安全的单例模式 这种方式虽然达到了按需初始化的目的,但却带来了线程不安全的问题,如果多个线程同时调用 `getInstance()` 方法,那么就会创建多个实例。 ```java public class Singleton { private static Singleton instance; private Singleton(){} public static Singleton getInstance(){ if(instance == null) { instance = new Singleton(); } return instance; } } ``` 3. 懒汉式——线程安全的单例模式 使用 `synchronized` 关键字可以解决线程安全问题,但是这样每次调用 `getInstance()` 方法都会进行同步,影响程序的性能。 ```java public class Singleton { private static Singleton instance; private Singleton(){} public static synchronized Singleton getInstance() { if(instance == null) { instance = new Singleton(); } return instance; } } ``` 4. 双重校验锁——线程安全的单例模式 这是一种比较好的实现方式,使用了双重校验锁,既保证了线程安全,又实现了按需初始化,同时也减少了同步开销。 ```java public class Singleton { private volatile static Singleton instance; private Singleton(){} public static Singleton getInstance() { if(instance == null) { synchronized (Singleton.class) { if(instance == null) { instance = new Singleton(); } } } return instance; } } ``` 5. 静态内部类——线程安全的单例模式 使用静态内部类的方式可以在调用 `getInstance()` 方法时才真正创建对象,达到最佳的按需初始化效果,并且也保证了线程安全。 ```java public class Singleton { private Singleton(){} private static class SingletonHolder{ private static final Singleton INSTANCE = new Singleton(); } public static Singleton getInstance(){ return SingletonHolder.INSTANCE; } } ```

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值