Concurenncy - synchronization problems

Question

Hello,
I have read about synchronization in about 5 sources so far and I still don't understand it and mostly because of codes that sources show do not work as they are intended to work.
For example I will show the code from this webpage: http://www.roseindia.net/java/thread/SynchronizedThreads.shtml
I tried this code:
class Share extends Thread{
  static String msg[]={"This", "is", "a", "synchronized", "variable"};
  Share(String threadname){
    super(threadname);
  public void run(){
    display(getName());
  public synchronized void display(String threadN){
    for(int i=0;i<=4;i++)
      System.out.println(threadN+msg);
try{
this.sleep(1000);
}catch(Exception e){}
public class SynThread1 {
public static void main(String[] args) {
Share t1=new Share("Thread One: ");
t1.start();
Share t2=new Share("Thread Two: ");
t2.start();
}And my output the most time is the same like they showed so it's like:Thread One: This
Thread One: is
Thread One: a
Thread One: synchronized
Thread One: variable
Thread Two: This
Thread Two: is
Thread two: a
Thread Two: synchronized
Thread Two: variableHowever, sometimes when i run this program it's like:Thread Two: This
Thread One: This
Thread One: is
Thread One: a
Thread One: synchronized
Thread One: variable
Thread Two: is
Thread Two: a
Thread Two: synchronized
Thread Two: variable
Okay I decided to make my own program the counter, who will start two threads at the same time which will use the same variable from the same object.
Here it is:public class Main
public static void main(String[] args) throws InterruptedException
Counter counter = new Counter();
Thread t = null;
t = new Thread(new CounterRunnable(counter, true), "theOneWhoIsIncreased");
t.start();
t = new Thread(new CounterRunnable(counter, false), "theOneWhoIsDecreased");
t.start();
class Counter
public synchronized void increaseCounter()
counter++;
System.out.println("I'm being increased");
public synchronized void decreaseCounter()
counter--;
System.out.println("I'm being decreased");
public synchronized int getCounter()
System.out.println("Here "+Thread.currentThread()+" The result is: "+ counter);
return counter;
private int counter = 500;
class CounterRunnable implements Runnable
public CounterRunnable(Counter counter, boolean increase)
this.increase = increase;
this.counter = counter;
public void run()
for (int i = 0; i < 10; i++)
if(increase)
counter.increaseCounter();
else
counter.decreaseCounter();
counter.getCounter();
boolean increase;
Counter counter;
But unluckly results are like that, even though methods are synchronized, why?? run:
I'm being increased
I'm being decreased
Here Thread[theOneWhoIsDecreased,5,main] The result is: 500
I'm being decreased
Here Thread[theOneWhoIsDecreased,5,main] The result is: 499
I'm being decreased
Here Thread[theOneWhoIsDecreased,5,main] The result is: 498
I'm being decreased
Here Thread[theOneWhoIsDecreased,5,main] The result is: 497
I'm being decreased
Here Thread[theOneWhoIsDecreased,5,main] The result is: 496
I'm being decreased
Here Thread[theOneWhoIsDecreased,5,main] The result is: 495
I'm being decreased
Here Thread[theOneWhoIsDecreased,5,main] The result is: 494
I'm being decreased
Here Thread[theOneWhoIsDecreased,5,main] The result is: 493
Here Thread[theOneWhoIsIncreased,5,main] The result is: 493
I'm being increased
Here Thread[theOneWhoIsIncreased,5,main] The result is: 494
I'm being increased
Here Thread[theOneWhoIsIncreased,5,main] The result is: 495
I'm being increased
Here Thread[theOneWhoIsIncreased,5,main] The result is: 496
I'm being increased
Here Thread[theOneWhoIsIncreased,5,main] The result is: 497
I'm being increased
Here Thread[theOneWhoIsIncreased,5,main] The result is: 498
I'm being increased
Here Thread[theOneWhoIsIncreased,5,main] The result is: 499
I'm being increased
Here Thread[theOneWhoIsIncreased,5,main] The result is: 500
I'm being increased
Here Thread[theOneWhoIsIncreased,5,main] The result is: 501
I'm being increased
Here Thread[theOneWhoIsIncreased,5,main] The result is: 502
I'm being decreased
Here Thread[theOneWhoIsDecreased,5,main] The result is: 501
I'm being decreased
Here Thread[theOneWhoIsDecreased,5,main] The result is: 500
I supossed that results would be like first only increasing and then only decreasing output, or first deacreasing and then increasing output. Why is that different?
I know that I can achieve that thing by for example using *join* method but well I want to understand synchronization ;)
So what's the problem, I'm totally confused about that synchronization things. Somehow i still think it doesn't work at all. I learnt about the object which is called Lock also, about the ReentrantLock... and well it still doesn't work good with that...
Please explain me what is the problem, i'm really confused...
Best regards,
Armon                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           

Answer 1

The first example doesn't work because the display method synchronizes on different objects (their own instance). A quick fix could be to synchronized on the Share.class, but since anyone could lock on that (if it was public), better make a local lock object.
// quick fix
public void display(String threadN){
  synchronized(Share.class) {
    for(int i=0;i<=4;i++)
      System.out.println(threadN+msg);
try{ this.sleep(1000); } catch(Exception e) {}
// better, though should really extend Thread
class Share extends Thread {
private final Object lock;
Share(String threadname, Object lock){
super(threadname);
this.lock = lock;
public void display(String threadN){
synchronized(lock) {
public class SynThread1 {
public static void main(String[] args) {
Object lock = new Object();
Share t1=new Share("Thread One: ", lock);
t1.start();
Share t2=new Share("Thread Two: ", lock);
t2.start();
You own example has the same problem: synchronizing on different objects.