两种方法（一种同步另一种不同步）和两种线程

Question

If one method of an object is synchronized and the other isn't, can two different threads run them on the same time? I know that when a method is marked synchronized the intrinsic lock has to be acquired, but the second method isn't synchronized, does it matter? Or maybe if one thread acquired the lock, all of the methods cannot be entered?

Answer 1

Yes. Two threads can execute those two methods simultaneously. Thread can get lock on synchronized method, but lock is not necessary to execute non-synchronized method.

Answer 2

I am sure both methods can run concurrently on the same object, because the one which is synchronized will only make use of intrinsic lock of that object & acquire it but as non-synchronized method won't make use of the lock, they both can run concurrently. I came across the same scenario & found the about statement correct. See the below example for more clarity:

class LockTest {

    // Sync Method. Will acquire the lock
    public synchronized void meth1() {
        System.out.println(Thread.currentThread().getName()
                + " is executing method1.");
        try {
            Thread.sleep(1000); // to show some processing, Won't release the
                                // lock
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out
                .println(Thread.currentThread().getName() + " ended method1.");
    }

    // No lock is required in this method
    public void meth2() {
        try {
            Thread.sleep(1);// to let meth1 execute first & acquire the lock
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()
                + " is executing method2.");
        System.out
                .println(Thread.currentThread().getName() + " ended method2.");
    }

    public static void main(String[] args) throws Exception {
        final LockTest oracle = new LockTest();
        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                oracle.meth1();

            }
        }, "BigThread");

        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                oracle.meth2();

            }
        }, "SmallThread");

        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }
}

The above code produces output as:

BigThread is executing method1.
SmallThread is executing method2.
SmallThread ended method2.
BigThread ended method1.

The output shows that method2 executed while method1 was also executing concurrently on same object oracle .