Protecting object identity in a language with built-in synchronization objects

• US 20040039746A1
• Filed: 06/12/2003
• Published: 02/26/2004
• Est. Priority Date: 06/14/2002
• Status: Active Grant

• Current Assignee: Oracle America, Inc. (Oracle Corporation)
• Original Assignee: Sun Microsystems Incorporated (Oracle Corporation)
• Inventors: Bracha, Gilad
• Granted Patent: US 7,458,061 B2
• Time in Patent Office: Days
• US Class Current: 707/100
• CPC Class Codes: G06F 16/289 Object oriented databases
• CPC Class Codes: G06F 9/526 Mutual exclusion algorithms

Abstract

Methods and systems for protecting object identity in an object-oriented programming language. An object from a class for protecting object identity is instantiated in memory. The object includes a first method that determines whether two object values are equal, and a second method that overrides an identity method associated with a superclass of the object by invoking the first method, the identity method for determining the identity of two objects. The object is immediately locked in response to the instantiating, so that the identity of the locked object is protected from threads that attempt to synchronize on the locked object.

Claims

1. A process for protecting object identity in an object-oriented programming language, comprising:

instantiating an object in memory; and

locking the object in response to the instantiating, wherein the identity of the locked object is protected from threads that attempt to synchronize on the locked object.

2. The process of claim 1, wherein the object includes a first method that determines whether two object values are equal, and a second method that overrides an identity method associated with a superclass of the object by invoking the first method, the identity method for determining the identity of two objects.

3. The process of claim 2, wherein the second method is a final method.

4. The process of claim 1, the locking comprising:

setting a bit in a header of the object using a thread.

5. The process of claim 4, wherein the thread that changes the bit is a system thread that does not run user code.

6. The process of claim 1, wherein the locking and the instantiating occur nearly simultaneously.

7. A process for protecting object identity in an object-oriented programming language, comprising:

instantiating an object in memory, the object including a first method that determines whether two object values are equal, and a second method that overrides an identity method associated with a superclass of the object by invoking the first method, the identity method for determining the identity of two objects; and

locking the object in response to the instantiating, wherein the identity of the locked object is protected from threads that attempt to synchronize on the locked object.

8. The process of claim 7, wherein the second method is a final method.

9. The process of claim 7, wherein the object includes a third method that returns a hash code for a given object.

10. The process of claim 7, the locking comprising:

changing a bit in a header of the object using a thread.

11. The process of claim 10, wherein the thread that changes the bit is a system thread that does not run user code.

12. A process for protecting object identity in an object-oriented programming language, comprising:

receiving code including an identity operator;

invoking an identity method associated with the identity operator;

performing a first method based on a determination that the identity method is associated with an object from a first class, the first method for determining whether two object values are substantially equal; and

performing an identity function based on a determination that the identity method is not associated with an object from the first class, the identity function for determining whether two object references refer to the same object.

13. The process of claim 12, wherein the identity method associated with the object from the first class is a final method that invokes the first method.

14. The process of claim 12, wherein the object from the first class is locked upon instantiation so that the identity of the locked object is protected from threads that attempt to synchronize on the locked object.

15. An object from a class for protecting object identity in an object-oriented programming language, comprising:

a first method that determines whether two object values are equal; and

a second method that overrides an identity method associated with a superclass of the object by invoking the first method, the identity method for determining the identity of two objects.

16. The object of claim 15, wherein the second method is a final method.

17. The object of claim 15, further comprising:

a third method that returns a hash code for a given object.

18. The object of claim 15, wherein all fields of the object are final.

19. The object of claim 15, wherein the object is locked by a thread upon instantiation, so that the identity of the object is indeterminable.

20. A class hierarchy for protecting object identity in an object-oriented programming language, comprising:

a first class including a first identity method configured to determine identity of two objects;

a second class including a second identity method and an equals method for determining whether two object values are equal, the second identity method overriding the first identity method by invoking the equals method, wherein the second class is a direct abstract subclass of the first class; and

a third class that inherits the second identity method from the second class, wherein the third class is a subclass of the second class and an object from the third class is locked upon instantiation in memory so that the identity of the locked object is protected from threads that attempt to synchronize on the locked object.

