单例会带来什么问题？怎么实现一个线程安全的单例模式呢？
public   class Test{
    private Test(){}
    private static  Test  test = new Test();
public static Test getTestInstance(){
     return test;
}  
单例确实会带来线程安全问题，但是这个怎么解决呢？通过 线程同步块（synchronized） 这个感觉不合适啊
}

该贴已经同步到 lucky_xingxing的微博

你写的代码就是一个线程安全的单例模式。

还有一种实现单例模式的如：

package tests;

public class SingleInstance {
        private static SingleInstance single = null;
       
        public static SingleInstance getInstance(){
               
                if(single == null){
                       
                        //此处睡眠纯粹为了说明可能出现同时有多个线程进入if语句
                        try {
                                Thread.sleep(20);
                        } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
                        single = new SingleInstance();
                }
               
                return single;
               
        }
       
        public static void main(String[] args) {
               
                for(int i = 0; i < 100; i++){
                       
                        new Thread(new Runnable(){
                                @Override
                                public void run() {
                                        // TODO Auto-generated method stub
                                       
                                        for(int i = 0; i < 10; i++){
                                                System.out.println(Thread.currentThread().getName() + " : " + SingleInstance.getInstance());
                                        }
                                       
                                }
                        }).start();
                       
                }
               
        }

}

我写的这种就不是线程安全的，因为两个或者多个线程会同时进入到if语句里面，会new出不同的对象。