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

This article mainly explains "what is the difference between String, String Builder and String Buffer". Interested friends may wish to have a look. The method introduced in this paper is simple, fast and practical. Now let the editor take you to learn "what's the difference between String, String Builder and String Buffer?"

Interviewer: what's the difference between String,StringBuilder,StringBuffer?

Otaka: is this too easy? is this looking down on me?

In terms of variability, the String is immutable and the length of the StringBuilder,StringBuffer is variable.

StringBuilder > StringBuffer > String in terms of running speed.

In terms of thread safety, StringBuilder is not thread safe, while StringBuffer is thread safe.

   so String: suitable for a small number of string operations, StringBuilder: suitable for a large number of operations in the character buffer under a single thread, StringBuffer: suitable for a large number of operations in a character buffer under multithreading.

Interviewer: why is String immutable?

Otaka: because the char array that stores the data is decorated with final, it is immutable.

Interviewer: I just said that String is immutable, but the following code has changed after running. Why? Public class Demo {public static void main (String [] args) {String str = "different"; str = str + "tech nerd"; System.out.println (str);}}

Obviously, the result of the above operation is: different tech nerds.

We first compile with javac Demo.class, and then decompile javap-verbose Demo to get the following result:

Public static void main (java.lang.String []); descriptor: ([Ljava/lang/String ) V flags: ACC_PUBLIC, ACC_STATIC Code: stack=2, locals=2 Args_size=1 0: ldc # 2 / / String different 2: astore_1 3: new # 3 / / class java/lang/StringBuilder 6: dup 7: invokespecial # 4 / / Method java/lang/StringBuilder. "": () V 10: aload_ 1 11: invokevirtual # 5 / / Method java/lang/StringBuilder.append: (Ljava/lang/String ) Ljava/lang/StringBuilder; 14: ldc # 6 / / String Tech House 16: invokevirtual # 5 / / Method java/lang/StringBuilder.append: (Ljava/lang/String;) Ljava/lang/StringBuilder; 19: invokevirtual # 7 / / Method java/lang/StringBuilder.toString: () Ljava/lang/String 22: astore_1 23: getstatic # 8 / / Field java/lang/System.out:Ljava/io/PrintStream; 26: aload_1 27: invokevirtual # 9 / / Method java/io/PrintStream.println: (Ljava/lang/String;) V 30: return

   We can find that when using + for stitching, jvm actually initializes a StringBuilder for stitching. The compiled code is as follows:

Public class Demo {public static void main (String [] args) {String str = "different"; StringBuilder builder = new StringBuilder (); builder.append (str); builder.append ("tech geek"); str = builder.toString (); System.out.println (str);}}

We can look at the implementation of builder.toString ();.

@ Overridepublic String toString () {/ / Create a copy, don't share the array return new String (value, 0, count);}

   it is clear that the toString method generates a new String object rather than changing the contents of the old str, which is equivalent to pointing a reference to the old str to the new String object. This is why str has changed.

Share an interview question I came across. Can you guess what the answer is? There is an analysis at the end of the article.

Public class Demo {public static void main (String [] args) {String str = null; str = str + "; System.out.println (str);}} interviewer: can the String class be inherited?

Otaka: no, because the String class is decorated with the final keyword, so it cannot be inherited, and StringBuilder,StringBuffer is also modified by the final keyword.

Interviewer: why is String Buffer thread safe?

Otaka: this is because the common methods in the StringBuffer class use synchronized for synchronization, so it is thread-safe, while StringBuilder does not. This is why the running speed is StringBuilder > StringBuffer.

Interviewer: you mentioned the keyword synchronized just now. Can you tell me about the expression of synchronized?

Xiao Zhai:

For normal synchronization methods, the lock is the current instance object.

For static synchronization methods, the lock is the class object of the current class.

For synchronous method blocks, locks are objects configured in Synchonized parentheses.

Interviewer: can you tell me the principle of synchronized?

Otaka: synchronized is a heavyweight lock that implements monitor monitor locks that depend on JVM. Monitorenter and monitorexit instructions are mainly used to achieve method synchronization and code block synchronization. At compile time, the monitorexit instruction is inserted at the beginning of the synchronous code block, while the monitorexit insertion method ends and the exception, and each monitorexit has a corresponding monitorexit.

   any object has a monitor associated with it. When a monitor is held, it will be locked. When the thread executes the monitorenter instruction time, it will attempt to acquire the ownership of the corresponding monitor of the object, that is, to acquire the lock of the object. Because the monitorexit will be inserted into the end of the method and the exception during the compilation time, the lock will be automatically released when the method is executed or an exception occurs.

Interviewer: you mentioned earlier that synchronized is a heavyweight lock. Do you know its optimization?

Otaka: in order to reduce the performance loss caused by acquiring and releasing locks, biased locks, lightweight locks and heavy locks are introduced for optimization. The lock upgrade process is as follows:

   is first of all a lock-free state. When a thread enters a synchronous code block, it checks whether the ID stored in the current thread is stored in the lock record in the object header and in the stack frame, if CAS is not used for replacement. Later, the thread entering and exiting the synchronous code block does not need to be locked and unlocked by CAS operations, but only needs to determine whether a biased lock pointing to the current thread is stored in the Mark word of the object header. If there is an indication that the lock has been acquired, if not or not, it needs to be replaced with CAS, and if the setting is successful, the current thread holds the biased lock, otherwise the biased lock is undone and upgraded to a lightweight lock.

   lightweight lock locking process, before the thread executes the synchronization block, JVM creates a space to store the lock record in the stack frame of the current thread, and copies the Mark Word of the object header to the lock record (Displaced Mark Word). Then the thread attempts to use CAS to replace the Mark Word in the object header with a pointer to the lock record. If successful, the current thread acquires the lock, which means that other threads compete for the lock, and the current thread attempts to acquire the lock using spin.

   lightweight lock unlocking process, when unlocking, will use CAS to replace the Displaced Mark Word back to the object header, if successful, it means that the competition has not occurred, otherwise it means that the current lock competition lock will expand into a heavy lock.

Upgrade process flow chart

In vernacular words:

   may have the upgrade process and upgrade process diagram above, which is a little difficult to understand and a little winding. Can we first understand why there is a lock upgrade process? The authors of HotSpot have found that in most cases, locks are not only not multithreaded, but are always acquired by the same thread multiple times. The process of lock upgrade is introduced to avoid the performance loss caused by acquiring the lock and releasing the lock. Understanding the lock upgrade process needs to be clear: only when there is competition will the lock be upgraded and cannot be degraded.

   We demonstrate how locks are inflated by synchronizing blocks of code with two threads T1 and T2. We start with the unlocked state, when T1 enters the synchronization code block to determine a state of the current lock. When it is found to be in an unlocked state, CAS is used to point the thread Id in the lock record to T1 and change from an unlocked state to a biased lock. After running for a period of time, T2 enters the synchronous code block and finds that it is already biased lock, so try to use CAS to try to change the thread Id in the lock record to T2, and if the change is successful, T2 holds the biased lock. Failure means that there is competition and upgrade to lightweight locks.

   you may have questions, why did you fail? We'll start with the CAS operation, which is short for Compare-and-swap (compare and replace), a well-known lock-free algorithm. CAS needs to have three operands, the memory address V, the old expected value A, and the target value B to be updated. In other words, the memory address 0x01 stores the number 6 and I want to turn it into 7. At this time, I first get the value of 0x01 is 6, and then get the value of 0x01 again and determine if it is 6, if it is, update it to 7, if not, do it again until the path is successful. This is mainly due to the time slice of CPU, it may be suspended in the middle of execution, and then other threads change the value, at this time the program may set the wrong value, resulting in an exception.

   took a brief look at CAS and now let's go back to the lock upgrade process. T2 tried to use CAS to replace the thread ID in the lock record, and CAS failed, which means that T1 snatched the lock that originally belonged to T2. Obviously, there is competition at this moment, so the lock needs to be upgraded. Before upgrading to a lightweight lock, the thread T1 that holds the bias lock is paused and checks the state of T1, which releases the bias lock and wakes up if it is inactive / has exited the synchronous code block. If the synchronous code block is not exited, the lock is upgraded to a lightweight lock at this time, and the lock is acquired by T1, continues execution from the security point, and releases the lightweight lock after execution.

   biased locks use a mechanism that releases locks only when there is competition, so when other threads try to compete for biased locks, the thread that holds the biased lock releases the lock. And the undo of the bias lock needs to wait for the global security point (there is no bytecode being executed at this point in time).

   T1 because there is no competition after a period of smooth operation, T2 came in at a certain point in time, resulting in the use of CAS to obtain the lock, but found that failed, T2 will wait (spin to acquire the lock), because the competition is not very fierce, so after T1 execution, it can acquire the lock and execute it. If the lock is not acquired for a long time, there may be competition, and a T3 may snatch the lightweight lock that originally belongs to T2, which will be upgraded to a heavyweight lock.

Retreat after eating.

Interviewer: inner OS: unexpectedly did not ask him, it seems that let him train is hopeless, let him go back and wait for notice.

   small house, right? I basically understand your level. I am quite satisfied with you, but there are still a few candidates here who have not yet been interviewed, so I can't give you a direct answer. Please go back and wait for notice.

Otaka: OK, thank you, interviewer. I'll go back first. Thanks to my full preparation, all the answers have come up. I should be able to receive the offer.

Public class Demo {public static void main (String [] args) {String str = null; str = str + "; System.out.println (str);}}

The answer is null. We learned before that using + for stitching is actually converted to StringBuilder for stitching using the append method. So let's take a look at the append method implementation logic.

Public AbstractStringBuilder append (String str) {if (str = = null) return appendNull (); int len = str.length (); ensureCapacityInternal (count + len); str.getChars (0, len, value, count); count + = len; return this;} private AbstractStringBuilder appendNull () {int c = count; ensureCapacityInternal (c + 4); final char [] value = this.value; value [C++] = 'nasty; value [C++] =' upland; value [C++] ='l' Value [C++] = 'lumped; count = c; return this;}

You can see from the code that if the string passed in is null, the appendNull method is called and appendNull returns null.

At this point, I believe you have a deeper understanding of "what is the difference between String, String Builder and String Buffer". You might as well do it in practice. Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

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.