package com.fly.base;

public class Thread01 extends Thread {

    /**
     * 继承Thread类重写Thread类的run(),run()用于描述线程的执行任务内容,
     * Thread的start()用于启动线程。
     */
    @Override
    public void run() {
        // 获取当前执行线程实例
        Thread thread = Thread.currentThread();
        System.out.println("当前执行线程id(tid):"+thread.getId());
        // 若不显示指定线程名称,默认以 "Thread-" + 线程下标(从0为开启下标)命名
        System.out.println("当前执行线程名称:"+thread.getName());
        System.out.println("当前执行线程状态:"+thread.getState());
        // Java线程的优先级分为1到10,默认优先级为5,优先级高不能线程的执行优先级
        System.out.println("当前执行线程优先级:"+thread.getPriority());
    }

    public static void main(String[] args) {
        Thread01 t01 = new Thread01();
        // 启动线程
        t01.start();
    }
}

// Runnable接口源码
package java.lang;
@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

package com.fly.base;

/**
 * 实现Runnable接口重写run()创建线程
 */
public class Thread02 implements Runnable {

    @Override
    public void run() {
        System.out.println("===== 普通写法 =====");
        Thread thread = Thread.currentThread();
        System.out.println("当前执行线程id(tid):" + thread.getId());
        System.out.println("当前执行线程名称:" + thread.getName());
        System.out.println("当前执行线程状态:" + thread.getState());
        System.out.println("当前执行线程优先级:" + thread.getPriority());
    }

    public static void main(String[] args) {
        Thread02 t = new Thread02();
        // 普通写法:传入Runnable实例通过Thread构造方法创建方法
        Thread thread01 = new Thread(t);
        // 调用start()启动线程后会执行Runnable接口的run()
        thread01.start();

        // 匿名内部类写法
        Thread thread02 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println();
                System.out.println("===== 匿名内部类写法 =====");
                Thread thread = Thread.currentThread();
                System.out.println("当前执行线程id(tid):" + thread.getId());
                System.out.println("当前执行线程名称:" + thread.getName());
                System.out.println("当前执行线程状态:" + thread.getState());
                System.out.println("当前执行线程优先级:" + thread.getPriority());
            }
        });
        thread02.start();

        // lambda写法。由于Runnable接口是一个函数式接口(有且只有一个抽象方法的接口),支持使用lambda表达式写法
        new Thread(() -> {
            System.out.println();
            System.out.println("===== lambda写法 =====");
            Thread currentThread = Thread.currentThread();
            System.out.println("当前执行线程id(tid):" + currentThread.getId());
            System.out.println("当前执行线程名称:" + currentThread.getName());
            System.out.println("当前执行线程状态:" + currentThread.getState());
            System.out.println("当前执行线程优先级:" + currentThread.getPriority());
        }).start();
    }
}

package java.util.concurrent;
// Callable源码
@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception;
}

package java.util.concurrent;
// RunnableFuture源码
public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

package java.util.concurrent;
// Future源码
public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException, ExecutionException;
    V get(long timeout, TimeUnit unit)
            throws InterruptedException, ExecutionException, TimeoutException;
}

package com.fly.base;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * 基于Callable接口重写call()创建线程
 */
public class Thread03 {

    /**
     * 创建静态内部类,基于Callable接口重写call()创建线程
     */
    static class ReturnableTask implements Callable<Long> {
        private static final long NUMBER = 100000000;
        @Override
        public Long call() throws Exception {
            long startTime = System.currentTimeMillis();
            System.out.println("当前执行线程:" + Thread.currentThread().getName());
            // 当前线程休眠1000ms
            Thread.sleep(1000);
            for (int i = 0; i < NUMBER ;i++){
                int j = i *1000;
            }
            long used = System.currentTimeMillis() - startTime;
            return used;
        }
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // (1).构造一个Callable接口实例
        ReturnableTask task = new ReturnableTask();
        // (2).将Callable实例作为FutureTask的构造函数创建一个FutureTask实例
        FutureTask<Long> futureTask = new FutureTask<>(task);
        // (3).将FutureTask实例作为Thread构造器的target
        Thread thread = new Thread(futureTask);
        // (4).启动线程
        thread.start();
        // (5).通过FutureTask实例获取Callable接口call()执行结果
        System.out.println("线程执行结果:"+futureTask.get());
    }
}

