The many faces of ownership implementation

Last week's column defined the rule of ownership. Every object has exactly one owner, the object responsible for its creation and destruction. The responsibility of ownership cannot be transferred to another object.

By objects, I'm talking not only in the object-oriented sense. All entities in a software system, from database records to program variables to COM objects, must obey the rule of ownership. These types of objects use referential integrity, scope, and reference counting, respectively, to implement ownership, but the rule is always the same.

While ownership can be properly implemented in Java, it takes discipline; garbage collection does not confer ownership for free.

RDBMS using referential integrity

Take, for example, ownership among records in a relational database. Ownership defines a strict one-to-many master-detail relationship between tables. No detail record should exist without a master record. To enforce this, we use the facilities of the DBMS to enforce referential integrity. Deletion cascades from master to detail. If you fail to properly define these relationships, you will end up with orphaned records, or worse, lost data.

C++ using scope

In C++ scope helps us define ownership. Define a member variable of class type within another class, and the inner object cannot outlive the outer. The owner intrinsically creates and destroys the owned object. Furthermore, ownership cannot be transferred. The owned object can be copied, certainly, but the copy has unique identity; the copy and the original can be changed independently. Using scope in this way, it is difficult to violate ownership.

However, the static relationship that scope implies is often not sufficient, at which time it is necessary to use pointers. When using pointers, you must manually implement ownership to avoid memory leaks, protection faults, and other nasty bugs. This requires careful use of the new and delete operators, and of constructors and destructors.

Java using scope with garbage collection

Java combines scope with garbage collection to avoid some of the memory bugs to which C++ pointers are prone. Java uses mark-and-sweep to destroy objects. At arbitrary intervals, program processing suspends and the garbage collection algorithm executes. First all objects are marked, then the network of objects starting from the root is swept clean. All objects left marked have no reference path from the root, and are therefore destroyed. At this point, program processing resumes.

Sign up for ITworld's Daily newsletter
Follow ITworld on Twitter @IT_world

• Email
• Print
• Share
  • Slashdot
  • Digg
  • Stumble
  • Reddit
  • Newsvine