Converting program code of a multi-threaded program into program code causing less lock contentions

A computer system for executing a conversion computer program for converting a first program code in a multi-threaded program into a second program code which causes less lock contention, the computer system comprising:

• a storage unit in which the first program code and the conversion computer program are stored;
• and
• a central processing unit (CPU) configured for
• loading the computer program, from the storage unit into a memory,
• determining whether the first program code includes either (i) a first class having a method call to a class that operates while taking synchronization by locking, or (ii) a second class inheriting a parent class that operates while taking synchronization by locking,
• converting the first class having the method call to a third class that operates while taking synchronization by locking into a class having a first method call to a concurrent operation executable fourth class that has a functionality equivalent to that of the third class and having a shorter lock holding section than the third class, and
• converting the second class having a method call to the parent class into a class having a second method call to a concurrent operation executable class that has a functionality equivalent to that of the parent class and having a shorter lock holding section than the second class, wherein:
• if code including the class having the second method call is enclosed in a synchronized block code, then the step of converting into the class having the second method call further comprises changing the position of the synchronized block code, and
• if the code enclosed in the synchronized block code includes code including a second method call to retrieve a thread-shared value while locking and a path to be executed if a predetermined value is returned as a result of the second method call, then the step of changing the position of the synchronized block code includes the steps of:
• deleting the synchronized block code;
• enclosing the path in a new synchronized block code;
• and
• adding, to the code enclosed in the new synchronized block code, the code including the second method call to retrieve the thread-shared value while locking.

A non-transitory computer readable storage medium tangibly embodying computer readable instructions which when executed causes a computer to carry out the steps of the method for controlling data comprising the steps of:

• determining whether the first program code includes either (i) a first class having a method call to a class that operates while taking synchronization by locking, or (ii) a second class inheriting a parent class that operates while taking synchronization by locking;
• in response to the determination that the first program code includes the first class, converting the first class having the method call to a third class that operates while taking synchronization by locking, into a class having a first method call to a concurrent operation executable fourth class that has a functionality equivalent to that of the third class, and having a shorter lock holding section than the third class;
• and
• in response to the determination that the first program code includes the second class, converting the second class having a method call to the parent class, into a class having a second method call to a concurrent operation executable class that has a functionality equivalent to that of the parent class, and having a shorter lock holding section than the second class, wherein:
• if code including the class having the first method call or the class having the second method call is enclosed in a synchronized block code, then the step of converting into the class having the first method call or converting into the class having the second method call further comprises rewriting the code enclosed in the synchronized block code, and
• if the code enclosed in the synchronized block code involves two or more operations selected from the first method call or the second method call to retrieve the thread-shared value, to read a private instance variable, and to read a private static variable, then the step of rewriting the code enclosed in the synchronized block code further comprises the steps of:
• replacing the synchronized block code with a read block code;
• and
• changing a write block code in which a command to update a variable to be referred to in the first or the second method call or in the reading is enclosed, to code enclosed in another synchronized block code including the command to update the variable.