package Thread_Single01;
//懒汉式,这里要使用延迟加载技术,和多线程技术
public class Single2 {
        private Single2() {//为了保证数据的唯一型
                super();
                // TODO Auto-generated constructor stub
        }
       
        static Single2 s= null;//由于get方法返回的是s  所以s也要静态,要不然又get时 s还没有出现
       
        public synchronized static Single2 getInstance(){//由于构造函数被私有,只能用类名调用,类名只能调用静态方法
                if(s==null){
                        s= new Single2();       
                }
                return s;
        }
}

只学过饿汉，懒汉看不懂；。。

1. class LazySingleton
   
2. {
   
3.         private static LazySingleton ls = null;
   
4.         private LazySingleton(){}
   
5.         private static LazySingleton getInstance()
   
6.         {
   
7.                 if (ls == null) //用双重判断提高效率.
   
8.                 {
   
9.                         synchronized (LazySingleton.class) //同步就加锁, 不同步就没锁,可能会出现大于1对象的情况,
   
10.                         {
    
11.                                 if (ls == null)
    
12.                                 {
    
13.                                         ls = new LazySingleton();
    
14.                                 }
    
15.                         }
    
16.                 }
    
17.                 return ls;
    
18.         }
    
19. }

复制代码

香草芭芙 发表于 2014-10-10 22:28

美女   可以问问  你这的双重判断  是在避免什么问题出现  呢  好像视屏里看过,一时没有想起来

香草芭芙 发表于 2014-10-10 22:28

还有个问题  你的这个代码是怎吗弄成这样的,教教我    我每次都是复制的   很想知道你这是怎么弄的

没同步的代码是这样

1. public static NoSingle getInstance(){
   
2.                 if(ns == null){
   
3.                         ns = new NoSingle();
   
4.                 }
   
5.                 return ns;
   
6.         }

复制代码

是第一个线程执行到if(ns==null)的里面，但又没执行ns=new NoSingle()的一瞬间被CPU切换出去，第二个线程进来执行一边，给ns付了值，第一个线程切换回来继续执行，就会产生一个新的NoSignle对象返回，失去了单例的意义。想要验证的话可以人为的让线程在if(ns==null)与ns=new NoSingle()之间停一停，放大这个时间差，然后验证之，经过验证，不加同步区别巨大=。=
我这么验证的：

1. //没加同步的"单例"类
   
2. public class NoSingle {
   
3.         private static NoSingle ns = null;
   
4.         private NoSingle(){}
   
5.        
   
6.         public static NoSingle getInstance(){
   
7.                 if(ns == null){
   
8.                         //人为的让进来的每个线程在这里停一停
   
9.                         //做个循环消磨一下时间
   
10.                         for(int i = 0; i < 10000; i ++){
    
11.                                 int x = i + 1;
    
12.                         }
    
13.                         //这个是原本要同步的关键代码
    
14.                         ns = new NoSingle();
    
15.                 }
    
16.                 return ns;
    
17.         }
    
18. }
    

复制代码

主函数：

1. public class Test {
   
2.         
   
3.         public static void main(String[] args) throws InterruptedException{
   
4.                
   
5.                 //定义10个TestThread对象
   
6.                 TestThread[] tt = new TestThread[10];
   
7.                 for(int i = 0;i < 10;i ++){
   
8.                         tt[i] = new TestThread();
   
9.                 }
   
10.                 //分别用10个TestThread对象构建10个线程
    
11.                 //意思就是10个"NoSingle.getInstance()"语句同时执行
    
12.                 Thread[] ts = new Thread[10];
    
13.                 for(int i = 0;i < 10;i ++){
    
14.                         ts[i] = new Thread(tt[i]);
    
15.                 }
    
16.                 //开启10个线程
    
17.                 for(int i = 0;i < 10;i ++){
    
18.                         ts[i].start();
    
19.                 }
    
20.                 //等待3S以确认10个线程都执行完并且结束了
    
21.                 Thread.sleep(3000);
    
22.                
    
23.                 //然后对比tt数组中的10个对象，每个对象中都存有一个NoSingle类的引用
    
24.                 //“引用”就是c++中的指针，可以直接比较，指向同一个对象则“引用”相等
    
25.                 //如果10个对象中有1个中NoSingle的引用与其他不一样，意思就是单例设计模式没单例成功
    
26.                 //则证明没有同步是不安全的
    
27.                 boolean b = true;
    
28.                 for(int i = 0; i < 9;i ++){
    
29.                         if(tt[i].getRefrence() != tt[i+1].getRefrence()){
    
30.                                 System.out.println("没同步代码不安全");
    
31.                                 b = false;
    
32.                         }
    
33.                 }
    
34.                 if(b){
    
35.                         System.out.println("没同步代码好像没什么区别");
    
36.                 }
    
37.                
    
38.         }
    
39. }
    
40. //多线程类，类中定义了一个NoSingle的变量，线程结束后，成员变量ns就拿到了一个NoSingle实例
    
41. class TestThread implements Runnable{
    
42.         private NoSingle ns;
    
43.         @Override
    
44.         public void run() {
    
45.                 // TODO Auto-generated method stub
    
46.                 ns = NoSingle.getInstance();
    
47.         }
    
48.         public NoSingle getRefrence(){
    
49.                 return ns;
    
50.         }
    
51.         
    
52. }
    

复制代码

ifinver 发表于 2014-10-10 23:24
没同步的代码是这样是第一个线程执行到if(ns==null)的里面，但又没执行ns=new NoSingle()的一瞬间被CPU切换 ...

非常感谢   解释的非常详细

如果在懒汉式s=new Single2();上面加一句Thread.sleep(10),你就会发现问题了，但你加同步时，如果加在函数上面又会出现一个新问题，就是在多线程执行它的情况下，造成每个线程都要去判断一下，很是消耗资源，所以这时你应该把函数上的同步去掉，在if(s==null)下面加一个同步块，锁是本类的字节码对象，在锁里再进行判断，如果null。就进行s=new Single2();并在第一个判断外面对外return s;新人一个希望能帮到你