package com.fly.base;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * 基于线程池创建线程。
 */
public class Thread04 {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 创建一个具有缓存功能的线程池
        ExecutorService pool = Executors.newFixedThreadPool(3);

        // 执行一个线程。execute仅支持Runnable接口,不支持Callable接口,且execute()无返回值
        pool.execute(() -> {
            System.out.println("execute:基于线程池创建线程");
        });

        // 提交并执行一个线程。submit即支持Runnable接口,又支持Callable接口,submit()返回值
        Future<String> future = pool.submit(() -> "submit:基于线程池创建线程");
        System.out.println("异步执行结果:"+future.get());

        // 关闭线程池
        pool.shutdown();
    }
}

public final static int MIN_PRIORITY = 1;
public final static int NORM_PRIORITY = 5;
public final static int MAX_PRIORITY = 10;

package com.fly.base;

/**
 * 线程优先级,Thread通过priority属性描述线程的优先级,通过Thread实例的getPriority()可以获取
 * 线程的优先级,通过Thread实例的setPriority()可以设置线程的优先级。
 * Thread线程默认优先级为5,最大优先级为10,最小优先级为1,在Thread分别用MIN_PRIORIT、
 * NORM_PRIORITY、MAX_PRIORITY常量分别表示。Java采用抢占式调度模型,虽然线程优先级越高,
 * 线程获得CPU的时间片机会也就越多,并实际运行中并非绝对。
 */
public class Thread05 {
    // 线程睡眠间隔时间
    public static final int SLEEP_GAP = 1000;

    static class PriorityThread extends Thread {
        // 线程编号
        static int threadNo = 1;
        // 机会值变量,机会值越大获得CPU时间片的机会就越大
        public long num;

        public PriorityThread() {
            // 调用父类Thread的构造方法设置线程名称
            super("thead-" + threadNo);
            threadNo++;
        }

        @Override
        public void run() {
            for (int i = 0; ; i++) {
                num++;
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        PriorityThread[] threads = new PriorityThread[10];
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new PriorityThread();
            // 设置线程优先级
            threads[i].setPriority(i + 1);
        }
        for (int i = 0; i < threads.length; i++) {
            threads[i].start();
        }
        // 线程睡眠
        Thread.sleep(SLEEP_GAP);
        for (int i = 0; i < threads.length; i++) {
            // 停止线程(stop方法已过期且不安全,不推荐使用该种方式关闭线程)
            threads[i].stop();
        }
        for (int i = 0; i < threads.length; i++) {
            System.out.println(threads[i].getName() + "-优先级:" + threads[i].getPriority() + "-机会值:" + threads[i].num);
        }
    }
}

// 以整数的形式存储线程的状态
private int threadStatus;
// 返回当前线程的状态,一个枚举类型值
public Thread.State getState();

public enum State {
  // 新建
  NEW,
  // 运行
  RUNNABLE,
  // 阻塞
  BLOCKED,
  // 等待
  WAITING,
  // 限时等待
  TIMED_WAITING,
  // 终止
  TERMINATED;
}

// 默认线程是用户线程
private boolean daemon = false;
// 设置线程为守护线程或用户线程
public final void setDaemon(boolean on);
// 判断当前线程是否是守护线程
public final boolean isDaemon();

package com.fly.base;

/**
 * 线程分为守护线程和用户线程
 */
public class Thread06 {

    public static void main(String[] args) {
        Thread thread = new Thread(()-> {
            System.out.println("start thread...");
        });
        // 设置线程为守护线程,注意:需要在调用Thread.start()前设置,否则JVM会抛出一个InterruptedException异常
        thread.setDaemon(true);
        // 启动线程
        thread.start();
    }
}

public final void wait() throws InterruptedException;
/**
 * 该方法允许线程在指定的时间内等待(timeoutMillis表示等待的最长时间,以毫秒为单位),
 * 如果在这段时间内没有被其他线程唤醒,线程将自动苏醒
 */
public final void wait(long timeoutMillis) throws InterruptedException

public class MyThread extends Thread {
    // 定义一把锁
    private static final Object lock = new Object();

