Java多线程学习（四）

单例模式
1.1立即加载/饿汉模式
立即加载既为使用类的方法的时候已经将对象创建完毕。常见的实现方法就是直接new实例化。

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

public static void main(String [] args){
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
MyThread t3 = new MyThread();

t1.start();
t2.start();
t3.start();
}
}
运行结果为三个线程输出的值相同。

1.2延迟加载/懒汉模式
延迟加载既为调用类的方法时，对象实例才被创建。常见实现方法为在get方法中进行new实例化。

public class MyObject {
private static MyObject myObject;
private MyObject(){}
public static MyObject getInstance(){
if(myObject == null){ myObject = new MyObject();}
return myObject;
}
}
public class MyThread extends Thread {
public void run(){
System.out.println(MyObject.getInstance().hashCode());
}

public static void main(String [] args){
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
MyThread t3 = new MyThread();

t1.start();
t2.start();
t3.start();
}
}
运行结果为三个线程输出的值不同，取出了多个线程实例，与单例模式相违背。

延迟加载的解决方案
如上例所示的延迟加载方法，在多线程模式下是线程不安全的，那么就是以下几种解决方案吧！
①声明synchronized关键字
既然出现线程不安全问题是因为多个线程同时进入getInstance方法导致的，那么就给这个方法上锁，同一时间内只有一个线程能够访问。

public class MyObject {
private static MyObject myObject;
private MyObject(){}
synchronized public static MyObject getInstance(){
if(myObject == null){
myObject = new MyObject();
}
return myObject;
}
}
public class MyThread extends Thread {
public void run(){
System.out.println(MyObject.getInstance().hashCode());
}

public static void main(String [] args){
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
MyThread t3 = new MyThread();

t1.start();
t2.start();
t3.start();
}
}
运行结果为三个线程输出的值相同。

但是这种方法的运行效率非常低下。
②尝试同步代码块

public class MyObject {
private static MyObject myObject;
private MyObject(){}
public static MyObject getInstance(){
synchronized (MyObject.class){
if(myObject == null){ myObject = new MyObject();}
}
return myObject;
}
}
public class MyThread extends Thread {
public void run(){
System.out.println(MyObject.getInstance().hashCode());
}

public static void main(String [] args){
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
MyThread t3 = new MyThread();

t1.start();
t2.start();
t3.start();
}
}
运行结果为三个线程输出的值相同。

但是这相当于第一种给方法上锁的方式，效率同样低下。
③尝试给重要代码上锁

public class MyObject {
private static MyObject myObject;
private MyObject(){}
public static MyObject getInstance(){
if(myObject == null){
synchronized (MyObject.class){
myObject = new MyObject();
}
}
return myObject;
}
}
public class MyThread extends Thread {
public void run(){
System.out.println(MyObject.getInstance().hashCode());
}

public static void main(String [] args){
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
MyThread t3 = new MyThread();

t1.start();
t2.start();
t3.start();
}
}
运行结果为三个线程输出的值不相同，并不是单例的。

这样的上锁方式虽然虽然提高了效率，但是仍有可能同时有多个线程进入if方法内部，等待执行同步代码块，因此获取了多个对象。
④使用DCL双检查锁机制

public class MyObject {
private static MyObject myObject;
private MyObject(){}
public static MyObject getInstance(){
if(myObject == null){
synchronized (MyObject.class){
if(myObject == null){
myObject = new MyObject();
}
}
}
return myObject;
}
}
public class MyThread extends Thread {
public void run(){
System.out.println(MyObject.getInstance().hashCode());
}

public static void main(String [] args){
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
MyThread t3 = new MyThread();

t1.start();
t2.start();
t3.start();
}
}
运行结果为三个线程输出的值相同。

使用双重检查锁机制，成功的解决了懒汉模式遇到多线程的问题。DCL也是大多数多线程结合单例模式使用的解决方案。