Java多线程(PART XXI)多线程和单例模式

一般的单例模式。

http://blog.csdn.net/uncle_gy/article/details/77962501

单例模式和线程安全

单例模式分为懒汉模式和饿汉模式。
其中饿汉模式是天生的线程安全的。
因为懒汉模式是延时加载的所以在多线程的环境下存在一些不确定的因素。

懒汉模式线程不安全示例代码

class MyObject{
    private static MyObject myObject;
    private MyObject(){}
    public static MyObject getInstance(){

        if(myObject!=null){

        }else{
            try{
                Thread.sleep(300);
            }catch(InterruptedException ie){
                System.out.println(ie.toString());
            }

            myObject=new MyObject();
        }
        return myObject;
    }
}
class MyThread extends Thread{
    @Override
    public void run(){
        System.out.println(MyObject.getInstance().hashCode());
    }
}
public class SingleMain{

    public static void main(String[]args){
        MyThread thread1=new MyThread();
        MyThread thread2=new MyThread();
        MyThread thread3=new MyThread();
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

输出结果：

可以看到一共有三个hashcode，说明一共产生了三个实例对象。
不满足单例模式的基本要求。

解决方案

基本上synchronized 关键字的几种格式都可以称为一种方法。
http://blog.csdn.net/uncle_gy/article/details/78175707

解决方案1：使用synchronized 同步方法

class MyObject{
    private static MyObject myObject;
    private MyObject(){}
    synchronized public static MyObject getInstance(){

        if(myObject!=null){

        }else{
            try{
                Thread.sleep(300);
            }catch(InterruptedException ie){
                System.out.println(ie.toString());
            }

            myObject=new MyObject();
        }
        return myObject;
    }
}

优点：简单粗暴
缺点：效率低下

解决方法2：同步代码块（都同步）

class MyObject{
    private static MyObject myObject;
    private MyObject(){}
    public static MyObject getInstance(){
        synchronized (MyObject.class){
            if(myObject!=null){

        }else{
            try{
                Thread.sleep(300);
            }catch(InterruptedException ie){
                System.out.println(ie.toString());
            }
                myObject=new MyObject();
            }
        }
        return myObject;
    }
}

特点：和方法1没有太大区别

解决方法3：同步代码块（只同步部分重要代码）

这里没有办法使用对象锁，因为getInstance方法是static方法。

class MyObject{
    private static MyObject myObject;
    private MyObject(){}
    public static MyObject getInstance(){

        if(myObject!=null){

        }else{
            try{
                Thread.sleep(300);
            }catch(InterruptedException ie){
                System.out.println(ie.toString());
            }
            synchronized (MyObject.class){
                myObject=new MyObject();
            }

        }
        return myObject;
    }
}

特点：较方法1和方法2的性能都有大幅度的提升。

解决方法4：DCL双检查锁机制

特点：使用volatile关键字和synchronize关键字结合
关于volatile关键字http://blog.csdn.net/uncle_gy/article/details/78184431

class MyObject{
    private volatile static MyObject myObject;
    private MyObject(){}
    public static MyObject getInstance(){

            if(myObject!=null){

        }else{
            try{
                Thread.sleep(300);
            }catch(InterruptedException ie){
                ie.printStackTrace();
            }
            synchronized (MyObject.class){
                myObject=new MyObject();
            }
        }
        return myObject;
    }
}