    @Override
    public void run() {
        // synchronized锁对象为当前实例
        synchronized (lock) {
            try {
                System.out.println("线程等待中...");
                /**
                 * 调用wait()使当前线程处于等待状态,并释放锁资源(lock),直到调用notify()或notifyAll()
                 * 唤醒处于等待的线程(调用wait、notify、notifyAll必须是拥有对象锁的线程,否则抛出IllegalMonitorStateException),
                 * 否则将阻塞后续代码执行
                 */
                lock.wait();
                System.out.println("线程等待完毕...");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();

        // 等待3s唤醒处于等待的线程,3s后打印 "线程等待完毕..."
        try {
            Thread.sleep(3000);
            synchronized (lock) {
                lock.notify();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class MyThread extends Thread {
    // 定义一把锁
    private static final Object lock = new Object();

    @Override
    public void run() {
        // synchronized锁对象为当前实例
        synchronized (lock) {
            try {
                System.out.println("线程" + Thread.currentThread().getName() + "等待中...");
                /**
                 * 调用wait()使当前线程处于等待状态,并释放锁资源(lock),直到调用notify()或notifyAll()
                 * 唤醒处于等待的线程(调用wait、notify、notifyAll必须是拥有对象锁的线程,否则抛出IllegalMonitorStateException),
                 * 否则将阻塞后续代码执行
                 */
                lock.wait();
                System.out.println("线程" + Thread.currentThread().getName() + "等待完毕...");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public static void main(String[] args) {
        // 创建两个线程
        MyThread thread01 = new MyThread();
        MyThread thread02 = new MyThread();
        thread01.start();
        thread02.start();

        /**
         * 等待3s唤醒处于等待的线程,3s后打印 "线程等待完毕...",由于启动了两个线程,
         * 调用lock.notify()后只会唤醒在当前对象上等待的一个线程,另外一个线程仍处于等待状态,
         * 应用程序不会终止。
         *
         * 当调用lock.notifyAll()唤醒所有处于等待状态的线程时,处于等待状态的两个线程都会被唤醒,
         * 打印"线程等待完毕",应用程序终止。
         */
        try {
            Thread.sleep(3000);
            synchronized (lock) {
                // notify()用于唤醒上一个处于等待的线程,notifyAll()唤醒所有处于等待状态的线程
                lock.notify();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class SleepExample {
    public static void main(String[] args) {
        System.out.println("开始启动");
        try {
            // 让当前线程休眠 2 秒,2s后打印"启动结束"
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("启动结束");
    }
}

public class MyThread {
    // 定义一把锁
    private static final Object lock = new Object();


    public static void main(String[] args) {
        // 创建两个线程
        Thread thread01 = new Thread(MyThread::sleepingTask);
        Thread thread02 = new Thread(MyThread::otherTask);
        thread01.start();
        thread02.start();
    }

    public static void sleepingTask() {
        synchronized (lock) {
            System.out.println("线程1进入同步块");
            try {
                // 当前线程休眠 5s
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程1退出同步块");
        }
    }

    public static void otherTask() {
        synchronized (lock) {
            System.out.println("线程2进入同步块");
            System.out.println("线程2退出同步块");
        }
    }
}

public class MyThread extends Thread {

    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            if (i == 3) {
                Thread.yield();
                System.out.println("线程" + Thread.currentThread().getName() + ",i=" + i + ",让出CPU调度权,优先执行其他线程");
                continue;
            }
            System.out.println("线程" + Thread.currentThread().getName() + ",i=" + i);
        }
    }

    public static void main(String[] args) {
        // 创建3个线程
        MyThread thread01 = new MyThread();
        MyThread thread02 = new MyThread();
        MyThread thread03 = new MyThread();
        thread01.start();
        thread02.start();
        thread03.start();
    }
}

public class TrafficLightExample {
    // 定义一把锁
    private static final Object LOCK = new Object();
    // 初始颜色为RED
    private static final String COLOR_RED = "RED";
    private static final String COLOR_YELLOW = "YELLOW";
    private static final String COLOR_GREEN = "GREEN";
    private static String color = COLOR_RED;


    public static void redLight() {
        synchronized (LOCK) {
            try {
                while (true) {
                    // 如果当前不是红灯,则当前线程等待
                    while (!COLOR_RED.equals(color)) {
                        LOCK.wait();
                    }
                    System.out.println("红灯亮起");
                    // 红灯持续2秒
                    Thread.sleep(2000);
                    // 切换到黄灯
                    color = COLOR_YELLOW;
                    LOCK.notifyAll();
                    // 释放锁,使当前线程处于等待状态,让其他线程有机会执行
                    LOCK.wait();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void yellowLight() {
        synchronized (LOCK) {
            try {
                while (true) {
                    // 如果当前是黄灯,则当前线程等待
                    while (!COLOR_YELLOW.equals(color)) {
                        LOCK.wait();
                    }
                    System.out.println("黄灯亮起");
                    // 黄灯持续3s
                    Thread.sleep(3000);
                    // 切换到绿灯
                    color = COLOR_GREEN;
                    LOCK.notifyAll();
                    // 释放锁,使当前线程处于等待状态,让其他线程有机会执行
                    LOCK.wait();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void greenLight() {
        synchronized (LOCK) {
            try {
                while (true) {
                    // 如果当前不是绿灯,则当前线程等待
                    while (!COLOR_GREEN.equals(color)) {
                        LOCK.wait();
                    }
                    System.out.println("绿灯亮起");
                    // 绿灯持续2s
                    Thread.sleep(2000);
                    // 切换到红灯
                    color = COLOR_RED;
                    LOCK.notifyAll();
                    // 释放锁,使当前线程处于等待状态,让其他线程有机会执行
                    LOCK.wait();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        // 创建红、黄、绿三个线程
        Thread redLightThread = new Thread(TrafficLightExample::redLight);
        Thread yellowLightThread = new Thread(TrafficLightExample::yellowLight);
        Thread greenLightThread = new Thread(TrafficLightExample::greenLight);
        redLightThread.start();
        yellowLightThread.start();
        greenLightThread.start();
    }
}

public class MyThread extends Thread{
    @Override
    public void run() {
        try {
            // 循环判断当前线程是否中断
            while (!Thread.interrupted()) {
                System.out.println("线程工作中...");
                // 模拟线程执行
                Thread.sleep(1000);
            }
        }catch (InterruptedException e){
            System.out.println("线程在睡眠时中断.");
        }
    }

    public static void main(String[] args) {
        // 创建一个线程
        MyThread myThread = new MyThread();
        // 启动线程
        myThread.start();

        // 模拟运行一段时间后中断线程
        try {
            Thread.sleep(3000);
            // 中断当前线程
            myThread.interrupt();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

public class MyThread extends Thread {
    // 定义标志位,使用volatile修饰变量保证线程可见性
    private volatile boolean isRunning = true;

    @Override
    public void run() {
        while (isRunning) {
            System.out.println("线程工作中...");
            try {
                // 模拟线程耗时操作
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 停止线程方法
     */
    public void stopThread() {
        isRunning = false;
    }

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();

        // 模拟运行一段时间后停止线程
        try {
            Thread.sleep(3000);
            thread.stopThread();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class MyThread extends Thread {
    // 定义标志位,使用volatile修饰变量保证线程可见性
    private volatile boolean isRunning = true;
    // 定义一把对象锁
    private final Object lock = new Object();

    @Override
    public void run() {
        try {
            while (isRunning) {
                synchronized (lock) {
                    // 模拟一个可能长时间阻塞的操作
                    lock.wait();
                    System.out.println("线程等待中...");
                }
                System.out.println("线程工作中...");
            }
        } catch (InterruptedException e) {
            System.out.println("线程中断.");
        }
    }

    /**
     * 停止线程方法
     */
    public void stopThread() {
        synchronized (lock) {
            // 唤醒可能在等待的线程
            lock.notifyAll();
        }
        isRunning = false;
    }

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();

        // 模拟运行一段时间后停止线程
        try {
            Thread.sleep(5000);
            thread.stopThread();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}