昨天在论坛看到有人问多线程下的懒汉式单例模式用lock实现的问题，我在那里回答了，为了让更多的人看到，我贴出来分享一下
下面这段代码就不多做解释了。

1. class Single{
   
2.         private static Single s=null;
   
3.         private Singleton(){}
   
4.         public static Single getInstance(){
   
5.                 if(s==null){
   
6.                         synchronized (Single.class) {
   
7.                                 if(s==null){
   
8.                                         s=new Single();
   
9.                                 }
   
10.                         }
    
11.                 }
    
12.                 return s;
    
13.         }
    
14. }

复制代码

用Lock实现多线程下的单例(懒汉式)

1. package test;
   
2. 
   
3. import java.util.concurrent.locks.Lock;
   
4. import java.util.concurrent.locks.ReentrantLock;
   
5. /**
   
6. *
   
7. * @author fjl
   
8. *
   
9. */
   
10. class Single{
    
11.         private static Single s=null;
    
12.         //构造方法私有化
    
13.         private Single(){}
    
14.        //创建一个锁对象，由于getInstance()是静态方法,则必须是静态成员该方法才能访问，
    
15.         //并将锁声明成final类型，保持该对象不变且只有一个Lock对象
    
16.         private static final Lock lock=new ReentrantLock();
    
17.         //获得单例实例
    
18.         public static Single getInstance(){               
    
19.               //如果为空
    
20.               if(s==null){
    
21.             //获取锁
    
22.              lock.lock();            
    
23.              //如果该锁未被其他线程保持（可以查看API），即该锁是空闲的
    
24.               if(lock.tryLock()){
    
25.                 if(s==null){
    
26.                  //实例化Single对象
    
27.                    s=new Single();
    
28.                }
    
29.           }
    
30.   }
    
31.             //返回
    
32.             return s;
    
33.         }
    
34. }
    
35. 
    
36. //多线程下测试
    
37. class Test1 implements Runnable{
    
38. 
    
39.         @Override
    
40.         public void run() {
    
41.                 // TODO Auto-generated method stub
    
42.                 while(true){
    
43.                 try {
    
44.                         Thread.sleep(100);
    
45.                 } catch (InterruptedException e) {
    
46.                         // TODO Auto-generated catch block
    
47.                         e.printStackTrace();
    
48.                 }
    
49.                 System.out.println(this+"-->"+Single.getInstance());
    
50.         }
    
51.         }
    
52. }
    
53. //多线程测试
    
54. class Test2 implements Runnable{
    
55. 
    
56.         @Override
    
57.         public void run() {
    
58.                 // TODO Auto-generated method stub
    
59.                 while(true){
    
60.                 try {
    
61.                         Thread.sleep(1000);
    
62.                 } catch (InterruptedException e) {
    
63.                         // TODO Auto-generated catch block
    
64.                         e.printStackTrace();
    
65.                 }
    
66.                
    
67.                 System.out.println(this+"-->"+Single.getInstance());
    
68.         }
    
69.         }
    
70. }
    
71. public class Demo01 {
    
72. 
    
73.         /**
    
74.          * @param args
    
75.          */
    
76.         public static void main(String[] args) {
    
77.                 // TODO Auto-generated method stub
    
78. 
    
79. //                Single s1=Single.getInstance();
    
80. //                Single s2=Single.getInstance();
    
81. //                System.out.println(s1==s2);
    
82.                
    
83.                 //多线程下测试
    
84.                 Thread one=new Thread(new Test1());
    
85.                 Thread one1=new Thread(new Test1());
    
86.                 Thread one2=new Thread(new Test1());
    
87.                 Thread two=new Thread(new Test2());
    
88.                 Thread two1=new Thread(new Test2());
    
89.                 Thread two2=new Thread(new Test2());
    
90.                 two.start();
    
91.                 two1.start();
    
92.                 two2.start();
    
93.                 one.start();
    
94.                 one1.start();
    
95.                 one2.start();
    
96.         }
    
97. 
    
98. }
    

复制代码

楼主分享的东西都不错。关注了

哈哈，也解决了我的问题

好，当多个线程访问懒汉式，如果不加锁，有可能就可能出现单列变成多列的情况，但是加锁也会浪费一些资源，消耗一些性能

呵呵！！！那没办法啊，在多线程下性能都会降低

谢了，现在正差技术分啊