多線程設計模式

• 什麼事設計模式

    在軟件工程中，設計模式（design pattern）是對軟件設計中普遍存在（反覆出現）的各種問題，所提出的解決方案。

• 單例模式

    單例對象的類必須保證只有一個實例的存在。許多時候整個系統只需要擁有一個的全局對象，這樣有利於我們協調系統整體的行爲。比如全局信息配置。    但是何時產生實例，不好判斷。

    這個實例在getInstance第一次被方位的時候創建實例。                       

public class Singleton {
	private Singleton(){
		System.out.println("single is create");
	}
	private static Singleton instance = new Singleton();
	public static Singleton getInstance(){
		return instance;
	}
	}
}

    以下實例也會被創建

public class Singleton2 {
	public static int STATUS = 1;

	private Singleton2() {
		System.out.println("single is create");
	}

	private static Singleton2 instance = new Singleton2();

	public static Singleton2 getInstance() {
		return instance;
	}

	public static void main(String[] args) {
		System.out.println(Singleton2.STATUS);
	}
}

    single is create

    1

    可以使用同步的方法，只有getInstance情況下才調用實例。採用延遲加載的機制，但是在高併發會影響效率

public class LazySingleton {
	public static int STATUS = 1;
	private LazySingleton() {
		System.out.println("single is create");
	}

	private static LazySingleton instance = null;

	public static synchronized LazySingleton getInstance() {
		if (instance == null)
			instance = new LazySingleton();
		return instance;
	}

	// public static void main(String[] args) {
	// System.out.println(LazySingleton.STATUS);
	// }
}

    使用靜態內部類，當外部類被初始化的時候，靜態內部類並不能被初始化，只有調用getInstance的時候靜態內部類才能夠被初始化。

public class StaticSingleton {
	public static int STATUS = 1;
	private StaticSingleton() {
		System.out.println("single is create");
	}

	private static class SingletonInner {
		private static StaticSingleton instance = new StaticSingleton();
	}

	public static StaticSingleton getInstance() {
		return SingletonInner.instance;
	}

	public static void main(String[] args) {
		System.out.println(StaticSingleton.STATUS);
	}
}

• 不變模式

    一個類創建後，再整個生命週期都不會發生變化，就是不變類。不變模式不需要同步。

public final class Pruduct {//確保無子類
	private final String no;
	private final String name;
	private final double price;
        //創建對象，必須指定數據，創建後就無法進行修改。
	public Pruduct(String no, String name, double price) {
		this.no = no;
		this.name = name;
		this.price = price;
	}

	public String getNo() {
		return no;
	}

	public String getName() {
		return name;
	}

	public double getPrice() {
		return price;
	}
}

    不變模式

    java.lang.String

    java.lang.Boolean

    java.lang.Byte

    java.lang.Character    

    java.lang.Double

    java.lang.Float

    java.lang.Integer

    java.lang.Long

    java.lang.Short

• Future模式

package designPattern;

public class Client {
	public Data request(final String querystr){
		final FutureData future = new FutureData();
		new Thread(){
			public void run(){
				RealData realData = new RealData(querystr);
				future.setRealData(realData);
			}
		}.start();
		return future;
	}
	public static void main(String[] args) {
		Client c = new Client();
		Data data = c.request("alan");
		System.out.println("請求完畢");
		try {
			Thread.sleep(5000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(data.getResult());
	}
}

package designPattern;

public class FutureData implements Data {
	protected RealData realData = null;
	protected boolean isReady = false;

	public synchronized void setRealData(RealData realdata) {
		if (isReady) {
			return;
		}
		this.realData = realData;
		isReady = true;
		notifyAll();

	}

	@Override
	public String getResult() {
		while (!isReady) {
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		return realData.result;
	}

}

package designPattern;

public class RealData implements Data {
	protected final String result;

	public RealData(String para) {
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < 10; i++) {
			sb.append(para);
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		result = sb.toString();
	}

	@Override
	public String getResult() {
		return result;
	}

}

package designPattern;

public interface Data {
	public String getResult();
}

• 生產者消費者

    是一種非常經典的多線程設計模式。它爲多線程間的協作提供了良好的解決方案。生產者和消費者之間通過共享內存緩衝區進行通信。