System and method for minimizing inter-application interference among static synchronized methods

• US 6,557,168 B1
• Filed: 02/25/2000
• Issued: 04/29/2003
• Est. Priority Date: 02/25/2000
• Status: Active Grant

• Current Assignee: Oracle America, Inc. (Oracle Corporation)
• Original Assignee: Sun Microsystems Incorporated (Oracle Corporation)
• Inventors: Czajkowski, Grzegorz J.
• Primary Examiner(s): Morse, Gregory
• Assistant Examiner(s): ZHEN, WEI Y
• Application Number:
  US09/513,292
• Time in Patent Office: 1,159 Days
• Field of Search: 717/127-133, 717/151, 717/152, 717/153, 717/159, 717/161, 709/100, 709/102, 709/400, 709/248
• US Class Current: 717/151
• CPC Class Codes: G06F 9/4488 Object-oriented

Abstract

A system and method for isolating the execution of a plurality of applications. A plurality of monitors are provided for a plurality of applications to access a static synchronized method. The applications are enabled to call the static synchronized method concurrently by accessing the static synchronized method through the plurality of monitors. A plurality of threads within one of the applications are excluded from calling the static synchronized method concurrently. The source code or bytecode for the synchronized method may be transformed by removing a method-level monitor and adding the plurality of monitors inside the method. In one embodiment, each static synchronized method is replaced with a corresponding static non-synchronized method. The applications may be further isolated by placing the static fields of shared classes into a static field class, which has one instance per utilizing application. The static non-synchronized method includes the body of the corresponding static synchronized method, wherein the body is synchronized on the instance of the static field class that corresponds to the utilizing application.

Claims

1. A method for isolating the execution of a plurality of applications, the method comprising:

providing a plurality of monitors to access a synchronized method;

enabling two or more of a plurality of applications to call the synchronized method concurrently by accessing the synchronized method through the plurality of monitors; and

excluding a plurality of threads within one of the applications from calling the synchronized method concurrently.

2. The method of claim 1,

wherein each monitor corresponds to one of the plurality of applications which calls the synchronized method.

3. The method of claim 1, further comprising:

transforming source code for the synchronized method by removing a method-level monitor and adding the plurality of monitors inside the method.

4. The method of claim 1, further comprising:

transforming bytecode for the synchronized method by removing a method-level monitor and adding the plurality of monitors inside the method.

5. The method of claim 1,

wherein the synchronized method is a static synchronized method.

6. A method for isolating the execution of a plurality of applications, the method comprising:

extracting zero or more static fields from an original class utilized by any of the plurality of applications, wherein the original class comprises at least one static synchronized method, and wherein each static synchronized method comprises an executable block;

creating a static field class, wherein the static field class comprises zero or more instance fields corresponding to the zero or more static fields, and wherein each instance of the static field class corresponds to one of the plurality of applications; and

replacing each static synchronized method with a corresponding static non-synchronized method, wherein the corresponding static non-synchronized method comprises the executable block from the corresponding static synchronized method which is synchronized on the corresponding instance of the static field class for the utilizing application.

7. The method of claim 6, wherein replacing each static synchronized method with the corresponding static non-synchronized method further comprises providing a plurality of monitors to access the static non-synchronized method.

8. The method of claim 6, wherein replacing each static synchronized method with the corresponding static non-synchronized method further comprises enabling two or more of the applications to call the static non-synchronized method concurrently by accessing the synchronized method through a plurality of monitors.

9. The method of claim 6, wherein replacing each static synchronized method with the corresponding static non-synchronized method further comprises excluding a plurality of threads within one of the applications from calling the static non-synchronized method concurrently.

10. The method of claim 6, further comprising:

creating on e or more access methods for the static fields, wherein the access methods are operable to access the corresponding instance of the static field class based upon the identity of the utilizing application.

11. The method of claim 6, wherein extracting the static fields, creating the static field class, and replacing each static synchronized method are performed within a virtual machine.

