understanding nested locks in java

i want to understand this:

String string;
public Test(String string){
     this.string = string;
     .....
}

public void foo(newObjectPerCall o) {
        synchronized (o) {
            //each thread can enter here because the object passed is always different
            ....
            synchronized (string) {
                // acquire this lock if the String is free.
            }
        }
    }

public synchronized void function() {

}

public static void main(){
    Test test = new Test("hello");
    for(int i = 0; i < 10;i++){
         WorkerThread workerThread = new WorkerThread(test);
         workerThread.start(); 
   }
 }

thread class

public class WorkerThread extends Thread {

    private Test test;

    public WorkerThread(Test test) {
        this.test = test;
    }

    @Override
    public void run() {
        while (true) {
            test.foo(new Object());
            try {
                sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            test.function();
        }
    }
}

my doubts are:

• if one thread acquire the inner lock, other threads that acquired the outer lock, will remains inside the foo function?
• When on thread ,for some reasons, remains outside the foo function, can this one acquire the lock of test instance inside function?