JDK1.5中提供了多线程升级解决方案：

将同步synchronized替换成了显示的lock操作
那么，我们在写懒汉式时，可以用lock方式写吗？如果可以的话，怎么写，最好附代码，谢谢！

如果问题解决了，请将分类改为“已解决”，谢谢

多谢两位的帮助

思想：
1，不让其他程序创建该类对象。
2，在本类中创建一个本类对象。
3，对外提供方法，让其他程序获取这个对象。
步骤：
1，因为创建对象都需要构造函数初始化，只要将本类中的构造函数私有化，其他程序就无法再创建该类对象；
2，就在类中创建一个本类的对象；
3，定义一个方法，返回该对象，让其他程序可以通过方法就得到本类对象。（作用：可控）
代码体现：
1，私有化构造函数；
2，创建私有并静态的本类对象；
3，定义公有并静态的方法，返回该对象。
---------------------------------------------
//饿汉式
class Single{
private Single(){} //私有化构造函数。
private static Single s = new Single(); //创建私有并静态的本类对象。
public static Single getInstance(){ //定义公有并静态的方法，返回该对象。
return s;
}
}
---------------------------------------------
//懒汉式:延迟加载方式。
class Single2{
private Single2(){}
private static Single2 s = null;
public static Single2 getInstance(){
if(s==null)
s = new Single2();
return s;
}
}

1. package test;
   
2. 
   
3. import java.util.concurrent.locks.Lock;
   
4. import java.util.concurrent.locks.ReentrantLock;
   
5. /**
   
6. *
   
7. * @author fjl
   
8. *多看一下java API，就能找到实现方法
   
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.                         
    
24.                    //如果该锁未被其他线程保持(可以查看API),即当前锁是空闲状态
    
25.                   if(lock.tryLock()){
    
26.                     if(s==null){
    
27.                             //实例化Single对象
    
28.                           s=new Single();
    
29.                     }
    
30.                   }
    
31.                 }
    
32.                 //返回
    
33.                 return s;
    
34.         }
    
35. }
    
36. 
    
37. //多线程下测试
    
38. class Test1 implements Runnable{
    
39. 
    
40.         @Override
    
41.         public void run() {
    
42.                 // TODO Auto-generated method stub
    
43.                 while(true){
    
44.                 try {
    
45.                         Thread.sleep(100);
    
46.                 } catch (InterruptedException e) {
    
47.                         // TODO Auto-generated catch block
    
48.                         e.printStackTrace();
    
49.                 }
    
50.                 System.out.println(this+"-->"+Single.getInstance());
    
51.         }
    
52.         }
    
53. }
    
54. //多线程测试
    
55. class Test2 implements Runnable{
    
56. 
    
57.         @Override
    
58.         public void run() {
    
59.                 // TODO Auto-generated method stub
    
60.                 while(true){
    
61.                 try {
    
62.                         Thread.sleep(1000);
    
63.                 } catch (InterruptedException e) {
    
64.                         // TODO Auto-generated catch block
    
65.                         e.printStackTrace();
    
66.                 }
    
67.                
    
68.                 System.out.println(this+"-->"+Single.getInstance());
    
69.         }
    
70.         }
    
71. }
    
72. public class Demo01 {
    
73. 
    
74.         /**
    
75.          * @param args
    
76.          */
    
77.         public static void main(String[] args) {
    
78.                 // TODO Auto-generated method stub
    
79. 
    
80. //                Single s1=Single.getInstance();
    
81. //                Single s2=Single.getInstance();
    
82. //                System.out.println(s1==s2);
    
83.                
    
84.                 //多线程下测试
    
85.                 Thread one=new Thread(new Test1());
    
86.                 Thread one1=new Thread(new Test1());
    
87.                 Thread one2=new Thread(new Test1());
    
88.                 Thread two=new Thread(new Test2());
    
89.                 Thread two1=new Thread(new Test2());
    
90.                 Thread two2=new Thread(new Test2());
    
91.                 two.start();
    
92.                 two1.start();
    
93.                 two2.start();
    
94.                 one.start();
    
95.                 one1.start();
    
96.                 one2.start();
    
97.         }
    
98. 
    
99. }
    

复制代码