Threads: join() and volatile instance variables

[Saumya Srivastava]

Hi,

Can anyone please tell me that what is difference when we use volatile instance variables in threads and without voitaile keyword in instance variables in thread. Also how is it possible to call join() function directly without using thread object i.e when Thread t=new Thread(); we should call like this: t.join(). But in the code we can directly call join(). How will I identify that which thread will join to which if I simply call join() function.

Thanks,
Saumya

[Deepak Bala]

Volatile variables are fetched from main memory and are not cached anywhere within the thread. Trips to main memory are expensive

But in the code we can directly call join()

t.join() tells the JVM, 'Please wait for thread t to die and then continue execution'. The aim being that one thread should wait for another to complete before proceeding. join() calls the method on the current executing instance. I am not sure what that would accomplish

[Saumya Srivastava]

In the below code which is from examlab. How am I getting output: 000000 ? I didn't get

public class ThrdVolatile extends Thread{
//	public class ThreadClass extends Thread{
	
	     public ThrdVolatile(int x){
	          this.x=x;
	     }

	     static String s="";
	     static volatile int x=0;

	     public static void doVIP(){
	          s=s+x;
	         try{
	               Thread.sleep(10);
	          }catch(Exception e){
	               s=s+x;
	          }
	     }

	     public void run(){
	          synchronized(s){
	               doVIP();
	          }
	     }

	     public static void doDelay(long g){
	          try{Thread.sleep(g);}catch(Exception e){}
	     }

	     public static void main(String args[]){

	    	 ThrdVolatile tc1=new ThrdVolatile(2);
	    	 ThrdVolatile tc2=new ThrdVolatile(1);
	    	 ThrdVolatile tc3=new ThrdVolatile(0);

	          tc1.start(); doDelay(100); System.out.print(s);
	          tc2.start(); doDelay(100); System.out.print(s);
	          tc3.start(); doDelay(100); System.out.print(s);

	     }
}

[Deepak Bala]

The last instance initializes the static variable to 0. Thus you get 0 all the time

  ThrdVolatile tc3=new ThrdVolatile(0);  

Try doing this instead

  
ThrdVolatile tc3=new ThrdVolatile(0);
ThrdVolatile tc1=new ThrdVolatile(2);
ThrdVolatile tc2=new ThrdVolatile(1);
  

the result will be different

[Stephan van Hulst]

The problem is that x is declared static.

Also regarding your question on volatile. If a variable is volatile, it simply means that threads shouldn't cache intermediary results from operations on that variable. Caching makes these operations a lot faster, but when you're working with multiple threads, this means that different threads won't see the effects of an operation by another thread on a variable. To counteract this, you declare the variable volatile, so all threads can see operations on that variable by other threads.