如果 Java 线程在这种情况下不应该表现得如此不同，为什么它们的行为如此不同？

我有线程睡眠问题。在线程运行方法内部，我有一个同步块和一个睡眠时间。 每个线程以 5 个单位递增或递减共享类“值”，然后休眠。

public class borr {

    public static void main(String[] args) {

        int times=5;
        int sleeptime=1000;
        int initial=50;
        Shared shared = new Shared(initial);

        ThreadClass tIncrement = new ThreadClass(shared,times,sleeptime,true);
        ThreadClass tDecrement = new ThreadClass(shared,times,sleeptime,false);
        tIncrement.start();
        tDecrement.start();
    }
}

class Shared{

    int  value=0;

    public Shared(int value) {
        super();
        this.value = value;
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }
}

class ThreadClass extends Thread{

    Shared shared;
    int times=0;
    int sleeptime=0;
    boolean inc;

    public ThreadClass(Shared shared, int times, int sleeptime, boolean inc) {
        super();
        this.shared = shared;
        this.times = times;
        this.sleeptime = sleeptime;
        this.inc = inc;
    }

    public void run() {

        int aux;

        if(inc) {
            for(int i=0;i<times;i++) {
                synchronized(shared) {
                    aux=shared.getValue()+1;
                    shared.setValue(aux);
                    System.out.println("Increment, new value"+shared.getValue());

                    try {
                        Thread.sleep(sleeptime);
                    }catch(Exception e) {
                        e.printStackTrace();
                    }
                }
            }   
        }
        else {
            for(int i=0;i<times;i++) {
                synchronized(shared) {
                    aux=shared.getValue()-1;
                    shared.setValue(aux);
                    System.out.println("Decrement, new value"+shared.getValue());

                    try {
                        Thread.sleep(sleeptime);
                    }catch(Exception e) {
                        e.printStackTrace();
                    }
                }
            }   
        }
    }
}

但如果我移动Thread.sleep出于synchronizedblock，像这样，输出是递增，递减，递增，递减。当它停止休眠并开始新的循环迭代时，其他线程不应该尝试进入吗？相反，它继续循环直到该线程完成：

for(int i=0;i<times;i++) {
    synchronized(shared) {
        aux=shared.getValue()-1;
        shared.setValue(aux);
        System.out.println("Decrement, new value"+shared.getValue());
    }

    try {
        Thread.sleep(sleeptime);
    }catch(Exception e) {
        e.printStackTrace();
    }
}   

这不好：

for(...) {
    synchronized(some_lock_object) {
        ...
    }
}

它不好的原因是，一旦某个线程 A 进入该循环，那么每次它解锁锁时，接下来的事情它所做的就是再次锁定锁。

如果循环体花费大量时间来执行，则等待锁的任何其他线程 B 将被操作系统置于等待状态。每次线程 A 释放锁时，线程 B 都会开始唤醒，但线程 A 将能够在线程 B 有机会之前重新获取锁。

这是一个经典的例子饥饿 https://en.wikipedia.org/wiki/Starvation_(computer_science).

解决该问题的一种方法是使用ReentrantLock https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/locks/ReentrantLock.html with a 公平订购政策 https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/locks/ReentrantLock.html#ReentrantLock-boolean-而不是使用synchronized堵塞。当线程竞争公平锁时，获胜者总是等待时间最长的线程。

但是，公平锁的实施成本很高。更好的解决方案是始终保留任何人的身体synchronized块尽可能短且尽可能甜。通常，线程保持锁锁定的时间不应超过在某个对象中分配少量字段所需的时间。