码迷，mamicode.com
首页 > 编程语言 > 详细

java单例 同步 多线程

时间：2015-08-19 20:37:30      阅读：167      评论：0      收藏：0      [点我收藏+]

标签：设计模式   多线程   java   class   thread   string   

get="_blank" href="http://www.csdn.net/tag/%e8%ae%be%e8%ae%a1%e6%a8%a1%e5%bc%8f">设计模式多线程javaclassthreadstring

单例模式的特点：

  1. 只创建一次
  2. 私有的属性
  3. 公有的访问方法

单例模式的分类：

  1. 懒汉（LazySingleton）；默认不自动实例化，等到用的时候根据当前情况实例化，并且返回当前对象；
  2. 恶汉（EagerSingleton）；在类第一次加载的时候强制实例化；

用处：

         一般用在配置文件的读取，有些东西只需要加载一次，以后重复使用。

示例代码：

[java] view plaincopy
  1. package myThread;  
  2.   
  3. /** 
  4.  * 单例模式，懒汉模式 
  5.  *  
  6.  * @author Champion.Wong 
  7.  *  
  8.  */  
  9. public class LazySingleton {  
  10.   
  11.     private static LazySingleton singleton = null;  
  12.   
  13.     /** 
  14.      * 私有的构造方法，防止被多次实例化 
  15.      *  
  16.      */  
  17.     private LazySingleton() {  
  18.     }  
  19.   
  20.     /** 
  21.      * 静态工厂，返回此类的唯一一个实例 判断，如果没有被实例化，则先初始化再返回 
  22.      *  
  23.      * @return LazySingleton 
  24.      */  
  25.     public static LazySingleton getInstance() {  
  26.         if (null == singleton)  
  27.             singleton = new LazySingleton();  
  28.         return singleton;  
  29.     }  
  30. }  

[java] view plaincopy
  1. package myThread;  
  2.   
  3. /** 
  4.  * 单例模式，饿汉模式 
  5.  * @author Champion.Wong 
  6.  * 
  7.  */  
  8. public class EagerSingleton {  
  9.   
  10.     private static EagerSingleton singleton = new EagerSingleton(); // 强制初始化，在类加载的时候就创建好了对象  
  11.   
  12.     /** 
  13.      * 私有的构造方法，防止被多次实例化 
  14.      *  
  15.      */  
  16.     private EagerSingleton() {  
  17.     }  
  18.   
  19.     public static EagerSingleton getInstance() {  
  20.         return singleton;  
  21.     }  
  22. }  

前边说过了，单例只创建一次，来做个测试，在单例的类中加入一个属性，当这个类在实例化的时候，会将当前的时间赋给这个属性。我们创建两个单例类的对象，然后分别拿出它们类中的这个属性进行对比。

所以，在EagerSingleton中加入属性：createdTime

[java] view plaincopy
  1. package myThread;  
  2.   
  3. /** 
  4.  * 单例模式，饿汉模式 
  5.  * @author Champion.Wong 
  6.  * 
  7.  */  
  8. public class EagerSingleton {  
  9.   
  10.     private static EagerSingleton singleton = new EagerSingleton(); // 强制初始化，在类加载的时候就创建好了对象  
  11.   
  12.     /** 
  13.      * 私有的构造方法，防止被多次实例化 
  14.      *  
  15.      */  
  16.     private EagerSingleton() {  
  17.         createdTime = System.currentTimeMillis();  
  18.     }  
  19.   
  20.     public static EagerSingleton getInstance() {  
  21.         return singleton;  
  22.     }  
  23.       
  24.     private long createdTime = 0L; //此类的创建时间，在类实例化的时候赋值  
  25.     public long getCreatedTime() {  
  26.         return createdTime;  
  27.     }  
  28. }  

然后，写个Test：
[java] view plaincopy
  1. package myThread;  
  2.   
  3. public class Test_Singleton {  
  4.   
  5.     public static void main(String[] args) {  
  6.         EagerSingleton singleton1 = EagerSingleton.getInstance();  
  7.         try {  
  8.             Thread.sleep(2000); //让当前线程睡眠2000ms，这样，两个对象实例化的时间就差2s  
  9.         } catch (InterruptedException e) {  
  10.             e.printStackTrace();  
  11.         }  
  12.         EagerSingleton singleton2 = EagerSingleton.getInstance();  
  13.           
  14.         System.out.println("Singleton1:" + singleton1.getCreatedTime());  
  15.         System.out.println("Singleton2:" + singleton2.getCreatedTime());  
  16.     }  
  17.   
  18. }  

最后控制台输出的内容为：

技术分享

两个对象的实例化的时间相同，证明单例设想成功！


当多个线程访问单例类的时候，必须要保证同时只能由一个线程访问，当这个线程访问结束了，其它线程才能访问。这是就要给单例的访问方法加个同步锁（synchronized）。

修改后的LazySingleton为：

[java] view plaincopy
  1. package myThread;  
  2.   
  3. /** 
  4.  * 单例模式，懒汉模式 
  5.  *  
  6.  * @author Champion.Wong 
  7.  *  
  8.  */  
  9. public class LazySingleton {  
  10.   
  11.     private static LazySingleton singleton = null;  
  12.   
  13.     /** 
  14.      * 私有的构造方法，防止被多次实例化 
  15.      *  
  16.      */  
  17.     private LazySingleton() {  
  18.     }  
  19.   
  20.     /** 
  21.      * 静态工厂，返回此类的唯一一个实例 判断，如果没有被实例化，则先初始化再返回 
  22.      *  
  23.      * @return LazySingleton 
  24.      */  
  25.     synchronized public static LazySingleton getInstance() {  
  26.         if (null == singleton)  
  27.             singleton = new LazySingleton();  
  28.             System.out.println(Thread.currentThread().getName() + System.currentTimeMillis());  
  29.         try {  
  30.             Thread.sleep(900); //假设每个线程访问的时候都需要耗费一定的时间  
  31.         } catch (InterruptedException e) {  
  32.             e.printStackTrace();  
  33.         }  
  34.         return singleton;  
  35.     }  
  36. }  

做个测试，起两个线程，没个线程中分别调用单例类的访问方法，每次访问的时候输出访问的时间，判断时间是否相等。如果相等，同步失败，如果不等，同步成功！
[java] view plaincopy
  1. package myThread;  
  2.   
  3. public class Test_Thread_Singleton {  
  4.   
  5.     /** 
  6.      * @param args 
  7.      */  
  8.     public static void main(String[] args) {  
  9.         SingletonThread st = new SingletonThread();  
  10.         SingletonThread st1 = new SingletonThread();  
  11.         st.start();  
  12.         st1.start();  
  13.     }  
  14.   
  15. }  
  16.   
  17. class SingletonThread extends Thread {  
  18.     private LazySingleton singleton = null;  
  19.     public void run() {  
  20.         while (!this.isInterrupted()) {  
  21.             try {  
  22.                 Thread.sleep(1000);  
  23.             } catch (InterruptedException e) {  
  24.                 e.printStackTrace();  
  25.             }  
  26.             singleton = LazySingleton.getInstance();  
  27.         }  
  28.     }  
  29. }  

看控制台的输出内容：

技术分享

时间差不多都不一致，同步成功！限制了同时访问

版权声明：本文为博主原创文章，未经博主允许不得转载。

java单例 同步 多线程

标签：设计模式   多线程   java   class   thread   string   

原文地址：http://blog.csdn.net/itzhanghao/article/details/47784437

踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！