【java源码系列】 - Object

架构

  • Object.java(rt.jar) 调用 jdk的native方法(Object.c)。
  • native方法 调用hotspot jvm的方法(jvm.cpp)。

Object.java

  • java source版本:oracle 1.7

Object 还有隐形的构造函数.

1
2
new Object();
new Object[int]; // 在ArrayList的构造函数中用到了

疑问:

为什么Object.java中看不到构造函数

编译器为它生成了构造函数

为什么在stack trace中看不到调用Object.

有7个native方法。

  • private static native void registerNatives();
  • protected native Object clone() throws CloneNotSupportedException;
  • public final native Class<?> getClass();
  • public native int hashCode();
  • public final native void notify();
  • public final native void notifyAll();
  • public final native void wait(long timeout) throws InterruptedException;
  • 但是构造函数是怎样实现的呢?(见jvm目录的init.md)

由于Object类中有JNI方法调用,按照JNI的规则,应当生成JNI 的头文件。
在此目录下执行javah -jni java.lang.Object 指令,将生成一个java_lang_Object.h头文件(自动生成的header,没什么意义)

Object.c

  • source版本:openjdk-7-fcs-src-b147-27_jun_2011
  • 路径: openjdk\jdk\src\share\native\java\lang\Object.c
  • 没有Object.h

Object.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/*-
* Implementation of class Object
*
* former threadruntime.c, Sun Sep 22 12:09:39 1991
*/

#include <stdio.h>
#include <signal.h>
#include <limits.h>

#include "jni.h"
#include "jni_util.h"
#include "jvm.h"

#include "java_lang_Object.h"

// JVM_这些函数是在jvm.c中实现的
static JNINativeMethod methods[] = {
{"hashCode", "()I", (void *)&JVM_IHashCode}, // 返回int
{"wait", "(J)V", (void *)&JVM_MonitorWait}, // 返回void,参数是long
{"notify", "()V", (void *)&JVM_MonitorNotify}, // 返回void
{"notifyAll", "()V", (void *)&JVM_MonitorNotifyAll}, // 返回void
{"clone", "()Ljava/lang/Object;", (void *)&JVM_Clone}, // 返回Ojbect
};

JNIEXPORT void JNICALL
Java_java_lang_Object_registerNatives(JNIEnv *env, jclass cls)
{
(*env)->RegisterNatives(env, cls,
methods, sizeof(methods)/sizeof(methods[0]));
}

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);
}
}

其中JNINativeMethod的结构体如下:

1
2
3
4
5
typedef struct {
char *name; // Java中函数的名字
char *signature; // signature 方法签名,描述了函数的参数和返回值
void *fnPtr; // native实现的函数指针,指向C函数
} JNINativeMethod;

跟踪 hashcode

1
2
3
4
5
6
7
8
9
10
11
// jvm.h 路径: openjdk\hotspot\src\share\vm\prims\jvm.h
JNIEXPORT jint JNICALL
JVM_IHashCode(JNIEnv *env, jobject obj);


// jvm.cpp 路径: openjdk\hotspot\src\share\vm\prims\jvm.cpp
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

FastHashCode才是真正计算hashcode的代码

FastHashCode