12. The method of claim 11, wherein the virtual machine is implemented in accordance with a platform-independent virtual machine specification.

13. The method of claim 6, wherein the plurality of applications are executable in a platform-independent programming environment.

14. The method of claim 6, wherein extracting the static fields, creating the static field class, and replacing each static synchronized method is transparent to the utilizing applications.

15. The method of claim 6, wherein extracting the static fields, creating the static field class, and replacing each static synchronized method are performed at run-time.

16. The method of claim 6, wherein extracting the static fields, creating the static field class, and replacing each static synchronized method are performed at compilation.

17. The method of claim 6, wherein extracting the static fields, creating the static field class, and replacing each static synchronized method further comprise transforming the bytecode of the one or more applications.

18. The method of claim 6, wherein extracting the static fields, creating the static field class, and replacing each static synchronized method further comprise transforming the source code of the one or more applications.

19. A system for isolating the execution of a plurality of applications, the system comprising:

an original class utilized by the plurality of applications, wherein the original class comprises zero or more static fields and one or more static synchronized methods, and wherein each of the static synchronized methods comprises an executable block;

a modified original class generated from the original class, wherein the modified class comprises the original class without the static fields;

a static field class generated from the original class, wherein each instance of the static field class corresponds to one of the plurality of applications, and wherein the static field class comprises zero or more instance fields corresponding to the zero or more static fields of the original class; and

one or more static non-synchronized methods, wherein each static non-synchronized method is generated from a corresponding one of the static synchronized methods, and wherein each static non-synchronized method comprises the executable block from the corresponding static synchronized method which is synchronized on the corresponding instance of the static field class for the utilizing application.

20. The system of claim 19, further comprising:

a virtual machine which is operable to execute the plurality of applications.

21. The system of claim 19, wherein the plurality of applications are executable in a platform-independent programming environment.

22. The system of claim 19, further comprising:

an access methods class generated from the original class, wherein the access methods class comprises one or more access methods for accessing the instance fields of the static field class.

23. A carrier medium comprising program instructions which are computer-executable to implement:

extracting zero or more static fields from an original class utilized by any of a plurality of applications, wherein the original class comprises at least one static synchronized method, and wherein each static synchronized method comprises an executable block;

creating a static field class, wherein the static field class comprises zero or more instance fields corresponding to the zero or more static fields, and wherein each instance of the static field class corresponds to one of the plurality of applications; and

replacing each static synchronized method with a corresponding static non-synchronized method, wherein the corresponding static non-synchronized method comprises the executable block from the corresponding static synchronized method which is synchronized on the corresponding instance of the static field class for the utilizing application.

24. The carrier medium of claim 23, wherein in replacing each static synchronized method with the corresponding static non-synchronized method, the program instructions are further computer-executable to implement providing a plurality of monitors to access the static non-synchronized method.

25. The carrier medium of claim 23, wherein in replacing each static synchronized method with the corresponding static non-synchronized method, the program instructions are further computer-executable to implement enabling two or more of the applications to call the static non-synchronized method concurrently by accessing the synchronized method through a plurality of monitors.

26. The carrier medium of claim 23, wherein in replacing each static synchronized method with the corresponding static non-synchronized method, the program instructions are further computer-executable to implement excluding a plurality of threads within one of the applications from calling the static non-synchronized method concurrently.

27. The carrier medium of claim 23, wherein the program instructions are further computer-executable to implement:

creating one or more access methods for the static fields, wherein the access methods are operable to access the corresponding instance of the static field class based upon the identity of the utilizing application.

28. The carrier medium of claim 23, wherein extracting the static fields, creating the static field class, and replacing each static synchronized method are performed within a virtual machine which is implemented in accordance with a platform-independent virtual machine specification.

29. The carrier medium of claim 23, wherein the carrier medium is a memory medium.

30. The carrier medium of claim 23, wherein the carrier medium is a transmission medium.