Java从JDK源码角度对Object进行实例分析

public class object {
	private static native void registernatives();
	static {
		registernatives();
	}
	public final native class<?> getclass();
	public native int hashcode();
	public boolean equals(object obj) {
		return (this == obj);
	}
	protected native object clone() throws clonenotsupportedexception;
	public string tostring() {
		return getclass().getname() + "@" + integer.tohexstring(hashcode());
	}
	public final native void notify();
	public final native void notifyall();
	public final native void wait(long timeout) throws interruptedexception;
	public final void wait(long timeout, int nanos) throws interruptedexception {
		if (timeout < 0) {
			throw new illegalargumentexception("timeout value is negative");
		}
		if (nanos < 0 || nanos > 999999) {
			throw new illegalargumentexception("nanosecond timeout value out of range");
		}
		if (nanos > 0) {
			timeout++;
		}
		wait(timeout);
	}
	public final void wait() throws interruptedexception {
		wait(0);
	}
	protected void finalize() throws throwable {
	}
}

jniexport void jnicall
java_java_lang_object_registernatives(jnienv *env, jclass cls)
{
	(*env)->registernatives(env, cls,
	methods, sizeof(methods)/sizeof(methods[0]));
}

static jninativemethod methods[] = {
  {"hashcode",  "()i",          (void *)&jvm_ihashcode},
  {"wait",    "(j)v",          (void *)&jvm_monitorwait},
  {"notify",   "()v",          (void *)&jvm_monitornotify},
  {"notifyall",  "()v",          (void *)&jvm_monitornotifyall},
  {"clone",    "()ljava/lang/object;",  (void *)&jvm_clone},
};

jniexport jclass jnicall
java_java_lang_object_getclass(jnienv *env, jobject this)
{
  if (this == null) {
    jnu_thrownullpointerexception(env, null);
    return 0;
  } else {
    return (*env)->getobjectclass(env, this);
  }
}

jni_entry(jclass, jni_getobjectclass(jnienv *env, jobject obj))
 jniwrapper("getobjectclass");
 dtrace_probe2(hotspot_jni, getobjectclass__entry, env, obj);
 klassoop k = jnihandles::resolve_non_null(obj)->klass();
 jclass ret =
  (jclass) jnihandles::make_local(env, klass::cast(k)->java_mirror());
 dtrace_probe1(hotspot_jni, getobjectclass__return, ret);
 return ret;
jni_end

jvm_entry(jint, jvm_ihashcode(jnienv* env, jobject handle))
 jvmwrapper("jvm_ihashcode");
 // as implemented in the classic virtual machine; return 0 if object is null
 return handle == null ? 0 : objectsynchronizer::fasthashcode (thread, jnihandles::resolve_non_null(handle)) ;
jvm_end

static inline intptr_t get_next_hash(thread * self, oop obj) {
	intptr_t value = 0 ;
	if (hashcode == 0) {
		value = os::random() ;
	} else
	 if (hashcode == 1) {
		intptr_t addrbits = intptr_t(obj) >> 3 ;
		value = addrbits ^ (addrbits >> 5) ^ gvars.stwrandom ;
	} else
	 if (hashcode == 2) {
		value = 1 ;
		// for sensitivity testing
	} else
	 if (hashcode == 3) {
		value = ++gvars.hcsequence ;
	} else
	 if (hashcode == 4) {
		value = intptr_t(obj) ;
	} else {
		unsigned t = self->_hashstatex ;
		t ^= (t << 11) ;
		self->_hashstatex = self->_hashstatey ;
		self->_hashstatey = self->_hashstatez ;
		self->_hashstatez = self->_hashstatew ;
		unsigned v = self->_hashstatew ;
		v = (v ^ (v >> 19)) ^ (t ^ (t >> 8)) ;
		self->_hashstatew = v ;
		value = v ;
	}
	value &= markoopdesc::hash_mask;
	if (value == 0) value = 0xbad ;
	assert (value != markoopdesc::no_hash, "invariant") ;
	tevent (hashcode: generate) ;
	return value;
}

jvm_entry(jobject, jvm_clone(jnienv* env, jobject handle))
 jvmwrapper("jvm_clone");
handle obj(thread, jnihandles::resolve_non_null(handle));
const klasshandle klass (thread, obj->klass());
jvmtivmobjectalloceventcollector oam;
if (!klass->is_cloneable()) {
	resourcemark rm(thread);
	throw_msg_0(vmsymbols::java_lang_clonenotsupportedexception(), klass->external_name());
}
const int size = obj->size();
oop new_obj = null;
if (obj->is_javaarray()) {
	const int length = ((arrayoop)obj())->length();
	new_obj = collectedheap::array_allocate(klass, size, length, check_null);
} else {
	new_obj = collectedheap::obj_allocate(klass, size, check_null);
}
copy::conjoint_jlongs_atomic((jlong*)obj(), (jlong*)new_obj,
                (size_t)align_object_size(size) / heapwordsperlong);
