Using separate locks has no effect

[gunitinug]

public class SCounter {
    private int c = 0;
  	Object lock1=new Object();
  	Object lock2=new Object();

    public void increment() {
      synchronized(lock1) {
        c++;
      }
    }

    public synchronized void decrement() {
      synchronized(lock2) {
        c--;
      }
    }

    public synchronized int value() {
        return c;
    }
}

public class Run1 implements Runnable {
  SCounter sc;
  
  public Run1(SCounter sc) {
    this.sc=sc;
  }
  
  public void run() {
    sc.increment();
    sc.increment();
    sc.increment();
    System.out.println(sc.value());
  }
}

public class Run2 implements Runnable {
  SCounter sc;
  
  public Run2(SCounter sc) {
    this.sc=sc;
  }
  
  public void run() {
    sc.decrement();
    sc.decrement();
    sc.decrement();
    System.out.println(sc.value());
  }
}

public class SCMain {
  public static void main(String[] args) {
    SCounter sc = new SCounter();
    new Thread(new Run1(sc)).start();
    new Thread(new Run2(sc)).start();
  }
}

synchronized(lock1) and synchronized(lock2)
has the same effect as
synchronized(lock1) and synchronized(lock1)

what's the point?

[SurfMan]

In the end you're just doing +3 and -3. Whatever execution order there is, locks or no locks, 0+3-3 wil always be 0.

[SurfMan]

Your test case is not elaborate enough to ever generate an error. I modified your example to show when it goes wrong. Consider the Thread.sleep() as a "latency generator". Switch the lock on one thread to see when it goes out of sync.

After incrementing/decrementing, there is a little pause. As soon as both threads use lock1, there is no problem, but using lock1 and lock2, the counter goes out of sync.

import java.util.Random;

public class Locks {
    public static void main(String[] args) {
        SCounter sc = new SCounter();
        new Thread(new Run1(sc), "Increment").start();
        new Thread(new Run2(sc), "Decrement").start();
    }
}

class SCounter {
    private int c = 0;
    Object lock1 = new Object();
    Object lock2 = new Object();

    public void increment() {
        c++;
    }

    public void decrement() {
        c--;
    }

    public int value() {
        return c;
    }

}

class Run1 implements Runnable {
    Random random = new Random();
    SCounter sc;

    public Run1(SCounter sc) {
        this.sc = sc;
    }

    public void run() {
        for (int i = 1; i <= 100; i++) {
            try {
                Thread.sleep(random.nextInt(100) + 200);
            }
            catch (InterruptedException e) {
            }

            synchronized (sc.lock1) {
                int oldValue = sc.value();
                sc.increment();
                try {
                    Thread.sleep(random.nextInt(100) + 200);
                }
                catch (InterruptedException e) {
                }
                int newValue = sc.value();
                if (newValue != oldValue + 1) {
                    System.out.println(Thread.currentThread().getName() + " " + i + ": expected " + (oldValue + 1) + ", got " + newValue);
                }
                else {
                    System.out.println(Thread.currentThread().getName() + " " + i + ": " + newValue);
                }
            }
        }

    }
}

class Run2 implements Runnable {
    Random random = new Random();
    SCounter sc;

    public Run2(SCounter sc) {
        this.sc = sc;
    }

    public void run() {
        for (int i = 1; i <= 100; i++) {
            try {
                Thread.sleep(random.nextInt(100) + 200);
            }
            catch (InterruptedException e) {
            }


            synchronized (sc.lock2) {
                int oldValue = sc.value();
                sc.decrement();
                try {
                    Thread.sleep(random.nextInt(100) + 200);
                }
                catch (InterruptedException e) {
                }
                int newValue = sc.value();
                if (newValue != oldValue - 1) {
                    System.out.println(Thread.currentThread().getName() + " " + i + ": expected " + (oldValue - 1) + ", got " + newValue);
                }
                else {
                    System.out.println(Thread.currentThread().getName() + " " + i + ": " + newValue);
                }
            }
        }

    }
}