ThreadThread t = new Thread(); // 线程此时处于New状态

t.start(); // 线程此时处于Runnable状态

public void run() {
    System.out.println("Thread is running.");
}
// 如果此时这个方法正在执行，那么线程就处于Running状态

synchronized(object) {
    // 如果此时object的锁被其他线程持有，那么线程就处于Blocked状态
}

// 当run()方法执行完毕，线程处于Terminated状态
public void run() {
    System.out.println("Thread is running.");
}

Thread t = new Thread(); // 新建状态
t.start(); // 调用start()方法，线程进入就绪状态

Thread.yield(); // 调用yield()方法，线程从运行状态进入就绪状态

synchronized(object) {
    // 如果此时object的锁被其他线程持有，那么线程就从运行状态进入阻塞状态
}

t.wait(); // 调用wait()方法，线程从运行状态进入等待状态
t.join(); // 调用join()方法，线程从运行状态进入等待状态

t.notify(); // notify()方法被调用，线程从等待状态进入就绪状态

Thread.sleep(1000); // 调用sleep()方法，线程从运行状态进入超时等待状态

// 创建一个继承了Thread类的ExampleThread类
class ExampleThread extends Thread {
    private Object lock; // 创建一个私有的Object对象，它将在同步代码块中被使用作为锁
    // 构造函数，接受一个Object类型的参数
    public ExampleThread(Object lock) {
        this.lock = lock; // 将传入的对象赋值给lock
    }
    // 重写Thread类的run方法
    @Override
    public void run() {
        // 同步代码块，只有获取到lock对象的锁才能执行
        synchronized(lock) {
            try {
                // 输出线程名和状态
                System.out.println(Thread.currentThread().getName() + " is running");
                // 让线程睡眠1秒，此时线程进入TIMED_WAITING状态
                Thread.sleep(1000);
                // 输出线程名和状态
                System.out.println(Thread.currentThread().getName() + " is waiting");
                // 调用wait()方法，线程释放lock锁，进入WAITING状态
                lock.wait();
                // 线程被唤醒，获取到lock锁，输出线程名和状态
                System.out.println(Thread.currentThread().getName() + " is running again");
            } catch (InterruptedException e) {
                // 线程被中断，输出线程名和状态，然后线程将结束
                System.out.println(Thread.currentThread().getName() + " is interrupted and will terminate");
            }
        }
    }
}
public class Main {
    public static void main(String[] args) throws InterruptedException {
        // 创建一个共享的锁对象
        Object lock = new Object();
        // 创建一个新的线程（NEW状态）
        Thread t1 = new ExampleThread(lock);
        System.out.println(t1.getName() + " is created");
        // 启动新的线程（READY/RUNNABLE状态）
        t1.start();
        // 让主线程睡眠2秒，这样新线程就可以先运行
        Thread.sleep(2000);
        // 唤醒等待的线程（将进入READY/RUNNABLE状态）
        synchronized(lock) {
            lock.notify();
        }
        // 让主线程再睡眠1秒，这样被唤醒的线程可以完成运行
        Thread.sleep(1000);
    }
}