为什么Synchronized不可中断？

public class Uninterruptible {
    private static final Object o1 = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            System.out.println("t1 enter");
            synchronized (o1) {
                try {
                    System.out.println("start lock t1");
                    Thread.sleep(20000);
                    System.out.println("end lock t1");
                } catch (InterruptedException e) {
                    System.out.println("t1 interruptedException");
                    e.printStackTrace();
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            System.out.println("t2 enter");
            synchronized (o1) {
                try {
                    System.out.println("start lock t2");
                    Thread.sleep(1000);
                    System.out.println("end lock t2");
                } catch (InterruptedException e) {
                    System.out.println("t2 interruptedException");
                    e.printStackTrace();
                }
            }
        });

        thread1.start();
        thread2.start();

        // 主线程休眠一下，让t1,t2线程百分百已经启动，避免线程交替导致测试结果混淆
        Thread.sleep(1000);
        // 中断t2线程的执行
        thread2.interrupt();
        System.out.println("t2 interrupt...");

    }
}
复制代码

t1 enter
start lock t1
t2 enter
t2 interrupt...   // 此处等待了好久好久，一直卡住

end lock t1       
start lock t2     // 直到t1执行完释放锁后，t2拿到锁准备执行时，interruptedException异常抛出
t2 interruptedException
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at concurrent.Uninterruptible.lambda$main$1(Uninterruptible.java:48)
    at concurrent.Uninterruptible$$Lambda$2/1134517053.run(Unknown Source)
    at java.lang.Thread.run(Thread.java:745)

Process finished with exit code 0

/**
 * <p> If this thread is blocked in an invocation of the {@link
 * Object#wait() wait()}, {@link Object#wait(long) wait(long)}, or {@link
 * Object#wait(long, int) wait(long, int)} methods of the {@link Object}
 * class, or of the {@link #join()}, {@link #join(long)}, {@link
 * #join(long, int)}, {@link #sleep(long)}, or {@link #sleep(long, int)},
 * methods of this class, then its interrupt status will be cleared and 
 * it will receive an {@link InterruptedException}.
 * 翻译：如果此线程被以下命令（wait、join、sleep）阻塞，他的中断状态会被
 * 清除并且会抛出InterruptedException异常
 *
 * <p> If none of the previous conditions hold then this thread's 
 * interrupt status will be set. </p>
 * 翻译：如果前面的条件都不满足那么将设置它的中断状态
 */
public void interrupt() {
        if (this != Thread.currentThread())
            checkAccess();   // 检查权限

        synchronized (blockerLock) {
            Interruptible b = blocker;
            if (b != null) {
                interrupt0();           // 它是一个native方法, Just to set the interrupt flag
                b.interrupt(this);
                return;
            }
        }
        interrupt0();
    }
复制代码

 /** @throws  InterruptedException
 *          if any thread has interrupted the current thread. The
 *          <i>interrupted status</i> of the current thread is
 *          cleared when this exception is thrown.
 */
public static native void sleep(long millis) throws InterruptedException;

 /** @throws  InterruptedException if any thread interrupted the
 *             current thread before or while the current thread
 *             was waiting for a notification.  The <i>interrupted
 *             status</i> of the current thread is cleared when
 *             this exception is thrown.
 * @see        java.lang.Object#notify()
 * @see        java.lang.Object#notifyAll()
 */
public final native void wait(long timeout) throws InterruptedException;

 /** @throws  InterruptedException
 *          if any thread has interrupted the current thread. The
 *          <i>interrupted status</i> of the current thread is
 *          cleared when this exception is thrown.
 */
public final void join() throws InterruptedException {
    join(0);
}
复制代码

public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);  // 调用可中断的获取锁方法
    }

public final void acquireInterruptibly(int arg)
            throws InterruptedException {
        if (Thread.interrupted())    // 获取锁时检查中断状态
            // 显式抛中断异常
            throw new InterruptedException();
        if (!tryAcquire(arg))   // 获取不到锁，执行doAcquireInterruptibly
            doAcquireInterruptibly(arg);
    }


private void doAcquireInterruptibly(int arg)
        throws InterruptedException {
        // 把线程放进等待队列
        final Node node = addWaiter(Node.EXCLUSIVE); 
        boolean failed = true;
        try {
            // 自旋
            for (;;) {
                // 获取前置节点
                final Node p = node.predecessor();
                // 前置节点为头节点 && 当前节点获取到锁
                if (p == head && tryAcquire(arg)) {
                   // 当前节点设为头节点
                    setHead(node);
                    p.next = null;  // 应用置null,便于GC
                    failed = false;
                    // 结束自旋
                    return;
                }
                // 检查是否阻塞线程 && 检查中断状态
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    // 显式抛中断异常
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }     
复制代码