墙裂推荐（java的hashcode是什么）java hashcode equals，java中的hashCode是怎么来的？，java hashcode原理，

(This is typically implemented by converting the internaladdress of the object into an integer, but this implementationtechnique is not required by theJava™ programming language.)

int main(){char var = 1;printf("%p\n", &var);}

0028FF3F

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

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

// hashCode() generation ://// Possibilities:// * MD5Digest of {obj,stwRandom}// * CRC32 of {obj,stwRandom} or any linear-feedback shift register function.// * A DES- or AES-style SBox[] mechanism// * One of the Phi-based schemes, such as:// 2654435761 = 2^32 * Phi (golden ratio)// HashCodeValue = ((uintptr_t(obj) >> 3) * 2654435761) ^ GVars.stwRandom ;// * A variation of Marsaglias shift-xor RNG scheme.// * (obj ^ stwRandom) is appealing, but can result// in undesirable regularity in the hashCode values of adjacent objects// (objects allocated back-to-back, in particular). This could potentially// result in hashtable collisions and reduced hashtable efficiency.// There are simple ways to "diffuse" the middle address bits over the// generated hashCode values:static inline intptr_t get_next_hash(Thread * Self, oop obj) {intptr_t value = 0;if (hashCode == 0) {// This form uses global Park-Miller RNG. // On MP system well 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 = cast_from_oop<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 = cast_from_oop<intptr_t>(obj);} else {// Marsaglias xor-shift scheme with thread-specific state // This is probably the best overall implementation -- well // 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;}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()) {// Handle for oop obj in case of 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() || DumpSharedSpaces ||!SafepointSynchronize::is_at_safepoint(), "invariant");assert(Universe::verify_in_progress() || DumpSharedSpaces ||Self->is_Java_thread() , "invariant");assert(Universe::verify_in_progress() || DumpSharedSpaces ||((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 if (hash) { // if it has hash, just return it 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 = obj->cas_set_mark(temp, 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, inflate_cause_hash_code);// 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 = Atomic::cmpxchg(temp, monitor->header_addr(), 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;}

int var;return &var;

void os::init_random(unsigned int initval) {_rand_seed = initval;}static int random_helper(unsigned int rand_seed) {/* standard, well-known linear congruential random generator with* next_rand = (16807*seed) mod (2**31-1)* see* (1) "Random Number Generators: Good Ones Are Hard to Find",* S.K. Park and K.W. Miller, Communications of the ACM 31:10 (Oct 1988),* (2) "Two Fast Implementations of the Minimal Standard Random* Number Generator", David G. Carta, Comm. ACM 33, 1 (Jan 1990), pp. 87-88.*/const unsigned int a = 16807;const unsigned int m = 2147483647;const int q = m / a; assert(q == 127773, "weird math");const int r = m % a; assert(r == 2836, "weird math");// compute az=2^31p+qunsigned int lo = a * (rand_seed & 0xFFFF);unsigned int hi = a * (rand_seed >> 16);lo += (hi & 0x7FFF) << 16;// if q overflowed, ignore the overflow and increment qif (lo > m) {lo &= m;++lo;}lo += hi >> 15;// if (p+q) overflowed, ignore the overflow and increment (p+q)if (lo > m) {lo &= m;++lo;}return lo;}int os::random() {// Make updating the random seed thread safe.while (true) {unsigned int seed = _rand_seed;unsigned int rand = random_helper(seed);if (Atomic::cmpxchg(rand, &_rand_seed, seed) == seed) {return static_cast<int>(rand);}}}

template <class T> inline oop cast_to_oop(T value) {return (oop)(CHECK_UNHANDLED_OOPS_ONLY((void *))(value));}//以下部分内容来源于 oopsHierachy.hpptemplate <class T> inline T cast_from_oop(oop o) {return (T)(CHECK_UNHANDLED_OOPS_ONLY((void*))o);}

value = 1;

value = ++GVars.hcSequence;

// Marsaglias xor-shift scheme with thread-specific state// This is probably the best overall implementation -- well// 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;