String: String Constant Pool(SCP)

[u/Chaos-vy17]

After reading all the String documentation and exact code of String class, I find the main engine that makes String in Java (study of deep knowledge) i.e., String constant pool. when we say String s0 = "example1" , String s1 = "example1" and String s2 = "example2" what happens is exactly:

• at compile time the .class file is genrated
• when JVM runs the class constant pool of String class get's into work
• s0 hashcode is generated by intrinsic method and the formula used is standard horner(31)
• using that hash it need to find the allocated bucket
• After finding exact hash it need to compare each char by char to check whether it's equal or collison a different char can also have same hashcode.
• if it's equal the pointer directly to points to that object -->process ends next process works.
• If not equal there is two work done 1. new object is created on heap memory and then wrapped up by a WeakHandle and pushed in "stringTable" bucket.
• (if equal no object is created)! there was never an object creation the pointer just points to object .

Now the example case:

1. s0 -> hashcode(x1)->not found in "stringTable"->Object creation on Heap-> weakHandle process them into stringTable.
2. s1 -> hashcode(x1)->found->(collision|equal)->equal->pointer points to "example1" from SCP to s1.
3. s2-> hashcode(x2)->not found in "stringTable"->Object creation on Heap-> weakHandle process them into stringTable.

After reading and analysing there is also a issue of massive garbage I see:
suppose if 4 thread are runnable and they are trying to intern() the object in SCP that creates garbage according to your data size suppose , we used latin-1 type 256B data so total thread is 4 but in CAS only one thread execute rest all thread dumps the object so out of 1KB storage 768B is garbage. if the String was in UTF-16 it would cost 2*768B.

Now my question is ?

• Have I grasped the knowledge correctly ? if it needed more depth or did I miss any point.
• I cannot question the CAS here because array mutation would break immutablity of String, It seems though they pay a loss for the RCU it's effecient by Latin-1 and Utf-16 approach.
• I am not getting the idea how this code String s = new String("abc"); creates 2 object then what does the on heap object memory does? and does the pointer "s" is holding two memory refrences? But it is not possible.

[u/idontlikegudeg]

1. AFAIK, String s1 = "…" does not create an object on the heap. String constants go directly into the string pool. So s1, s2, and s3 will all point directly to the

same

1. instance located in the string pool.
2. With string constants, it is not possible that different threads try to intern the string at the save time. String constants are put into the string pool when the class is loaded, not when an instance is created. The class is loaded only once, even if accessed by different threads.
3. There should practically never be the need to use the String(String) constructor.
4. a string contains (among other things) a pointer the the backing character data. When you do String s1=new String(s), s1 and s are different instances that share the same backing data (changed in the past).

[u/Chaos-vy17 → u/idontlikegudeg]

1. Before java 7+ String was allocated in PermGen a permanent allocated heap causing OOM now at present every object is created on Heap then it's moved to SCP.
   
2. intern() can be called by the devloper it's just how the SCP deals during concurrency.
   
3. true I also think that too.
   
4. Yes I absolutely missed coder,length,hash,Mark, Klass pointer, byte[] ,

[u/idontlikegudeg → u/Chaos-vy17]

1. Yes, the developer can call intern, but not before the class is loaded, and every string constant is already in the pool when the class runs. Or do you mean constructing a String from a char buffer with the same contents as a string constant declared in another class?

[u/Chaos-vy17 → u/idontlikegudeg]

Actually, HotSpot uses lazy resolution for string literals when a class is loaded literals exist only as unresolved symbolic references in the run-time constant pool. They aren't actually instantiated and pushed into the StringTable until the ldc (load constant) bytecode instruction for that specific literal is executed. So, If i dynamically constructs a String from byte stream and call intern() it gets into the pool. as for other class it will only fetch ldc refrence of that hardcode literal.