Gagan Sabharwal

Thanks people.

Hi,

I am going through the following url
Java theory and practice - IBM

Under the section, What do you mean by "publish"? , the following code is written

public class Safe { private Object me; private Set set = new HashSet(); private Thread thread; public Safe() { // Safe because "me" is not visible from any other thread me = this; // Safe because "set" is not visible from any other thread set.add(this); // Safe because MyThread won't start until construction is complete // and the constructor doesn't publish the reference thread = new MyThread(this); } public void start() { thread.start(); } private class MyThread(Object o) { private Object theObject; public MyThread(Object o) { this.theObject = o; } ... } }

1) The respected author says that it is a safe publication. I fail to understand why ? The contention in my mind is that what if the compiler or processor or cache reorders
thread = new MyThread(this);
statement in the constructor and puts it as the first statement in the constructor. Won't the inner class MyThread be able to see a partially constructed object ?

Hi Chris,

As per my nderstanding,

1) I think in context of thread safety final is used to make an object immutable.Also since final in new JMM has a changed meaning which says that if the variables of a class are final, then during the instantiation, all those varibles will get properly initialized value before the reference of that instance is made visible to other threads.

2) The internal Data Structure(which contains the constant pool) in the runtime area is thread safe, which is used by the classloader to load the class and create a .class instance. Now since Static initialization happens just after the class is loaded by the class loader and its .class instance is created in the heap, it remains questionable whether the assignment of appropriate values to static variables is thread safe or not.

Could someone throw some light on the same ?

Hi Paul,

Thanks for the reply. Here is the code.

package com.DS; import java.util.ArrayList; import java.util.HashMap; import java.util.Hashtable; import java.util.Set; import java.util.TreeSet; public class TreeSetMain { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub HashMap m = new HashMap<String, Integer>(); m.put("x", 1); Set x = new TreeSet(m.values()); m.put("x", 2); TreeSetMain objTreeSetMain = new TreeSetMain(); objTreeSetMain.initAnotherDataStructure(); } private void initAnotherDataStructure(){ ArrayList<Integer> objInteger = new ArrayList<Integer>(); objInteger.add(1); } }


Questions
1) When we say java TreeSetMain.class and the class is loaded by a system classloader, what will be the content of
a)Method Area...namely constant pool, field information,method information,information of the classloader.
b)Heap

2)Since there is only one main thread, how does stack frame for main method and initAnotherDataStructure interact with the method area and heap?

3) Those jvms which have method tables, how is the information stored?

Hi,

Can somebody guide me through a simple java program which reads a class file and prints an output which shows what parts of a program goes into which section of a runtime data areas?

Thanks Fred for the answer. Quick sort as per my knowledge solely depends on what your bound/pivot is, so that when you sort the members of your array you get balanced right and left arrays. Merge sort on the other hand makes this comparison after dividing a large array into single elements and then compares them.

I am looking for an example (may be a real world ex) where computational times of quick sort is better than merge sort. Let's say merge sort has its worst case and quick sort its best. Will quick sort be able to beat merge sort in computational times when both have an upper bound of O(n log n)?

Hi,

I have just started learning algorithms and went through merge sort and quick sort.Run time analysis states that both have an O(n log n) time for best cases. Where does the difference lie? I wonder if it could be in the number of comparisons. Considering a real world application where an array has a considerable length and some part of it is in order, when would I want to choose a quick sort over a merge sort(keeping aside the fact that merge sort needs additional storage in terms of auxillary array).

Thanks much

Thanks much Peter. I will try it out.

Hi,

I am entering into the world of Unix OS. I intend to write a simple shell script which runs a java program. My java program takes three VM arguments and classpath of various directories.Let the root directory be ab_root.
Can some one please guide me to a sample script for such tasks ?

Also I am having a hard time mugging up basic unix commands. Not too sure if its the lack of interest or what.

Thanks Jelly for summing it up!

I actually read someone's blog just a few days back, lost that net link.

You have mentioned about storing an object's reference in a static field, if we have say a public static field, will it be thread safe if the object to which this public static field references has even one instance field as non final ?

public final static List car = new ArrayList();

Will the above line of code be thread safe?I feel it is not, even if its the first thing to happen in class during the time of class loading.

Could some one please guide me through the various ways of publishing an object where its thread safety could be compromised. I went through an article, but still have not found a grip on the same. Could some one please direct me to an article where there are a good number of examples on the same!!

Hi Wouter,

Thanks for your reply. But that's precisely my question. I am expecting that when say Thread 2 reaches that sysout line, the resource should have an address reference of a partially constructed object by Thread 1. I am trying just to reecreate it. It may happen one in 10000 times but so far I am unlucky to see that.

Do you have any other code snippet where the probability of seeing a partially constructed object is more ?

Hi,

I am trying to create and see a race condition by running a very common double checked locking code. Instead I am seeing a NullPointerException at the bold line underneath, which I don't want to.

package com.rbs.threads; //Double Checked Locking public class SomeClass { //One way to resolve the problem is to make resource field static, that will be like //eager initialisation. private Resource resource = null; public Resource getResource() { //Thread B is here. //Now suppose that Thread B comes along after the memory is allocated for resource and the resource //field is set and before the constructor of new Resource() is called or in other words before the //values x,y are initialised to 4 and 5 respectively and have default values of 0 and 0, it sees that // the resource is not null and skips the synchronised block and returns a reference to a partially //constructed object. System.out.println("Current Thread before synchronized :"+Thread.currentThread().getName()); [b][i]System.out.println("Current Thread before synchronized :"+Thread.currentThread().getName()+" sees as " + resource.hashCode());[/i][/b] if (resource == null) { synchronized(this) { if (resource == null) System.out.println("Current Thread in synchronized :"+Thread.currentThread().getName()); System.out.println("Current Thread before synchronized :"+Thread.currentThread().getName()+" sees as " + resource.hashCode()); //Thread A is here //Instructions can be reordered by the compiler or the processor in the following manner: //Allocate memory, Assign reference to the resource and Call Constructor. resource = new Resource(); } } return resource; } }

I am running the above code say some 2000 times from a for loop, but have been unfortunate so far to see a hashcode value of a partially constructed object. I am running it on java 6. If I can predict that what is going to happen, the whole importance of threading is lost. But just for the heck of it, I want to see a race condition as I mentioned above. Need help!!!

Thank you gentlemen!!!