JUC系列：（二）线程

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("run");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start();
    }
}

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("run");
    }
}

public class Main {
    public static void main(String[] args) {
        Runnable r1 = new MyRunnable();
        Thread t1 = new Thread(r1);
        t1.start();
    }
}

class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "hello";
    }
}

public class Main {
    public static void main(String[] args) {
        Callable<String> callable = new MyCallable();
        FutureTask<String> task = new FutureTask<>(callable);
        Thread thread = new Thread(task);
        thread.start();
    }
}

// 先调用它
public Thread(Runnable target) {
    this(null, target, "Thread-" + nextThreadNum(), 0);
}

// 然后调用它
public Thread(ThreadGroup group, Runnable target, String name, long stackSize) {
    this(group, target, name, stackSize, null, true);
}

// 主要的代码：
private Thread(ThreadGroup g, Runnable target, String name, 
               long stackSize, AccessControlContext acc, boolean inheritThreadLocals) {
    // ...
    
    // 最重要的：这里将Runnable接口（target）赋值给Thread自己的target成员属性 
    this.target = target;
    
    // ...
}

// 如果实现了runnable接口，那么target不会为null，最终调用实现的run方法
@Override
public void run() {
    if (target != null) {
        target.run();
    }
}

// start方法，只能被调用一次
public synchronized void start() {
    if (threadStatus != 0)
        throw new IllegalThreadStateException();

    group.add(this);
    boolean started = false;
    try {
        start0();
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
            /* do nothing. If start0 threw a Throwable then it will be passed up the call stack */
        }
    }
}

private native void start0();

// 如果实现了runnable接口，那么target不会为null，最终调用实现的run方法
@Override
public void run() {
    if (target != null) {
        target.run();
    }
}

public final synchronized void join(long millis) throws InterruptedException {
    while (isAlive()) {
        wait(0);
    }
}

Thread t1 = new Thread(()->{
    try {
        Thread.sleep(1000); // 阻塞状态
    } catch (InterruptedException e) {
        e.printStackTrace(); // 打断后，进入异常处理
    }
}, "t1");

t1.start();
Thread.sleep(500);
t1.interrupt();

System.out.println(" 打断状态: " + t1.isInterrupted()); // 打断状态: false

Thread t2 = new Thread(()->{
    while(true) {
        if(Thread.currentThread().isInterrupted()) {
            System.out.println(" 打断状态: " + interrupted); // 打断状态: true
            break;
        }
    }
}, "t2");

t2.start();
Thread.sleep(500);
t2.interrupt();

Thread t1 = new Thread(() -> {
    System.out.println("park...");
    LockSupport.park();
    System.out.println("unpark...");
    System.out.println("打断状态: " + Thread.currentThread().isInterrupted()); // 打断状态: true
}, "t1");

t1.start();
Thread.sleep(2000);
t1.interrupt();

class MyThread {
    private Thread monitor;

    public void start() {
        monitor = new Thread(() -> {
            while (true) {
                if (Thread.interrupted()) {
                    break;
                }
                
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    Thread.currentThread().interrupt();
                }
            }
        });
        monitor.start();
    }
    
    public void stop() {
        monitor.interrupt();
    }
}

public enum State {
    
    NEW,			// 创建状态：线程已创建，但是还没start

    RUNNABLE,		// 就绪状态：调用了start，可能在CPU上运行，也可能没有，取决于操作系统

    BLOCKED,		// 阻塞状态：尝试获取一个锁，但是获取失败

    WAITING,		// 无限等待状态：等待其他线程的唤醒（其他线程调用notify）

    TIMED_WAITING,	// 超时等待状态：保持到期满，或者接收到唤醒通知（如：Thread.sleep, Object.wait）

    TERMINATED;		// 结束状态：正常退出，或者有没有捕获的异常而终止
}