doubt in threads

[akaash singh]

Synchronization problems occur when two threads have a access to the same object . In the following code :

public class T1{
 int x =0;
 public class Run implements Runnable 
 { public void run()
    {
     // code that manipulates and prints value of x 
     }
 }

 public static void main(String args[])
  { new T1.go();
    }

  public void go()
 {Runnable r = new Run();
    Thread t1=new Thread(r);
    Thread t2=new Thread(r);
     t1.start();
     t2.start();
  }
}

In this we have two threads t1 and t2 . The common object they share is "r" . " r" has access to x ; thereby granting t1 and t2 access to x , leading to synchronization problems in the output .

i have the following doubts :
- is the above reasoning correct ?
- the objetc on which run() is executed is "r" and not t1 and t2?

And when we extend the Thread class the run() is executed on the object of the subclass of Thread ? as in :

class T2 extends Thread
{public void run()
  {//
   }
  public static void main(String[] s)
  { T2 ob = new T2();
      ob.start()
  }
}

So here the run() is executed on ob?

[Nitish Bangera]

Runnable interface is implemented by the thread class also. Well now if you class is implementing a runnable interface and then providing a run method means you are providing a job that has to be performed by the thread. So we pass the job(runnable reference) to the thread. Extending thread class is not appropriate because extending classes should always be done when you have a special purpose. That's why its also called specialization. Also thread class has a start method which internally makes a new stack for the thread and calls the run method.

Well when you pass a runnable object, you are telling that instead of using the thread's default run, the thread should use your run method i.e the job.

 public class T1{
 int x =0;
 public class Run implements Runnable 
 { public void run()
    {
     // code that manipulates and prints value of x 
     }
 }

 public static void main(String args[])
  { new T1.go();
    }

  public void go()
 {Runnable r = new Run();
    Thread t1=new Thread(r);
    Thread t2=new Thread(r);
     t1.start();
     t2.start();
  }
}
    

In this you can solve the synchronization problem by using the synchronized block on this. Why this because you only creating one object of class T1 which creates 2 threads. Also you have the same job to be performed but the threads will run their own runs. Means the same job is to be performed by 2 threads i.e 2 times simultaneously in different stack modifying the x. So stop that synchronize on the T1 class object which is only 1. So before entering the synchronized block the thread will acquire the lock and thus only 1 thread can manipulate the x variable.


I hope i answered what you asked for. If not please correct me ok

Cheers.

[akaash singh]

i understand that we can synchronize by making the following change :

public synchronized void run() {//}

but what does "this" refer to : is it the object "r" of class Run ?
or is it the object of class T1.
The 2 threads must have access to the same object in order to cause synchronization problems. What is that same object here: "r" or the "anonymous object of class T1"

[Adeel Ansari]

akaash singh wrote:What is that same object here: "r" or the "anonymous object of class T1"

"r" of T1's anonymous object.

[Adeel Ansari]

akaash singh wrote:What is that same object here: "r" or the "anonymous object of class T1"

"r" of T1's anonymous object.

[Nitish Bangera]

but what does "this" refer to : is it the object "r" of class Run ?
or is it the object of class T1.

this is put in which class?

Well don't confuse yourself by this. Runnable gives the contract that the particular class can have its own methods to run that's all. Runnable interface only has 1 method so its reference can always run that method only. Also within the class implementing the Runnable it will always be its object(this) because the JVM looks at the object that is new Run();