这是hashCode()的具体实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
// 路径: openjdk\hotspot\src\share\vm\runtime\synchronizer.cpp
intptr_t ObjectSynchronizer::FastHashCode (Thread * Self, oop obj) {
if (UseBiasedLocking) {
// NOTE: many places throughout the JVM do not expect a safepoint
// to be taken here, in particular most operations on perm gen
// objects. However, we only ever bias Java instances and all of
// the call sites of identity_hash that might revoke biases have
// been checked to make sure they can handle a safepoint. The
// added check of the bias pattern is to avoid useless calls to
// thread-local storage.
if (obj->mark()->has_bias_pattern()) {
// Box and unbox the raw reference just in case we cause a STW safepoint.
Handle hobj (Self, obj) ;
// Relaxing assertion for bug 6320749.
assert (Universe::verify_in_progress() ||
!SafepointSynchronize::is_at_safepoint(),
"biases should not be seen by VM thread here");
BiasedLocking::revoke_and_rebias(hobj, false, JavaThread::current());
obj = hobj() ;
assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
}
}

// hashCode() is a heap mutator ...
// Relaxing assertion for bug 6320749.
assert (Universe::verify_in_progress() ||
!SafepointSynchronize::is_at_safepoint(), "invariant") ;
assert (Universe::verify_in_progress() ||
Self->is_Java_thread() , "invariant") ;
assert (Universe::verify_in_progress() ||
((JavaThread *)Self)->thread_state() != _thread_blocked, "invariant") ;

ObjectMonitor* monitor = NULL;
markOop temp, test;
intptr_t hash;
markOop mark = ReadStableMark (obj);

// object should remain ineligible for biased locking
assert (!mark->has_bias_pattern(), "invariant") ;

if (mark->is_neutral()) {
hash = mark->hash(); // this is a normal header 对象的hashcode存储在对象头里
if (hash) { // if it has hash, just return it 注意这里有个cache,对于同一个Ojbect,第一次调用Object.hashCode将会执行实际的计算并记入cache,以后直接从cache中取出。
return hash;
}
hash = get_next_hash(Self, obj); // allocate a new hash code
temp = mark->copy_set_hash(hash); // merge the hash code into header
// use (machine word version) atomic operation to install the hash
test = (markOop) Atomic::cmpxchg_ptr(temp, obj->mark_addr(), mark);
if (test == mark) {
return hash;
}
// If atomic operation failed, we must inflate the header
// into heavy weight monitor. We could add more code here
// for fast path, but it does not worth the complexity.
} else if (mark->has_monitor()) {
monitor = mark->monitor();
temp = monitor->header();
assert (temp->is_neutral(), "invariant") ;
hash = temp->hash();
if (hash) {
return hash;
}
// Skip to the following code to reduce code size
} else if (Self->is_lock_owned((address)mark->locker())) {
temp = mark->displaced_mark_helper(); // this is a lightweight monitor owned
assert (temp->is_neutral(), "invariant") ;
hash = temp->hash(); // by current thread, check if the displaced
if (hash) { // header contains hash code
return hash;
}
// WARNING:
// The displaced header is strictly immutable.
// It can NOT be changed in ANY cases. So we have
// to inflate the header into heavyweight monitor
// even the current thread owns the lock. The reason
// is the BasicLock (stack slot) will be asynchronously
// read by other threads during the inflate() function.
// Any change to stack may not propagate to other threads
// correctly.
}

// Inflate the monitor to set hash code
monitor = ObjectSynchronizer::inflate(Self, obj);
// Load displaced header and check it has hash code
mark = monitor->header();
assert (mark->is_neutral(), "invariant") ;
hash = mark->hash(); // 取出缓存
if (hash == 0) {
hash = get_next_hash(Self, obj); // 实际计算
temp = mark->copy_set_hash(hash); // merge hash code into header
assert (temp->is_neutral(), "invariant") ;
test = (markOop) Atomic::cmpxchg_ptr(temp, monitor, mark);
if (test != mark) {
// The only update to the header in the monitor (outside GC)
// is install the hash code. If someone add new usage of
// displaced header, please update this code
hash = test->hash();
assert (test->is_neutral(), "invariant") ;
assert (hash != 0, "Trivial unexpected object/monitor header usage.");
}
}
// We finally get the hash
return hash;
}

get_next_hash

这才是核心代码

