Thread 1 sleep的时候根本就没有占据锁。因为sleep的方法在同步关键字外面执行的。

将sleep放到同步关键字中

    public void f(int flag) {

        synchronized (this) {

            System.out.println("f()" + flag);

            try {

                Thread.sleep(10000);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }

class DualSynch{
public void f(int flag) {
synchronized (this) {
System.out.println("f()" + flag);
}
}
}
public class Test {
public static void main(String[] args) {
final DualSynch ds = new DualSynch();
new Thread() {
public void run() {
int i = 0;
while(i ++ <2){
ds.f(1);
try {
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
new Thread(){
public void run() {
ds.f(2);
}
}.start();
}
}
既然sleep（）不释放锁，为什么这个程序运行结果会出现f(1) f(2) f(1)呢？在线程一sleep时，线程二得到了锁并且调用了f（）方法

Quote: 引用 楼主 learsea 的回复:

class DualSynch{
public void f(int flag) {
synchronized (this) {
System.out.println("f()" + flag);
}
}
}
public class Test {
public static void main(String[] args) {
final DualSynch ds = new DualSynch();
new Thread() {
public void run() {
int i = 0;
while(i ++ <2){
ds.f(1);
try {
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
new Thread(){
public void run() {
ds.f(2);
}
}.start();
}
}
既然sleep（）不释放锁，为什么这个程序运行结果会出现f(1) f(2) f(1)呢？在线程一sleep时，线程二得到了锁并且调用了f（）方法

sleep方法只是让线程睡眠一段时间，单纯的让线程休息会儿。
跟“锁”没有直接没有关系。

2楼正确的。 sleep(10000) ，我改了一下，sleep (1000), 会出现下面的结果：
f()1
f()1
f()2