Java設計模式：Factory vs Singleton？在多線程的情況下

Question

明智地創建新對象並使用相同的對象實例而不是創建新對象是明智的。在下面的情況下，我對確定創建對象的解決方案並不十分有信心。有一個SOAP服務類有幾種方法來負責多個客戶。請參閱模板下面，

Public class SOAPService {   
      public Object getProductList(String CustId, String endPoint){ 
       SOAPStub stub = new SOAPStub(endPoint); 
       Object productList = stub.getProductList(); 
       return productList; 
      } 
      public Object getProductInfo(String CustId, String productId, String endPoint){ 
       SOAPStub stub = new SOAPStub(endPoint); 
       Object productInfo = stub.getProductList(productId); 
       return productInfo; 
      } 
    } 

現在我介紹一個工廠方法爲每個客戶創建對象，並把它放在一個地圖，但我很困惑，當單個客戶的多個線程將訪問該服務類。對象的行爲不會像單身或可能導致任何死鎖問題，或讓線程等待？請在此指導我。

Public class SOAPService { 
     private Map<String, SOAPStub> map = new HashMap<String, SOAPStub>(); 
     public SOAPStub getSOAPObject(String CustId, String endPoint){ 
      if(map.containsKey(CustId)) 
       return map.get(CustId); 
      else{ 
       SOAPStub stub = new SOAPStub(endPoint); 
       map.put(custId, stub); 
       return stub; 
       } 
     } 
     public Object getProductList(String CustId, String endPoint){ 
      SOAPStub stub = getSOAPObject(CustId, endPoint); 
      Object productList = stub.getProductList(); 
      return productList; 
     } 

     public Object getProductInfo(String CustId, String productId, String endPoint){ 
      SOAPStub stub = getSOAPObject(CustId, endPoint); 
      Object productInfo = stub.getProductList(productId); 
      return productInfo; 
     } 
    } 

Answer 1

您的HashMap不是線程安全的，它似乎令人懷疑整個路徑你會下降生產力。您的線程可能會花費所有時間阻止訪問共享池，並且隨着負載的增加爭用將變得更糟。儘可能使你的線程獨立於彼此，即使這使得它們使用更多的內存。

一般用於資源密集型對象（如數據庫連接）的預留池。見this question about object pooling。緩存可能對您有所幫助，請查看緩存提供程序，如ehcache。滾動你自己的緩存比你想象的更麻煩。

Answer 2

你的第一個代碼示例看起來安全，但..

是的，有服務類單身對象「可以」只有當你有這些正在使用的服務方法的類變量產生問題讀/寫模式。

例如可以採取以下服務方法

private int count = 0; //class variable 

public Response service(Request r) 
{ 
count = r.getSomeVariable(); 
... 
response.setParameter(count); 
} 

上面的方法可能並不安全，因爲每個請求都會有自己的線程，也有着共同的變量「計數」當兩個要求是同時叫他們可能覆蓋彼此的數據。

但如果你在方法本身聲明count爲變量，它將是安全的。因爲每次調用此方法時都會分配一個新的計數變量，這些變量在方法調用結束後將被銷燬。

您可以爲每個安全的請求創建新的服務，但是，這將成爲系統開銷。

Answer 3

我建議你作爲標誌。如果由於某種原因想要替換SOAPService的實現，工廠是合適的。因此，signleton實現可能是：

public final class SoapService { 

    public static final String END_POINT = "endpoint"; 

    private final Map<String, InternalSOAPService> map = Collections.synchronizedMap(new HashMap()); 

    // All user services int the box 
    private final Map<String, InternalSOAPService> unmodifiableMap = Collections.unmodifiableMap(someServiceMapInitMethod()); 

    private static SoapService ourInstance = new SoapService(); 

    private SoapService() { 
    } 

    // All user services int the box. No delays. 
    public static InternalSOAPService getServiceFromTheBox(final String custId) { 
     return ourInstance.unmodifiableMap.get(custId);   
    } 

    public static InternalSOAPService getService(final String custId) { 

     InternalSOAPService service = ourInstance.map.get(custId); 

     if (service == null) { 
      synchronized (SoapService.class) { 
       service = ourInstance.new InternalSOAPService(custId); 
       if (service == null) { // Double Checked Locking 
        service = ourInstance.new InternalSOAPService(custId); 
       } 
       ourInstance.map.put(custId, service); 
      } 
     } 
     return service; 
    } 

    public class InternalSOAPService { 

     private final String custId; 

     private final SOAPStub stub; 

     public InternalSOAPService(final String custId) { 
      this.custId = custId; 
      this.stub = new SOAPStub(END_POINT); // Here could be Factory based on custId or END_POINT 
     } 

     public Object getProductList(){ 
      return stub.getProductList(); 
     } 

     public Object getProductInfo(final String productId){ 
      return stub.getProductList(productId); 
     } 
    } 
} 

Answer 4

明智地創建新對象並使用相同對象 實例而不是創建新對象是明智的。

建議如果性能增益值得誘導的複雜性。就我的經驗而言，在現代面向對象的平臺上很少有這種情況。

您對多線程環境中發生的事情感到困惑，足以表明折衷可能不是有利可圖的。我的注意力：直到你證明樣本＃1提出的對象的數量將不可接受地損害了產品的性能，樣本＃2是不成熟的優化。