String immutability and wait method in synchronized block

Question

I am new to Java and while I was reading through Java language I got into two doubts. Though I referred many websites and but still I am not very clear.

Why string class is immutable ? I saw some examples with new File(str) which leads to security threat, but I don't understand how if string is immutable, it will help this scenario.
Another doubt is why wait, notify and notifyall should be inside synchronized block. I know if not it throws illegalMonitorException. But I want to know the technical background why it should be in synchronized block and why not without in synchronized block wait and notify can have same behavior.

please don't combine multiple unrelated questions in one post. both of these have been dealt with already in separate questions. — Nathan Hughes, Mar 04 '13 at 20:26
for #1 see http://stackoverflow.com/questions/2068804/why-is-string-final-in-java — Nathan Hughes, Mar 04 '13 at 20:29
@Nathan I think he is asking about string immutability, not about why String is final. — Mikita Belahlazau, Mar 04 '13 at 20:34
@Nikita: yes but the answers in the linked question address immutability as well. esp: http://stackoverflow.com/a/2068812/217324 — Nathan Hughes, Mar 04 '13 at 20:36

score 1 · Answer 1 · edited May 23 '17 at 10:25

Why string class is immutable?

The question of why strings are immutable in Java is an old one, and it's been much debated. In my book, I'd say they are immutable because they should be immutable ;). That might sound like a cop out, but let me explain.

Most simply, strings are used all over the place, if they were mutable that would require a lot of baggage everywhere for making defensive copies and dealing with synchronization and so on. Making them immutable, and then having helpers for mutating them like StringBuilder/StringBuffer is a much better design choice (and a common choice in several languages, not just Java).

Second, everything should be immutable, unless there is a very good reason to justify mutability. Many many problems disappear with immutable classes (esp. pertaining to concurrency). See Effective Java: "Classes should be immutable unless there's a very good reason to make them mutable. If a class cannot be made immutable, limit its mutability as much as possible."

Third, strings are used in the internals of Java, such as the class loading mechanism. Making them immutable makes internal processes simpler, and prevents some security issues. (Another example, String constants are "interned" in Java for performance reasons: http://en.wikipedia.org/wiki/String_interning, and this is, again, much more sane with an immutable type.)

All in all there were probably several reasons the designers chose to make strings immutable in Java and as a day to day programmer it helps you out (as do the utils around creating new strings, like StringBuilder).

Why wait, notify and notifyall should be inside synchronized block?

Here's some info on that one: wait(), notify() and notifyAll() inside synchronized statement.

Basically it makes no sense for a thread to "notify" or "wait" unless it already owns the object's monitor.

In general though, if you are new to Java, you might want to also look at some of the newer utils relating to concurrency in java.util.concurrent: http://docs.oracle.com/javase/6/docs/api/java/util/concurrent/package-summary.html. Often you can rely on these classes and avoid hand coding synchronization, which is notoriously difficult and error prone.

I didn't see the previous answer noted in earlier comments regarding String immutability, or I would have included a link to that too (and just commented ;)). Still I think my answer adds a little, so I'll leave it. — Charlie Collins, Mar 04 '13 at 20:56

String immutability and wait method in synchronized block

1 Answers1