Shulou(Shulou.com)06/03 Report--

This article is to share with you what are the practical tips in JDK source code. The editor thinks it is very practical, so share it with you as a reference and follow the editor to have a look.

1 iTunes + vs iMurray-

Line 985 of the String source code, in the equals method

While (n-murmur = 0) {if (v1 [I]! = v2 [I]) return false; iTunes;}

This code is used to determine whether a string is equal or not, but there is a strange place to judge by using iMushroom equal 0. Don't we usually use iColor +? Why use iMurray -? And the number of cycles is the same. The reason is that there will be one more instruction after compilation:

The operation itself affects CPSR (current program status register). The common flags of CPSR are N (negative result), Z (result 0), C (carry), O (overflow). I > 0 can be judged directly by the Z flag.

The iTunes + operation also affects CPSR (the current program status register), but only the O (with overflow) flag, which for I

< n的判断没有任何帮助。所以还需要一条额外的比较指令，也就是说每个循环要多执行一条指令。 简单来说，跟0比较会少一条指令。所以，循环使用i--，高端大气上档次。 2 成员变量 vs 局部变量 JDK源码在任何方法中几乎都会用一个局部变量来接受成员变量，比如 public int compareTo(String anotherString) { int len1 = value.length; int len2 = anotherString.value.length; 因为局部变量初始化后是在该方法线程栈中，而成员变量初始化是在堆内存中，显然前者更快，所以，我们在方法中尽量避免直接使用成员变量，而是使用局部变量。 3 刻意加载到寄存器 && 将耗时操作放到锁外部 在ConcurrentHashMap中，锁segment的操作很有意思，它不是直接锁，而是类似于自旋锁，反复尝试获取锁，并且在获取锁的过程中，会遍历链表，从而将数据先加载到寄存器中缓存中，避免在锁的过程中在便利，同时，生成新对象的操作也是放到锁的外部来做，避免在锁中的耗时操作 final V put(K key, int hash, V value, boolean onlyIfAbsent) { /** 在往该 segment 写入前，需要先获取该 segment 的独占锁 不是强制lock()，而是进行尝试 */ HashEntry node = tryLock() ? null : scanAndLockForPut(key, hash, value); scanAndLockForPut()源码 private HashEntry scanAndLockForPut(K key, int hash, V value) { HashEntry first = entryForHash(this, hash); HashEntry e = first; HashEntry node = null; int retries = -1; // negative while locating node // 循环获取锁 while (!tryLock()) { HashEntry f; // to recheck first below if (retries < 0) { if (e == null) { if (node == null) // speculatively create node //该hash位无值，新建对象，而不用再到put()方法的锁中再新建 node = new HashEntry(hash, key, value, null); retries = 0; } //该hash位置key也相同，退化成自旋锁 else if (key.equals(e.key)) retries = 0; else // 循环链表，cpu能自动将链表读入缓存 e = e.next; } // retries>

It becomes a spin lock at 0. Of course, if the number of retries exceeds MAX_SCAN_RETRIES (single core 1 multi-core 64), then no more, enter the blocking queue and wait for the lock / / lock () is the blocking method, until the lock is acquired and returned, otherwise suspend else if (+ + retries > MAX_SCAN_RETRIES) {lock (); break } else if ((retries & 1) = = 0 & & / / there is a big problem at this time, that is, there are new elements in the linked list and become the new header / / so the strategy here is equivalent to repeating the scanAndLockForPut method (f = entryForHash (this, hash)! = first) {e = first = f / / re-traverse if entry changed retries =-1;}} return node;}

4 to judge the equality of an object, you can first use = =

When judging whether an object is equal, you can first use = =, because it is very fast to compare the address directly, while the comparison of the most object value in equals is relatively slow, so if possible, you can use "equal" to compare whether the object is equal | | a.equals (b).

5 about transient

Transient is used to block serialization, but the internal array in the HashMap source code is defined as transient

/ * The table, resized as necessary. Length MUST Always be a power of two. * / transient Entry [] table = (Entry []) EMPTY_TABLE

Isn't it possible that the key-value pairs cannot be serialized? it is impossible to transmit with hashmap in the network, but it is not.

The great god Effective Java 2nd, Item75, Joshua mentioned:

For example, consider the case of a hash table. The physical

Representation is a sequence of hash buckets containing key-value

Entries. The bucket that an entry resides in is a function of the hash

Code of its key, which is not, in general, guaranteed to be the same

From JVM implementation to JVM implementation. In fact, it isn't even

Guaranteed to be the same from run to run. Therefore, accepting the

Default serialized form for a hash table would constitute a serious

Bug. Serializing and deserializing the hash table could yield an

Object whose invariants were seriously corrupt.

How do you understand it? If you look at HashMap.get () / put (), you can see that reading and writing Map determines which bucket to read / write from based on Object.hashcode (). While Object.hashcode () is the native method, it may be different in different JVM.

For example, save an entry to HashMap, and key is the string "STRING". In the first java program, the hashcode () of "STRING" is 1, and it is stored in bucket; 1. In the second java program, the hashcode () of "STRING" may be 2, and it is stored in bucket 2. If you use the default serialization (Entry [] table does not use transient), then the memory distribution of this HashMap is the same after importing the second java program through serialization from the first java program, which is not correct.

For example, for example, to HashMap to save a key value pair entry, key= "Fang Lao Si", in the first java program, "Fang Lao Si" hashcode () is 1, stored in table [1], OK, now it is passed to another JVM program, "Fang Lao Si" hashcode () may be 2, so go to table [2] to get the result value does not exist.

HashMap's readObject and writeObject now output / input the content and regenerate the HashMap.

6 do not use char

Char is utf-16 encoded in Java, which is 2 bytes, and 2 bytes cannot represent all characters. The 2-byte representation is called BMP, and the other is concatenated as high surrogate and low surrogate to form a 4-byte character. For example, indexOf in String source code:

/ / use int to accept a char here, and it is convenient to judge the range of public int indexOf (int ch, int fromIndex) {final int max = value.length; if (fromIndex).

< 0) { fromIndex = 0; } else if (fromIndex >

= max) {/ / Note: fromIndex might be near-1 > 1. Return-1;} / / in the Bmp range if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) {/ / handle most cases here (ch is a BMP code point or a / / negative value (invalid code point)) final char [] value = this.value; for (int I = fromIndex; I < max Return +) {if (value [I] = = ch) {return I;}} return-1;} else {/ / otherwise return indexOfSupplementary (ch, fromIndex);}}

So the char of Java can only represent some of the bmp characters in utf ­16. For CJK (unified ideographic characters of China, Japan and South Korea), part of the extended character set cannot be expressed.

For example, in the following figure, except for the Ext-A part, char cannot represent.

In addition, there is another saying that to use char, the password is constant (that is, it cannot be changed after creation) and will be saved to the constant pool. If there are other processes that can dump the memory of this process, then the password will be leaked by dump along with the constant pool, and char [] can write other information to change it. Even if it is dump, it will reduce the risk of password disclosure.

But personally, I think you can dump memory. Is it possible that a char can prevent it? Unless the String is not recycled in the constant pool and is read directly from the constant pool by other threads, it is probably very rare.

Thank you for reading! On "what are the practical tips in the JDK source code" this article is shared here, I hope the above content can be of some help to you, so that you can learn more knowledge, if you think the article is good, you can share it out for more people to see it!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.