new_obj->init_mark();
barrierset* bs = universe::heap()->barrier_set();
assert(bs->has_write_region_opt(), "barrier set does not have write_region");
bs->write_region(memregion((heapword*)new_obj, size));
if (klass->has_finalizer()) {
	assert(obj->is_instance(), "should be instanceoop");
	new_obj = instanceklass::register_finalizer(instanceoop(new_obj), check_null);
}
return jnihandles::make_local(env, oop(new_obj));
jvm_end

jvm_entry(void, jvm_monitornotify(jnienv* env, jobject handle))
 jvmwrapper("jvm_monitornotify");
 handle obj(thread, jnihandles::resolve_non_null(handle));
 assert(obj->is_instance() || obj->is_array(), "jvm_monitornotify must apply to an object");
 objectsynchronizer::notify(obj, check);
jvm_end

void objectmonitor::notify(traps) {
	check_owner();
	if (_waitset == null) {
		tevent (empty-notify) ;
		return ;
	}
	dtrace_monitor_probe(notify, this, object(), thread);
	int policy = knob_movenotifyee ;
	thread::spinacquire (&_waitsetlock, "waitset - notify") ;
	objectwaiter * iterator = dequeuewaiter() ;
	if (iterator != null) {
		tevent (notify1 - transfer) ;
		guarantee (iterator->tstate == objectwaiter::ts_wait, "invariant") ;
		guarantee (iterator->_notified == 0, "invariant") ;
		if (policy != 4) {
			iterator->tstate = objectwaiter::ts_enter ;
		}
		iterator->_notified = 1 ;
		objectwaiter * list = _entrylist ;
		if (list != null) {
			assert (list->_prev == null, "invariant") ;
			assert (list->tstate == objectwaiter::ts_enter, "invariant") ;
			assert (list != iterator, "invariant") ;
		}
		if (policy == 0) {
			// prepend to entrylist
			if (list == null) {
				iterator->_next = iterator->_prev = null ;
				_entrylist = iterator ;
			} else {
				list->_prev = iterator ;
				iterator->_next = list ;
				iterator->_prev = null ;
				_entrylist = iterator ;
			}
		} else
		   if (policy == 1) {
			// append to entrylist
			if (list == null) {
				iterator->_next = iterator->_prev = null ;
				_entrylist = iterator ;
			} else {
				// consider: finding the tail currently requires a linear-time walk of
				// the entrylist. we can make tail access constant-time by converting to
				// a cdll instead of using our current dll.
				objectwaiter * tail ;
				for (tail = list ; tail->_next != null ; tail = tail->_next) ;
				assert (tail != null && tail->_next == null, "invariant") ;
				tail->_next = iterator ;
				iterator->_prev = tail ;
				iterator->_next = null ;
			}
		} else
		   if (policy == 2) {
			// prepend to cxq
			// prepend to cxq
			if (list == null) {
				iterator->_next = iterator->_prev = null ;
				_entrylist = iterator ;
			} else {
				iterator->tstate = objectwaiter::ts_cxq ;
				for (;;) {
					objectwaiter * front = _cxq ;
					iterator->_next = front ;
					if (atomic::cmpxchg_ptr (iterator, &_cxq, front) == front) {
						break ;
					}
				}
			}
		} else
		   if (policy == 3) {
			// append to cxq
			iterator->tstate = objectwaiter::ts_cxq ;
			for (;;) {
				objectwaiter * tail ;
				tail = _cxq ;
				if (tail == null) {
					iterator->_next = null ;
					if (atomic::cmpxchg_ptr (iterator, &_cxq, null) == null) {
						break ;
					}
				} else {
					while (tail->_next != null) tail = tail->_next ;
					tail->_next = iterator ;
					iterator->_prev = tail ;
					iterator->_next = null ;
					break ;
				}
			}
		} else {
			parkevent * ev = iterator->_event ;
			iterator->tstate = objectwaiter::ts_run ;
			orderaccess::fence() ;
			ev->unpark() ;
		}
		if (policy < 4) {
			iterator->wait_reenter_begin(this);
		}
		// _waitsetlock protects the wait queue, not the entrylist. we could
		// move the add-to-entrylist operation, above, outside the critical section
		// protected by _waitsetlock. in practice that's not useful. with the
		// exception of wait() timeouts and interrupts the monitor owner
		// is the only thread that grabs _waitsetlock. there's almost no contention
		// on _waitsetlock so it's not profitable to reduce the length of the
		// critical section.
	}
	thread::spinrelease (&_waitsetlock) ;
	if (iterator != null && objectmonitor::_sync_notifications != null) {
		objectmonitor::_sync_notifications->inc() ;
	}
}

jvm_entry(void, jvm_monitorwait(jnienv* env, jobject handle, jlong ms))
 jvmwrapper("jvm_monitorwait");
 handle obj(thread, jnihandles::resolve_non_null(handle));
 assert(obj->is_instance() || obj->is_array(), "jvm_monitorwait must apply to an object");
 javathreadinobjectwaitstate jtiows(thread, ms != 0);
 if (jvmtiexport::should_post_monitor_wait()) {
  jvmtiexport::post_monitor_wait((javathread *)thread, (oop)obj(), ms);
 }
 objectsynchronizer::wait(obj, ms, check);
jvm_end