21. The class hierarchy of claim 20, wherein the second identity method is a final method.

22. The class hierarchy of claim 20, wherein the locking thread is a system thread that does not run user code.

23. An object from a class for protecting object identity in an object-oriented programming language, comprising:

a first method that determines whether two object values are equal; and

a second method that overrides an identity method associated with a superclass of the object by invoking the first method, the identity method for determining the identity of two objects,

wherein the object is locked upon instantiation so that threads fail when attempting to synchronize on the locked object.

24. The object of claim 23, wherein the second method is a final method.

25. The object of claim 23, further comprising:

a third method that returns a hash code for a given object.

26. The object of claim 23, wherein all fields of the object are final.

27. An apparatus for protecting object identity in an object-oriented programming language, comprising:

means for instantiating an object in memory; and

means for locking the object in response to the instantiating, wherein the identity of the locked object is protected from threads that attempt to synchronize on the locked object.

28. The apparatus of claim 27, wherein the object includes a first method that determines whether two object values are equal, and a second method that overrides an identity method associated with a superclass of the object by invoking the first method, the identity method for determining the identity of two objects.

29. The apparatus of claim 28, wherein the second method is a final method.

30. The apparatus of claim 28, said means for locking comprising:

means for changing a bit in a header of the object using a thread.

31. The apparatus of claim 30, wherein the thread that changes the bit is a system thread that does not run user code.

32. An apparatus for protecting object identity in an object-oriented programming language, comprising:

means for instantiating an object in memory, the object including a first method that determines whether two object values are equal, and a second method that overrides an identity method associated with a superclass of the object by invoking the first method, the identity method for determining the identity of two objects; and

means for locking the object in response to the instantiating, wherein the identity of the locked object is protected from threads that attempt to synchronize on the locked object.

33. The apparatus of claim 32, wherein the second method is a final method.

34. The apparatus of claim 32, wherein the object includes a third method that returns a hash code for a given object.

35. An apparatus for protecting object identity in an object-oriented programming language, comprising:

means for receiving code including an identity operator;

means for invoking an identity method associated with the identity operator;

means for performing a first method based on a determination that the identity method is associated with an object from a first class, the first method for determining whether two object values are substantially equal; and

means for performing an identity function based on a determination that the identity method is not associated with an object from the first class, the identity function for determining whether two object references refer to the same object.

36. The apparatus of claim 35, wherein the identity method associated with the object from the first class is a final method that invokes the first method.

37. The apparatus of claim 35, wherein the object from the first class is locked using a thread upon instantiation in memory so that the identity of the locked object is protected from threads that attempt to synchronize on the locked object.

38. A computer-readable medium containing instructions for performing a process for protecting object identity in an object-oriented programming language, the process comprising:

instantiating an object in memory, the object including a first method that determines whether two object values are equal, and a second method that overrides an identity method from a superclass of the object by invoking the first method, the identity method for determining the identity of two objects; and

locking the object in response to the instantiating, wherein the identity of the locked object is protected from threads that attempt to synchronize on the locked object.

39. The computer-readable medium of claim 38, wherein the second method is a final method.

40. The computer-readable medium of claim 38, wherein the object includes a third method that returns a hash code for a given object.

41. The computer-readable medium of claim 38, the locking comprising:

changing a bit in a header of the object using a thread.

42. The computer-readable medium of claim 41, wherein the thread that changes the bit is a system thread that does not run user code.

43. An apparatus for protecting object identity in an object-oriented programming language, comprising:

a memory having a program that;

instantiates an object in memory, the object including a first method that determines whether two object values are equal, and a second method that overrides an identity method associated with a superclass of the object by invoking the first method, the identity method for determining the identity of two objects; and

locking the object in response to the instantiating, wherein the identity of the locked object is protected from threads that attempt to synchronize on the locked object; and

a processor that runs the program.

44. An apparatus for protecting object identity in an object-oriented programming language, comprising:

a memory having a program that;

invokes an identity method associated with an identity operator;

performs a first method based on a determination that the identity method is associated with an object from a first class, the first method for determining whether two object values are equal; and

performs an identity function based on a determination that the identity method is not associated with an object from the first class, the identity function for determining whether two object references refer to the same object; and

a processor that runs the program.