Synchronized method in a java class used by many interfaces

Question

My interface (idoc to file) is using a java class, which has one method that reads a table from a central database and after doing some calculations updates it.
(The interface instantiate the class inside a user-defined function and calls the method there.)
The problem is that if somebody sends 100 idocs at the same time, there can be a “dirty read”, I mean, a read just before other interface updates the table.
We want the following:
Interface 1:
-          Read counter from the table (counter = 5 )
-          Increment counter (counter = 6)
-          Update table with that counter (table with counter = 6)
Interface 2:
-          Read counter from the table (counter = 6 )
-          Increment counter (counter = 7)
-          Update table with that counter (table with counter = 7)
RESULT: The table has the counter = 7
But what is happening is the following:
-          Interface 1 reads (counter = 5)
-          Interface 2 reads (counter = 5)
-          Interface 1 increments counter (counter = 6)
-          Interface 2 increments counter (counter = 6)
-          Interface 1 updates table (table with counter = 6)
-          Interface 2 updates table (table with counter = 6)
RESULT: The table has the counter = 6 (WRONG)
I made the method synchronized. What I was expecting was that only one interface (i1) could enter the method (read the table and update it) while other interfaces running at the same time would have to wait until i1 finished that method.
My first test indicates that's not happening. Can anybody help me to find a solution?

Answer 1

Hi Bhavesh,
If the QOS is EOIO this means that the integration engine manage the call to the mapping program (and all the other blocks) inside an "internal" synchronized method.
So this means that in this case you do not need to manage the queued access (synchronization) inside your custom java code because it is already enveloped in a queued block by XI.
The problem that Jorge had can be easily reproduced using the sample code that follows:
<b>class Synch Object</b>
import java.util.Date;
public class SynchObject {
     String strName;
     public SynchObject(String strName){
          this.strName = strName;
     public synchronized void syncWrite(String strCaller) throws InterruptedException{
          Date now;
          now = new Date();
          System.out.println("-- " + now.toLocaleString() + " " + strCaller + " entering syncWrite of " + strName);
          System.out.flush();
          Thread.sleep(1000);
          now = new Date();
          System.out.println("-- " + now.toLocaleString() + " syncWrite of " + strName + " called by " + strCaller );
          System.out.flush();
          Thread.sleep(1000);
          now = new Date();
          System.out.println("-- " + now.toLocaleString() + " " + strCaller + " leaving syncWrite of " + strName);
          System.out.println("");
          System.out.flush();
<b>class Caller</b>
public class Caller implements Runnable {
     String strName;
     SynchObject target;
     int intMax;
     public Caller(String strName, SynchObject target, int intMax) {
          this.strName = strName;
          this.target = target;
          this.intMax = intMax;
     public void run() {
          for(int i=0; i<intMax;i++)
               try {
                    target.syncWrite(strName);
               } catch (InterruptedException e) {
                    e.printStackTrace();
<b>class Workbench</b>
public class Workbench {
     public static void main(String[] args) {
          // TODO Auto-generated method stub
          SynchObject sObj1 = new SynchObject("syncObj1");
          SynchObject sObj2 = new SynchObject("syncObj2");
          Caller c1 = new Caller("caller1",sObj1,2);
          Caller c2 = new Caller("caller2",sObj1,2); '[*CHANGE*]
          Thread ct1 = new Thread(c1);
          Thread ct2 = new Thread(c2);
          ct1.start();
          ct2.start();
Run the workbench class to see what happen when setting QOS EOIO (the synch object is the same).
To see instead what happen now (missing synchronization) you have to change in Workbench class the statement
Caller c2 = new Caller("caller2",sObj1,2); '[*CHANGE*]
with
Caller c2 = new Caller("caller2",sObj2,2); '[*CHANGE*]
The reason is that every instance of the mapping program declare a new instance of the "Synchronized object" so the calls are synchronized inside the same mapping program but not between several mapping program.
Hope this give you a better idea on this problems with java synchronization, but if you have further doubts (I know it's a little bit tricky ) feel free to ask.
Kind Regards,
Sergio