Atomic execution of multiple methods

Question

Is it a flawed idea to try to execute a sequence of methods atomically in the following way?
synchronized(obj) {
obj.method1();
obj.method2();
Even if the object is thread-safe, it can still have methods that are not declared synchronized (e.g. because they involve a single atomic read/write operation). So these methods are not blocked by the synchronized block.
Is it better to consider the object's lock something internal to the object and should not be manipulated outside the object's implementation? In another word, is it better to rely on an external lock (i.e. an external object created solely for the purpose of locking) to achieve atomicity? Obviously, it's harder to make sure all invocations of method1 and method2 are done while holding this lock.

Answer 1

A thread will not block unless it synchronizes on a
"locked" object. If an object is "locked" and a
different thread enters one of its unsynchronized
methods it will not block.If an object is locked it will not allow another thread to access it's unsynchronized method.
Here is an example of locking an object and trying to access an unsychronized method with another thread which cannot be done until the synch block has finished.
public class Test3 extends Thread
    Test2 t2;
    /** Creates a new instance of Test3 */
    public Test3(Test2 t2Instance)
        t2 = t2Instance;
    public void run()
       // this is my seperate thread which calls a unsynchronized method
       // but it won't call it until after the synch block is through
       t2.unsynchronizedMethod();
       System.out.println("Called the unsych method using another thread.");
public class Test2
    /** Creates a new instance of Test2 */
    public Test2(int maxIndex)
        synchronized( this )
            // loop for 100 times to deminstrate the synch block
            for(int i = 0; i < maxIndex; i++)
                System.out.println("In synch block; count is " + i);               
    public void unsynchronizedMethod()
        System.out.println("Accessed unsynchronized method");
public class Test1
    /** Creates a new instance of Test1 */
    public static void main(String[] args)
        Test2 t2 = new Test2(10000);
        Test3 t3 = new Test3(t2);
        t3.start();
        t2.unsynchronizedMethod();
}The thread has to wait until the synch block is through before it can access the unsynchronized method of the locked object.