Can You Make an Array or ArrayList Unstable in Java?

This is likely one of the many attention-grabbing multi-threading questions I’ve shared in my publish 50 multi-threading interview questions. Sure, you can also make an array unstable in Java, there is no such thing as a downside with that, neither compiler will flag any error not JVM will throw any exception however the difficult half is why you wish to make an array unstable and what’s the impact of creating an array unstable in Java? So as to reply this query, you have to be accustomed to each unstable modifier and Java reminiscence mannequin, in any other case, it will be tough to reply, and that is why it is also one of many trick questions from Java interviews. Earlier than answering this query intimately, let’s first revise what’s a unstable key phrase in Java and what sort of assure it offers within the context of multithreading and concurrency.

What’s a unstable modifier in Java?

The unstable is a modifier in Java which solely applies to member variables, each occasion and sophistication variables, and each primitive and reference sorts. It offers the happens-before assure which ensures {that a} write to a unstable variable will occur earlier than any studying. This ensures that any modification to a unstable object or primitive kind shall be seen to all threads i.e. it offers the visibility assure.

The unstable modifier additionally offers an ordering assure as a result of the compiler can not re-order any code or operation which entails unstable variables (primitive and objects), however what is probably extra essential to know and keep in mind is that unstable variable does not present atomicity (aside from write to the unstable double variable) and mutual exclusion, which can be the principle distinction between unstable and synchronized key phrase.

There are particular restrictions with unstable key phrases such as you can not make a member variable each remaining and unstable on the identical time, however you can also make a static variable unstable in Java.

If you wish to be taught extra concerning the unstable variable in Java, I recommend studying Java Concurrency in Apply, which offers a extra thorough and full introduction and utility of unstable modifiers in Java.

Can we make an array unstable in Java?

Now, coming again to the unique query, can we make an array unstable in Java? The reply is, Sure, you can also make an array (each primitive and reference kind array e.g. an int array and String array) unstable in Java however solely modifications to reference pointing to an array shall be seen to all threads, not the entire array. What this implies is that suppose you’ve a reference variable known as primes as proven beneath:

protected unstable int[] primes = new int[10];

then when you assign a brand new array to primes variable, the change shall be seen to all threads, however modifications to particular person indices is not going to be coated below unstable assure i.e.

primes = new int[20];

will observe the “happens-before” rule and trigger reminiscence barrier refresh, however the next code is not going to accomplish that

primes[0] = 10;
primes[1] = 20;
primes[2] = 30;
primes[3] = 40;

This implies, if a number of threads are altering particular person array components e.g. storing updates, there received’t be any happens-before assure supplied by the unstable modifier for such modification. So, in case your use-case is to supply reminiscence visibility assure for particular person array components then unstable is just not the proper alternative. 

On an analogous notice, typically as an alternative of an array, the Interviewer places the gathering i.e. they are going to ask are you able to make a group variable unstable in Java or not e.g. an ArrayList or HashMap. The reply is similar, in fact, you can also make a reference variable pointing to a Assortment unstable in Java, however the happens-before assure will solely be supplied if the worth of that reference variable is modified e.g. you assign a brand new assortment to it.

Any modification is finished on the precise assortment objects. including or eradicating components from ArrayList is not going to invoke happens-before assure or reminiscence barrier refresh. 

If you’re curious to be taught extra about unstable variables and the way they work in Java, and different key multithreading and parallel programming ideas then I strongly recommend you Java specification which has in-depth info on that. 

That is all about whether or not we will make an array unstable in Java or not. Sure, you can also make the array unstable however that may solely cowl change to the reference variable pointing to an array, it is not going to cowl modifications in particular person array components.