又调用的get_next_hash()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
// 路径: openjdk\hotspot\src\share\vm\runtime\synchronizer.cpp
static inline intptr_t get_next_hash(Thread * Self, oop obj) {
intptr_t value = 0 ;
if (hashCode == 0) {
// This form uses an unguarded global Park-Miller RNG,
// so it's possible for two threads to race and generate the same RNG.
// On MP system we'll have lots of RW access to a global, so the
// mechanism induces lots of coherency traffic.
value = os::random() ;
} else
if (hashCode == 1) {
// This variation has the property of being stable (idempotent)
// between STW operations. This can be useful in some of the 1-0
// synchronization schemes.
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 {
// Marsaglia's xor-shift scheme with thread-specific state
// This is probably the best overall implementation -- we'll
// likely make this the default in future releases.
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;
}

hashCode()并不是简单的返回内存地址。
OpenJDK一共实现了5中不同的计算hash值的方法,通过
这段代码中hashCode进行切换。其中hashCode == 4的是直接使用地址的(前面的实验说明OpenJDK默认情况下并没有使用这种方式,或许可以通过运行/编译时参数进行选择)。

###

结论

前面通过JNI验证已经能够得到很显然的结论,hashCode返回的并不一定是对象的(虚拟)内存地址,具体取决于运行时库和JVM的具体实现。

跟踪wait

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
JNIEXPORT void JNICALL
JVM_MonitorWait(JNIEnv *env, jobject obj, jlong ms);


// 路径: openjdk\hotspot\src\share\vm\prims\jvm.cpp
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

跟踪notify

1
2
3
4
5
6
7
8
9
10
11
JNIEXPORT void JNICALL
JVM_MonitorNotify(JNIEnv *env, jobject obj);


// 路径: openjdk\hotspot\src\share\vm\prims\jvm.cpp
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

跟踪clone

1
2
3
4
5
6
7
8
9
10
JNIEXPORT jobject JNICALL
JVM_Clone(JNIEnv *env, jobject obj);


// 路径: openjdk\hotspot\src\share\vm\prims\jvm.cpp
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;

跟踪 getClass

跟踪

参考

http://blog.csdn.net/xusiwei1236/article/details/45152201

byte code

  • 通过编译后的jar包(即class文件),查看byte code.
  • 运行 javap -c java.lang.Object > a.txt,得到以下的byte code

如果执行不成功,看看是否把jdk的lib加入到了classpath:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
Compiled from "Object.java"
public class java.lang.Object {
public java.lang.Object(); // 什么都不干?不需要调用<init>吗?
Code:
0: return

public final native java.lang.Class<?> getClass();

public native int hashCode();

public boolean equals(java.lang.Object);
Code:
0: aload_0
1: aload_1
2: if_acmpne 9
5: iconst_1
6: goto 10
9: iconst_0
10: ireturn

protected native java.lang.Object clone() throws java.lang.CloneNotSupportedException;

public java.lang.String toString();
Code:
0: new #1 // class java/lang/StringBuilder
3: dup
4: invokespecial #2 // Method java/lang/StringBuilder."<init>":()V // 注意这里,调用了<init>
7: aload_0
8: invokevirtual #3 // Method getClass:()Ljava/lang/Class;
11: invokevirtual #4 // Method java/lang/Class.getName:()Ljava/lang/String;
14: invokevirtual #5 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
17: ldc #6 // String @
19: invokevirtual #5 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
22: aload_0
23: invokevirtual #7 // Method hashCode:()I
26: invokestatic #8 // Method java/lang/Integer.toHexString:(I)Ljava/lang/String;
29: invokevirtual #5 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
32: invokevirtual #9 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
35: areturn

public final native void notify();

public final native void notifyAll();

public final native void wait(long) throws java.lang.InterruptedException;

public final void wait(long, int) throws java.lang.InterruptedException;
Code:
0: lload_1
1: lconst_0
2: lcmp
3: ifge 16
6: new #10 // class java/lang/IllegalArgumentException
9: dup
10: ldc #11 // String timeout value is negative
12: invokespecial #12 // Method java/lang/IllegalArgumentException."<init>":(Ljava/lang/String;)V
15: athrow
16: iload_3
17: iflt 26
20: iload_3
21: ldc #13 // int 999999
23: if_icmple 36
26: new #10 // class java/lang/IllegalArgumentException
29: dup
30: ldc #14 // String nanosecond timeout value out of range
32: invokespecial #12 // Method java/lang/IllegalArgumentException."<init>":(Ljava/lang/String;)V
35: athrow
36: iload_3
37: ldc #15 // int 500000
39: if_icmpge 52
42: iload_3
43: ifeq 56
46: lload_1
47: lconst_0
48: lcmp
49: ifne 56
52: lload_1
53: lconst_1
54: ladd
55: lstore_1
56: aload_0
57: lload_1
58: invokevirtual #16 // Method wait:(J)V
61: return

public final void wait() throws java.lang.InterruptedException;
Code:
0: aload_0
1: lconst_0
2: invokevirtual #16 // Method wait:(J)V
5: return

protected void finalize() throws java.lang.Throwable;
Code:
0: return

static {};
Code:
0: invokestatic #17 // Method registerNatives:()V
3: return
}

C:\Program Files\java\jdk1.7.0_67\jre\lib\rt>

其他

  • object header: it’s JVM dependent, 具体参考JVM

扩展阅读