Strange output

[Anudeep Duvvuri]

package may25th;

public class Lockjava extends Thread {

	static synchronized void method() throws InterruptedException {
		{
			for (int i = 0; i < 5; i++) {
				System.out.println("  " + Thread.currentThread().getName());
				System.out.println(" static method syncronized  " + i);
				Thread.sleep(1000);
			}
		}
	}

	static synchronized void method2() throws InterruptedException {
		for (int i = 0; i < 5; i++) {
			System.out.println(" " + Thread.currentThread().getName());
			System.out.println(" static method 2 synchronized " + i);
			Thread.sleep(1000);
		}
	}

	public void run() {
		try {
			method();
			System.out.println();
			method2();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

	}

	public static void main(String[] args) {
		Lockjava l = new Lockjava();
		Thread t = new Thread(l);
		t.start();
		Thread t1 = new Thread(l);
		t1.start();

	}
}

The output of the above program is
Thread-1
static method syncronized 0
Thread-1
static method syncronized 1
Thread-1
static method syncronized 2
Thread-1
static method syncronized 3
Thread-1
static method syncronized 4

Thread-2
static method syncronized 0
Thread-2
static method syncronized 1
Thread-2
static method syncronized 2
Thread-2
static method syncronized 3
Thread-2
static method syncronized 4

Thread-1
static method 2 synchronized 0
Thread-1
static method 2 synchronized 1
Thread-1
static method 2 synchronized 2
Thread-1
static method 2 synchronized 3
Thread-1
static method 2 synchronized 4
Thread-2
static method 2 synchronized 0
Thread-2
static method 2 synchronized 1
Thread-2
static method 2 synchronized 2
Thread-2
static method 2 synchronized 3
Thread-2
static method 2 synchronized 4

[Anudeep Duvvuri]

This is another program which is almost similar to the above one.
But the output is not as the above one.

package may25th;

class Synchr1 extends Thread {

	synchronized void method1() throws InterruptedException {
		System.out.println("Hai starts : " + Thread.currentThread().getName());
		for (int i = 0; i < 5; i++) {
			System.out.println("method1***************" + i);
			Thread.sleep(1000);
		}

		System.out.println("Hai Ends : " + Thread.currentThread().getName());
	}

	synchronized void method2() throws InterruptedException {
		System.out.println("Other1 starts : "
				+ Thread.currentThread().getName());
		for (int i = 0; i < 5; i++) {
			System.out.println("method2-------" + i);
			Thread.sleep(1000);
		}
		System.out.println("Other1 Ends : " + Thread.currentThread().getName());
	}

	public void run() {

		try {
			method1();
			method2();
		} catch (InterruptedException e) {

			e.printStackTrace();
		}
	}

}

public class ThreadSynch22 {

	public static void main(String[] args) {
		Synchr1 s = new Synchr1();
		Thread t2 = new Thread(s);
		t2.start();
		Thread tt = new Thread(s);
		tt.start();

	}

}

output:
Hai starts : Thread-1
method1***************0
method1***************1
method1***************2
method1***************3
method1***************4
Hai Ends : Thread-1
Other1 starts : Thread-1
method2-------0
method2-------1
method2-------2
method2-------3
method2-------4
Other1 Ends : Thread-1
Hai starts : Thread-2
method1***************0
method1***************1
method1***************2
method1***************3
method1***************4
Hai Ends : Thread-2
Other1 starts : Thread-2
method2-------0
method2-------1
method2-------2
method2-------3
method2-------4
Other1 Ends : Thread-2


Please explain me why both the outputs are different even we use synchronization
Sorry for consuming so much space

[Jelle Klap]

What do you think is "strange" about the output you provided?

[Anudeep Duvvuri]

In the 1st program thread 2 is starting to print method 1 without the thread 1 printing method 2
But in the 2nd Program Thread2 waits until the 1st Thread prints both the methods 1 and 2

[Jelle Klap]

In both example programs that is purely coincidental; the order is not predictable.
It's also possible for thread 2 to complete invocations of method 1 and 2 before thread 1 gets its turn.
Adding the keyword synchronized to a method only ensures that no two threads can execute that method (or any other body of code that synchonizes on the same lock) concurrently.