Java主题：多线程 - 竞赛条件

Question

我正在编写多线程程序，可以同时从多个用户访问该程序，该程序必须避免竞争条件。

代码/多线程：

public class DataProcessor implements Serializable, Runnable { 

private static final long serialVersionUID = 1L; 

public DataProcessor() { 

} 

@Override 
public void run() { 
    process(); 
} 

private void process() { 

    int iSize = 5; 

    for (int iCounter = 0; iCounter < iSize; iCounter++) { 
     DataKey objDataKey = new DataKey(); 
     ArrayList<String> list = //..fetch data method() 
     HashMap<String, String> hmPQdata = //..fetch data method() 

     SendNForgotHelperThread helperThread = new SendNForgotHelperThread(objDataKey, list, hmPQdata); 
     Thread t = new Thread(helperThread); 
     t.start(); 
    } 

} 

class SendNForgotHelperThread implements Runnable { 

    private ArrayList<String> list; 
    private HashMap<String, String> hmPQdata; 
    private DataKey objDataKey; 

    public SendNForgotHelperThread(DataKey objDataKey, ArrayList<String> list, HashMap<String, String> hmPQdata) { 
     this.list = list; 
     this.hmPQdata = hmPQdata; 
     this.objDataKey = objDataKey; 
    } 

    @Override 
    public void run() { 

     try { 

      // Option 1 : synchronized method - SendNForgotHelperThread class object locking 

      DataCollector objDataSenderM = new DataCollector(); 
      objDataSenderM.synchronizedMethodStore(this.objDataKey, this.list, this.hmPQdata); 

      // Option 2 : synchronized block - SendNForgotHelperThread class object locking 

      synchronized (this) { 
       DataCollector objDataSender = new DataCollector(); 
       objDataSender.store(this.objDataKey, this.list, this.hmPQdata); 
      } 

      // Option 3 : Class level locking 

      synchronized (SendNForgotHelperThread.class) { 
       DataCollector objDataSender = new DataCollector(); 
       objDataSender.store(this.objDataKey, this.list, this.hmPQdata); 
      } 

     } catch (Exception iex) { 
      System.out.println("Exception in thread: " + iex.getMessage()); 
     } 
    } 
} 

class DataCollector { 

    public void store(DataKey objDataKey, ArrayList<String> list, HashMap<String, String> hmPQdata) { 

     HashMap<String, String> retrivedValue = (HashMap<String, String>) MemCacheUtil 
       .retrieveFromMemCache(objDataKey.getKey()); 

     retrivedValue.putAll(hmPQdata); 

     MemCacheUtil.addToMemCache(objDataKey.getKey(), retrivedValue, "expTime value"); 

     // Sending data in queue 
     sendDataToQueue(objDataKey, list, hmPQdata); 

    } 

    synchronized void synchronizedMethodStore(DataKey objDataKey, ArrayList<String> list, 
      HashMap<String, String> hmPQdata) { 
     store(objDataKey, list, hmPQdata); 

    } 

} 

class DataKey { 
    private String key; 

    public String getKey() { 
     return key; 
    } 

    public void setKey(String key) { 
     this.key = key; 
    } 
} 

public void sendDataToQueue(DataKey objDataKey, ArrayList<String> list, HashMap<String, String> hmPQdata) { 
    // sending data to queue 

} 

}

用户1：

public class UserA { 

public static void main(String[] args) { 
    DataProcessor objDataProcessor = new DataProcessor(); 
    Thread thProcessorThread = new Thread(objDataProcessor, "PROCESSOR"); 
    thProcessorThread.start(); 
} 

}

用户2：

public class UserB { 

public static void main(String[] args) { 
    DataProcessor objDataProcessor = new DataProcessor(); 
    Thread thProcessorThread = new Thread(objDataProcessor, "PROCESSOR"); 
    thProcessorThread.start(); 
} 

}

用户A & B将被调用在同一时间数据处理器线程。 很明显，选项1 & 2将是面对竞争条件，因为它们锁定了该类的类对象/自我类对象锁定，选项3将在类级别上提供锁定 - 如果多个用户同时访问该程序，则选项3会减慢应用程序的速度，而多线程的整体目标将继续折腾。

任何人都可以请建议任何关于如何处理这种情况。

编辑：

可以在任何一个请帮助办理SendNForgotHelperThread线程对象上竞争条件 - 此线程循环，每个循环新的线程SendNForgotHelperThread正在开始被调用。

Answer 1

您正在将DataProcessor的两个不同实例传递给UserA和UserB中的线程，如果您启动这些主要方法，它将正常运行。比赛条件不会发生在您的应用程序中。

对于竞争条件出现，你必须通过共享对象，即多个线程在同一对象和共享对象应具备现场进行操作/属性在多个线程之间共享得到

DataProcessor objDataProcessor = new DataProcessor(); 
    Thread thProcessorThread1 = new Thread(objDataProcessor, "PROCESSOR-1"); 
    thProcessorThread1.start(); 
    Thread thProcessorThread2 = new Thread(objDataProcessor, "PROCESSOR-2"); 
    thProcessorThread2.start();