Thread: Object o = new Object(); need help

There is a server class in which we are using this code. I just want to ask, what this code do in general??

Object o = new Object();
synchronized (o) {
try {
o.wait();
} catch (InterruptedException ex) {}

Do be able to have a synchronized block without synchronizing the whole method you have to sync on a certain object. When you do that you create a lock and the next thread which calls that method and reaches that sync block will have to wait until the lock on the object has been released.

So to create a shortcut for object locking you can just create an object like in the code and sync on that object.

However if that object it created inside the actual method that has the sync block it will effectively be useless because every time the method is called there will be a new object used as a lock so no matter what thread calls this method you wont be seeing a synchronized behaviour.

If the object is declared as a static it would make more sense or if its an object passed into the thread at creation, as long as all threads share the same object they lock on it should work.

Here is a simple test for you. Play around with this code and you will understand how the locks work.

public class ThreadTest1 extends Thread {
 
    private static Object object = new Object();
 
    private static int value = 0;
 
    public ThreadTest1(final String name) {
        super(name);
    }
 
    public static void main(final String... arguments) {
        for (int i = 1; i <= 15; ++i) {
            new ThreadTest1("ThreadTest_" + i).start();
        }
    }
 
    @Override
    public void run() {
        myFirstMethod();
 
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
 
        mySecondMethod();
    }
 
    private void myFirstMethod() {
        final Object object = new Object();
 
        synchronized (object) {
            value = value + 1;
 
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
 
            System.out.println("This is myFirstMethod called from thread [" + Thread.currentThread().getName() + "] with value [" + value + "]");
        }
    }
 
    private void mySecondMethod() {
        synchronized (object) {
            value = value + 1;
 
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
 
            System.out.println("This is mySecondMethod called from thread [" + Thread.currentThread().getName() + "] with value [" + value + "]");
        }
 
    }
}

When it comes to waiting on the object, this is also rather pointless if the object is only on the stack (in a method). That would put the thread in a permanent RUNNABLE state waiting for someone to notify on the object which can never happen.

// Json

In a stupid way its like doing this.

while(true){}

Or.

for(;;) {}

Or any other infinite loops just to keep the thread alive.

// Json

you mean in my code example o.wait( ) is just for keeping the thread alive ??

//zeeshan

Look for the book Java Concurrency in Practice by Brian Goetz.

bibcloax, what exactly more would you like help on, threads or stupid while loops to keep threads alive?

// Json