//------------------------------------------------------------------------------------------------------------------------ // In order to preserve oops during garbage collection, they should be // allocated and passed around via Handles within the VM. A handle is // simply an extra indirection allocated in a thread local handle area. // // A handle is a value object, so it can be passed around as a value, can // be used as a parameter w/o using &-passing, and can be returned as a // return value. // // oop parameters and return types should be Handles whenever feasible. // // Handles are declared in a straight-forward manner, e.g. // // oop obj = ...; // Handle h2(thread, obj); // allocate a new handle in thread // Handle h3; // declare handle only, no allocation occurs // ... // h3 = h1; // make h3 refer to same indirection as h1 // oop obj2 = h2(); // get handle value // h1->print(); // invoking operation on oop // // Handles are specialized for different oop types to provide extra type // information and avoid unnecessary casting. For each oop type xxxOop // there is a corresponding handle called xxxHandle.
//------------------------------------------------------------------------------------------------------------------------ // Base class for all handles. Provides overloading of frequently // used operators for ease of use.
// Direct interface, use very sparingly. // Used by JavaCalls to quickly convert handles and to create handles static data structures. // Constructor takes a dummy argument to prevent unintentional type conversion in C++.
Handle(oop *handle, bool dummy) { _handle = handle; }
// Raw handle access. Allows easy duplication of Handles. This can be very unsafe // since duplicates is only valid as long as original handle is alive.
oop* raw_value() const { return _handle; } static oop raw_resolve(oop *handle) { return handle == NULL ? (oop)NULL : *handle; }
// Metadata Handles. Unlike oop Handles these are needed to prevent metadata // from being reclaimed by RedefineClasses. // Metadata Handles should be passed around as const references to avoid copy construction // and destruction for parameters.
//------------------------------------------------------------------------------------------------------------------------ // Thread local handle area class HandleArea: public Arena {
friend class HandleMark;
friend class NoHandleMark;
friend class ResetNoHandleMark; #ifdef ASSERT
int _handle_mark_nesting;
int _no_handle_mark_nesting; #endif
HandleArea* _prev; // link to outer (older) area public: // Constructor
HandleArea(HandleArea* prev) : Arena(mtThread, Chunk::tiny_size) {
debug_only(_handle_mark_nesting = 0);
debug_only(_no_handle_mark_nesting = 0);
_prev = prev;
}
//------------------------------------------------------------------------------------------------------------------------ // Handles are allocated in a (growable) thread local handle area. Deallocation // is managed using a HandleMark. It should normally not be necessary to use // HandleMarks manually. // // A HandleMark constructor will record the current handle area top, and the // destructor will reset the top, destroying all handles allocated in between. // The following code will therefore NOT work: // // Handle h; // { // HandleMark hm(THREAD); // h = Handle(THREAD, obj); // } // h()->print(); // WRONG, h destroyed by HandleMark destructor. // // If h has to be preserved, it can be converted to an oop or a local JNI handle // across the HandleMark boundary.
// The base class of HandleMark should have been StackObj but we also heap allocate // a HandleMark when a thread is created. The operator new is for this special case.
class HandleMark { private:
Thread *_thread; // thread that owns this mark
HandleArea *_area; // saved handle area
Chunk *_chunk; // saved arena chunk
char *_hwm, *_max; // saved arena info
size_t _size_in_bytes; // size of handle area // Link to previous active HandleMark in thread
HandleMark* _previous_handle_mark;
size_t size_in_bytes() const { return _size_in_bytes; } // remove all chunks beginning with the next void chop_later_chunks(); public:
HandleMark(Thread* thread) { initialize(thread); }
~HandleMark();
// Functions used by HandleMarkCleaner // called in the constructor of HandleMarkCleaner void push(); // called in the destructor of HandleMarkCleaner void pop_and_restore(); // overloaded operators void* operator new(size_t size) throw(); void* operator new [](size_t size) throw(); voidoperatordelete(void* p); voidoperatordelete[](void* p);
};
//------------------------------------------------------------------------------------------------------------------------ // A NoHandleMark stack object will verify that no handles are allocated // in its scope. Enabled in debug mode only.
class NoHandleMark: public StackObj { public: #ifdef ASSERT
NoHandleMark();
~NoHandleMark(); #else
NoHandleMark() {}
~NoHandleMark() {} #endif
};
// ResetNoHandleMark is called in a context where there is an enclosing // NoHandleMark. A thread in _thread_in_native must not create handles so // this is used when transitioning via ThreadInVMfromNative. class ResetNoHandleMark: public StackObj {
int _no_handle_mark_nesting; public: #ifdef ASSERT
ResetNoHandleMark();
~ResetNoHandleMark(); #else
ResetNoHandleMark() {}
~ResetNoHandleMark() {} #endif
};
// The HandleMarkCleaner is a faster version of HandleMark. // It relies on the fact that there is a HandleMark further // down the stack (in JavaCalls::call_helper), and just resets // to the saved values in that HandleMark.
class HandleMarkCleaner: public StackObj { private:
Thread* _thread; public:
inline HandleMarkCleaner(Thread* thread);
inline ~HandleMarkCleaner();
};
#endif// SHARE_RUNTIME_HANDLES_HPP
Messung V0.5 in Prozent
¤ Dauer der Verarbeitung: 0.10 Sekunden
(vorverarbeitet am 2026-09-04)
¤
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
