package com.wry.concurrent.util;

import lombok.extern.slf4j.Slf4j;

import java.io.FileNotFoundException;
import java.io.FileReader;

/**
 * <p>
 *
 * </p>
 *
 * @author wangruiyu
 * @since 2020/7/26
 */
@Slf4j
public class FileReaderUtil {
    
    public static void read(String path) {
        log.debug("FileReader start .....");
        try {
            FileReader reader = new java.io.FileReader(path);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        log.debug("FileReader end .....");
    }
}

package com.wry.concurrent.n2;

import com.wry.concurrent.constans.Constans;
import com.wry.concurrent.util.FileReaderUtil;
import lombok.extern.slf4j.Slf4j;

import java.io.FileNotFoundException;
import java.io.FileReader;

/**
 * <p>
 * 同步等待
 * </p>
 *
 * @author wangruiyu
 * @since 2020/7/26
 */
@Slf4j
public class Sync {

    public static void main(String[] args) {
        //同步执行，必须等待fileReader方法执行完毕，才能进行其他操作
        FileReaderUtil.read(Constans.FILE_PATH);

        log.debug("do other things .....");
    }


}

package com.wry.concurrent.n2;

import com.wry.concurrent.constans.Constans;
import com.wry.concurrent.util.FileReaderUtil;
import lombok.extern.slf4j.Slf4j;

/**
 * <p>
 * 异步不等待
 * </p>
 *
 * @author wangruiyu
 * @since 2020/7/26
 */
@Slf4j
public class Async {

    public static void main(String[] args) {
        //创建一个线程去异步执行，不需要等待执行完毕，就可以执行其他操作
        new Thread(() -> {
            FileReaderUtil.read(Constans.FILE_PATH);
        }).start();

        log.debug("do other things .....");
    }
}

package com.wry.concurrent.n2.example;

import lombok.extern.slf4j.Slf4j;

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

/**
 * <p>
 * 用同步和异步两中方式计算数据所消耗的时间
 * </p>
 *
 * @author wangruiyu
 * @since 2020/7/26
 */
@Slf4j
public class MyBenchmark {

    static int[] ARRAY = new int[4000_000_00];

    static {
        Arrays.fill(ARRAY, 1);
    }

    /**
     * 异步计算 ，创建4个线程去同步计算结果，最后合并计算结果
     */
    public static void async() throws ExecutionException, InterruptedException {
        //开始时间
        Long start = System.currentTimeMillis();
        int[] array = ARRAY;
        FutureTask<Integer> task1 = new FutureTask<Integer>(() -> {
            int sum = 0;
            for (int i = 0; i < 1000_000_00; i++) {
                sum += array[0 + i];
            }
            return sum;
        });
        FutureTask<Integer> task2 = new FutureTask<Integer>(() -> {
            int sum = 0;
            for (int i = 0; i < 1000_000_00; i++) {
                sum += array[1000_000_00 + i];
            }
            return sum;
        });
        FutureTask<Integer> task3 = new FutureTask<Integer>(() -> {
            int sum = 0;
            for (int i = 0; i < 1000_000_00; i++) {
                sum += array[2000_000_00 + i];
            }
            return sum;
        });
        FutureTask<Integer> task4 = new FutureTask<Integer>(() -> {
            int sum = 0;
            for (int i = 0; i < 1000_000_00; i++) {
                sum += array[3000_000_00 + i];
            }
            return sum;
        });

        new Thread(task1).start();
        new Thread(task2).start();
        new Thread(task3).start();
        new Thread(task4).start();
        int i = task1.get() + task2.get() + task3.get() + task4.get();
        //结束时间
        Long end = System.currentTimeMillis();
        System.out.println("异步计算：计算结果：" + i + "\t总计耗时：" + (end - start));
    }

    /**
     * 同步计算
     */
    private static void sync() {
        //开始时间
        Long start = System.currentTimeMillis();
        int[] array = ARRAY;
        int sum = 0;
        for (int i = 0; i < 4000_000_00; i++) {
            sum += array[i];
        }
        //结束时间
        Long end = System.currentTimeMillis();
        System.out.println("同步计算：计算结果：" + sum + "\t总计耗时：" + (end - start));
    }


    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //同步计算
        sync();
        //异步计算
        async();
    }

}

/**
 * <p>
 * 创建线程的第一种方式 Thread类
 * </p>
 *
 * @author wangruiyu
 * @since 2020/7/27
 */

@Slf4j
public class Thread1 {
    public static void main(String[] args) {
        Thread thread = new Thread() {
            @Override
            public void run() {
                //要执行的任务
                log.debug("runing....");
            }
        };
        //设置线程名字
        thread.setName("t1");
        //启动线程
        thread.start();
        
        log.debug("main....");
    }
}

/**
 * <p>
 * 创建线程的第二种方式
 * </p>
 *
 * @author wangruiyu
 * @since 2020/7/27
 */

@Slf4j
public class Thread2 {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                //要执行的任务
                log.debug("runing....");
            }
        };

        //创建一个线程(参数1：要执行的任务，参数2：线程的名字)
        Thread thread = new Thread(runnable,"t2");
        //启动线程
        thread.start();
        
        log.debug("main....");
    }
}

//创建任务
Runnable lombdaRunnable= () -> {
    log.debug("lombda runging......"); 
};
//创建线程
Thread lombdaThead=new Thread(lombdaRunnable,"lombdaThead");
//启动线程
lombdaThead.start();

new Thread(() -> {
    log.debug("lombda runging......");
}, "lambdaThread").start();

/**
 * <p>
 * 创建线程的第三种方式
 * </p>
 *
 * @author wangruiyu
 * @since 2020/7/27
 */

@Slf4j
public class Thread3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<Integer> task=new FutureTask<>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                log.debug("running.......");
                Thread.sleep(1000);
                return 100;
            }
        });

        //创建一个线程(参数1：要执行的任务，参数2：线程的名字)
        Thread thread = new Thread(task,"t3");
        //启动线程
        thread.start();
        
        //获取task任务的返回值，主线程会等待task任务完成才会继续执行下边的操作
        Integer integer = task.get();
        log.debug("task 的返回值：{}",integer);
    }
}

/**
 * Allocates a new {@code Thread} object. This constructor has the same
 * effect as {@linkplain #Thread(ThreadGroup,Runnable,String) Thread}
 * {@code (null, target, name)}.
 *
 * @param  target
 *         the object whose {@code run} method is invoked when this thread
 *         is started. If {@code null}, this thread's run method is invoked.
 *
 * @param  name
 *         the name of the new thread
 */
public Thread(Runnable target, String name) {
    init(null, target, name, 0);
}

/**
    * Initializes a Thread with the current AccessControlContext.
    * @see #init(ThreadGroup,Runnable,String,long,AccessControlContext,boolean)
    */
   private void init(ThreadGroup g, Runnable target, String name,
                     long stackSize) {
       init(g, target, name, stackSize, null, true);
   }

/**
 * Initializes a Thread.
 *
 * @param g the Thread group
 * @param target the object whose run() method gets called
 * @param name the name of the new Thread
 * @param stackSize the desired stack size for the new thread, or
 *        zero to indicate that this parameter is to be ignored.
 * @param acc the AccessControlContext to inherit, or
 *            AccessController.getContext() if null
 * @param inheritThreadLocals if {@code true}, inherit initial values for
 *            inheritable thread-locals from the constructing thread
 */
private void init(ThreadGroup g, Runnable target, String name,
                  long stackSize, AccessControlContext acc,
                  boolean inheritThreadLocals) {
    if (name == null) {
        throw new NullPointerException("name cannot be null");
    }

    this.name = name;

    Thread parent = currentThread();
    SecurityManager security = System.getSecurityManager();
    if (g == null) {
        /* Determine if it's an applet or not */

        /* If there is a security manager, ask the security manager
           what to do. */
        if (security != null) {
            g = security.getThreadGroup();
        }

        /* If the security doesn't have a strong opinion of the matter
           use the parent thread group. */
        if (g == null) {
            g = parent.getThreadGroup();
        }
    }

    /* checkAccess regardless of whether or not threadgroup is
       explicitly passed in. */
    g.checkAccess();

    /*
     * Do we have the required permissions?
     */
    if (security != null) {
        if (isCCLOverridden(getClass())) {
            security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
        }
    }

    g.addUnstarted();

    this.group = g;
    this.daemon = parent.isDaemon();
    this.priority = parent.getPriority();
    if (security == null || isCCLOverridden(parent.getClass()))
        this.contextClassLoader = parent.getContextClassLoader();
    else
        this.contextClassLoader = parent.contextClassLoader;
    this.inheritedAccessControlContext =
            acc != null ? acc : AccessController.getContext();
    //把Runable 任务保存在成员变量
    this.target = target;
    setPriority(priority);
    if (inheritThreadLocals && parent.inheritableThreadLocals != null)
        this.inheritableThreadLocals =
            ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
    /* Stash the specified stack size in case the VM cares */
    this.stackSize = stackSize;

    /* Set thread ID */
    tid = nextThreadID();
}

/**
   * If this thread was constructed using a separate
   * <code>Runnable</code> run object, then that
   * <code>Runnable</code> object's <code>run</code> method is called;
   * otherwise, this method does nothing and returns.
   * <p>
   * Subclasses of <code>Thread</code> should override this method.
   *
   * @see     #start()
   * @see     #stop()
   * @see     #Thread(ThreadGroup, Runnable, String)
   */
  @Override
  public void run() {
      if (target != null) {
          target.run();
      }
  }

/**
 * <p>
 * 演示多个线程并发交替执行
 * </p>
 *
 * @author wangruiyu
 * @since 2020/7/27
 */
@Slf4j
public class MultiThread {
    public static void main(String[] args) {
        new Thread(()->{
            while (true) {
                log.debug("running.....");
            }
        },"t1").start();
        
        new Thread(() -> {
            while (true) {
                log.debug("running.....");
            }
        }, "t2").start();
    }
}

/**
 * <p>
 * 方法调用查看方法栈和栈帧
 * </p>
 *
 * @author wangruiyu
 * @since 2020/7/27
 */
public class Frames {
    public static void main(String[] args) {
        method1(10);
    }

    private static void method1(int x) {
        int y = x + 1;
        Object o = method2();
        System.out.println(o);
    }

    private static Object method2() {
        Object o = new Object();
        return o;
    }
}

package com.wry.concurrent.thread;

/**
 * <p>
 * 多线程情况下 方法调用查看方法栈和栈帧
 * </p>
 *
 * @author wangruiyu
 * @since 2020/7/27
 */
public class Frames2 {
    public static void main(String[] args) {
        new Thread(() -> {
            //t1线程调用
            method1(20);
        }, "t1").start();
        //main线程调用
        method1(10);
    }

    private static void method1(int x) {
        int y = x + 1;
        Object o = method2();
        System.out.println(o);
    }

    private static Object method2() {
        Object o = new Object();
        return o;
    }
}

/**
 * <p>
 * 创建线程调用 run 方法
 * </p>
 *
 * @author wangruiyu
 * @since 2020/7/27
 */
@Slf4j
public class RunMethod {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            log.debug(Thread.currentThread().getName());
            FileReaderUtil.read(Constants.FILE_PATH);
        }, "t1");

        t1.run();
    }
}

/**
 * <p>
 * 创建线程调用 run 方法
 * </p>
 *
 * @author wangruiyu
 * @since 2020/7/27
 */
@Slf4j
public class RunMethod {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            log.debug(Thread.currentThread().getName());
            FileReaderUtil.read(Constants.FILE_PATH);
        }, "t1");
//        //调用run方法
//        t1.run();
        //调用start方法
        t1.start();
    }
}

/**
 * If this thread was constructed using a separate
 * <code>Runnable</code> run object, then that
 * <code>Runnable</code> object's <code>run</code> method is called;
 * otherwise, this method does nothing and returns.
 * <p>
 * Subclasses of <code>Thread</code> should override this method.
 *
 * @see     #start()
 * @see     #stop()
 * @see     #Thread(ThreadGroup, Runnable, String)
 */
@Override
public void run() {
    if (target != null) {
        target.run();
    }
}

@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

public synchronized void start() {
     /**
      * This method is not invoked for the main method thread or "system"
      * group threads created/set up by the VM. Any new functionality added
      * to this method in the future may have to also be added to the VM.
      *
      * A zero status value corresponds to state "NEW".
      */
     if (threadStatus != 0)
         throw new IllegalThreadStateException();

     /* Notify the group that this thread is about to be started
      * so that it can be added to the group's list of threads
      * and the group's unstarted count can be decremented. */
     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();

/**
 * <p>
 * 查看线程运行状态
 * </p>
 *
 * @author wangruiyu
 * @since 2020/7/27
 */
public class ThreadStatus {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            System.out.println("running.....");
        }, "t1");

        //获取运行前的状态
        System.out.println("运行前的状态:"+t1.getState());
        //调用start方法
        t1.start();
        //获取运行后的状态
        System.out.println("运行后的状态:"+t1.getState());
    }
}

//调用start方法
t1.start();
t1.start();

/**
 * <p>
 * 测试线程的常用方法  sleep
 * </p>
 *
 * @author wangruiyu
 * @since 2020/7/27
 */
@Slf4j
public class ThreadMethod {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "t1");

        t1.start();
        log.debug("t1 线程的状态：{}",t1.getState());

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.debug("t1 线程的状态：{}",t1.getState());
    }
}

/**
 * <p>
 * 测试线程的常用方法 interrupt 打断
 * </p>
 *
 * @author wangruiyu
 * @since 2020/7/27
 */
@Slf4j
public class ThreadMethod2 {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            try {
                log.debug("enter sleep...... ");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
                log.debug("wake up...... ");
            }
        }, "t1");

        t1.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t1.interrupt();
        log.debug("interrupt...... ");
    }
}

/**
 * <p>
 * 测试线程的常用方法 使用TimeUnit
 * </p>
 *
 * @author wangruiyu
 * @since 2020/7/27
 */
@Slf4j
public class ThreadMethod3 {
    public static void main(String[] args) throws InterruptedException {
        log.debug("start ......");
        TimeUnit.SECONDS.sleep(1);
        log.debug("end ......");
    }
}

/**
 * <p>
 * 设置线程的线程优先级
 * </p>
 *
 * @author wangruiyu
 * @since 2020/7/27
 */
public class ThreadPriority {
    public static void main(String[] args) {
        Runnable task1 = () -> {
            int count = 0;
            for (; ; ) {
                System.out.println("---->1 " + count++);
            }
        };
        Runnable task2 = () -> {
            int count = 0;
            for (; ; ) {
                // Thread.yield();
                System.out.println("        ---->2 " + count++);
            }
        };
        Thread t1 = new Thread(task1, "t1");
        Thread t2 = new Thread(task2, "t2");
        t1.start();
        t2.start();
    }
}

/**
 * <p>
 * 设置线程的线程优先级
 * </p>
 *
 * @author wangruiyu
 * @since 2020/7/27
 */
public class ThreadPriority {
    public static void main(String[] args) {
        Runnable task1 = () -> {
            int count = 0;
            for (; ; ) {
                System.out.println("---->1 " + count++);
            }
        };
        Runnable task2 = () -> {
            int count = 0;
            for (; ; ) {
                //调用yield,把CPU执行执行时间交给其他线程
                Thread.yield();
                System.out.println("        ---->2 " + count++);
            }
        };
        Thread t1 = new Thread(task1, "t1");
        Thread t2 = new Thread(task2, "t2");
        t1.start();
        t2.start();
    }
}

/**
 * <p>
 * 设置线程的线程优先级
 * </p>
 *
 * @author wangruiyu
 * @since 2020/7/27
 */
public class ThreadPriority {
    public static void main(String[] args) {
        Runnable task1 = () -> {
            int count = 0;
            for (; ; ) {
                System.out.println("---->1 " + count++);
            }
        };
        Runnable task2 = () -> {
            int count = 0;
            for (; ; ) {
                System.out.println("        ---->2 " + count++);
            }
        };
        Thread t1 = new Thread(task1, "t1");
        Thread t2 = new Thread(task2, "t2");
        //t1线程设置最小的线程优先级
        t1.setPriority(Thread.MIN_PRIORITY);
        //t2线程设置最大的线程优先级
        t2.setPriority(Thread.MAX_PRIORITY);
        
        t1.start();
        t2.start();
    }
}

Thread t1 = new Thread(() -> {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }   
        },"t1");
        t1.start();

/**
 * <p>
 * 测试线程的常用方法 join
 * </p>
 *
 * @author wangruiyu
 * @since 2020/7/28
 */
@Slf4j
public class JoinMethod {
    private static int r = 0;

    private static void test1() {
        log.debug("开始......");
        Thread t1 = new Thread(() -> {
            log.debug("开始......");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            log.debug("结束......");
            r = 10;
        },"t1");
        t1.start();
        log.debug("结果为:{}", r);
        log.debug("结束......");
    }

    public static void main(String[] args) throws InterruptedException {
        test1();
    }
}

/**
 * <p>
 * 测试线程的常用方法 join
 * </p>
 *
 * @author wangruiyu
 * @since 2020/7/28
 */
@Slf4j
public class JoinMethod {
    private static int r = 0;

    private static void test1() throws InterruptedException {
        log.debug("开始......");
        Thread t1 = new Thread(() -> {
            log.debug("开始......");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            log.debug("结束......");
            r = 10;
        },"t1");
        t1.start();
        //等待t1线程执行结束
        t1.join();
        log.debug("结果为:{}", r);
        log.debug("结束......");
    }

    public static void main(String[] args) throws InterruptedException {
        test1();
    }
}

/**
 * <p>
 * 测试线程的常用方法 join 等待多个结果
 * </p>
 *
 * @author wangruiyu
 * @since 2020/7/28
 */
@Slf4j
public class JoinMethod2 {
    private static int r1 = 0;
    private static int r2 = 0;

    private static void test1() throws InterruptedException {
        log.debug("开始......");
        Thread t1 = new Thread(() -> {
            log.debug("开始......");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            log.debug("结束......");
            r1 = 10;
        }, "t1");

        Thread t2 = new Thread(() -> {
            log.debug("开始......");
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            log.debug("结束......");
            r2 = 20;
        }, "t2");

        //启动线程
        t1.start();
        t2.start();

        //开始时间
        long start = System.currentTimeMillis();
        log.debug("join begin ......");
        t1.join();
        log.debug("t1 join end ......");
        t2.join();
        log.debug("t2 join end ......");
        //结束时间
        long end = System.currentTimeMillis();
        log.debug("t1 结果为:{},t2 结果为:{},总耗时：{}", r1, r2, end - start);
        log.debug("结束......");
    }

    public static void main(String[] args) throws InterruptedException {
        test1();
    }
}

/**
 * <p>
 * 测试线程的常用方法 join 有时效的等待
 * </p>
 *
 * @author wangruiyu
 * @since 2020/7/28
 */
@Slf4j
public class JoinMethod3 {
    private static int r1 = 0;

    private static void test1() throws InterruptedException {
        log.debug("开始......");
        Thread t1 = new Thread(() -> {
            log.debug("开始......");
            try {
                //睡2000毫秒
                TimeUnit.MILLISECONDS.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            log.debug("结束......");
            r1 = 10;
        }, "t1");

        //启动线程
        t1.start();

        //开始时间
        long start = System.currentTimeMillis();
        log.debug("join begin ......");
        //只等待1500毫秒
        t1.join(1500);
        log.debug("t1 join end ......");
        //结束时间
        long end = System.currentTimeMillis();
        log.debug("t1 结果为:{},总耗时：{}", r1,  end - start);
        log.debug("结束......");
    }

    public static void main(String[] args) throws InterruptedException {
        test1();
    }
}

package com.wry.concurrent.thread;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.TimeUnit;

/**
 * <p>
 * 测试线程的常用方法  interrupt 打断阻塞线程
 * </p>
 *
 * @author wangruiyu
 * @since 2020/7/28
 */
@Slf4j
public class InterruptMethod {
    private static void test1() throws InterruptedException {
        Thread t1 = new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "t1");
        t1.start();
        log.debug("interrupt... ");
        TimeUnit.SECONDS.sleep(1);
        t1.interrupt();
        log.debug(" 打断状态: {}", t1.isInterrupted());
    }

    public static void main(String[] args) throws InterruptedException {
        test1();
    }
}

/**
 * <p>
 * 测试线程的常用方法  interrupt 打断正常状态线程
 * </p>
 *
 * @author wangruiyu
 * @since 2020/7/28
 */
@Slf4j
public class InterruptMethod2 {
    private static void test1() throws InterruptedException {
        Thread t1 = new Thread(() -> {
            while (true) {
               
            }
        }, "t1");

        t1.start();

        log.debug("interrupt... ");
        TimeUnit.SECONDS.sleep(1);
        t1.interrupt();
        log.debug(" 打断状态: {}", t1.isInterrupted());
    }

    public static void main(String[] args) throws InterruptedException {
        test1();
    }
}

/**
 * <p>
 * 测试线程的常用方法  interrupt 打断正常状态线程
 * </p>
 *
 * @author wangruiyu
 * @since 2020/7/28
 */
@Slf4j
public class InterruptMethod2 {
    private static void test1() throws InterruptedException {
        Thread t1 = new Thread(() -> {
            while (true) {
                boolean isInterrupt = Thread.currentThread().isInterrupted();
                if (isInterrupt) {
                    log.debug("被打断了，退出循环");
                    break;
                }
            }
        }, "t1");

        t1.start();

        log.debug("interrupt... ");
        TimeUnit.SECONDS.sleep(1);
        t1.interrupt();
        log.debug(" 打断状态: {}", t1.isInterrupted());
    }

    public static void main(String[] args) throws InterruptedException {
        test1();
    }
}

/**
 * <p>
 * 测试线程的常用方法  interrupt 打断park线程
 * </p>
 *
 * @author wangruiyu
 * @since 2020/7/28
 */
@Slf4j
public class InterruptMethod3 {
    private static void test1() throws InterruptedException {
        Thread t1 = new Thread(() -> {
            log.debug("park...");
            LockSupport.park();
            log.debug("unpark...");
            log.debug("打断状态：{}", Thread.currentThread().isInterrupted());
        }, "t1");
        t1.start();
        TimeUnit.SECONDS.sleep(1);
        t1.interrupt();
    }

    public static void main(String[] args) throws InterruptedException {
        test1();
    }
}

/**
 * <p>
 * 测试线程的常用方法  interrupt 打断park线程
 * </p>
 *
 * @author wangruiyu
 * @since 2020/7/28
 */
@Slf4j
public class InterruptMethod3 {
    private static void test1() throws InterruptedException {
        Thread t1 = new Thread(() -> {
            log.debug("park...");
            LockSupport.park();
            log.debug("unpark...");
            log.debug("打断状态：{}", Thread.currentThread().isInterrupted());
            //再次park
            LockSupport.park();
            log.debug("unpark...");

        }, "t1");
        t1.start();
        TimeUnit.SECONDS.sleep(1);
        t1.interrupt();
    }

    public static void main(String[] args) throws InterruptedException {
        test1();
    }
}

package com.wry.concurrent.thread;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;

/**
 * <p>
 * 测试线程的常用方法  interrupt 打断park线程
 * </p>
 *
 * @author wangruiyu
 * @since 2020/7/28
 */
@Slf4j
public class InterruptMethod3 {
    private static void test1() throws InterruptedException {
        Thread t1 = new Thread(() -> {
            log.debug("park...");
            LockSupport.park();
            log.debug("unpark...");
            log.debug("打断状态：{}", Thread.interrupted());
            //再次park
            LockSupport.park();
            log.debug("unpark...");
        }, "t1");
        t1.start();
        TimeUnit.SECONDS.sleep(1);
        t1.interrupt();

        TimeUnit.SECONDS.sleep(1);
        t1.interrupt();
    }

    public static void main(String[] args) throws InterruptedException {
        test1();
    }
}

/**
 * <p>
 * 利用interrupt实现两阶段停止。
 * </p>
 *
 * @author wangruiyu
 * @since 2020/7/28
 */
@Slf4j
public class TwoPhaseTermination {
    private Thread monitor;

    /**
     * 启动监控
     */
    private void start() {
        monitor = new Thread(() -> {
            while (true) {
                Thread currentThread = Thread.currentThread();
                if (currentThread.isInterrupted()){
                    log.debug("料理后事。。。。。。");
                    break;
                }
                try {
                    TimeUnit.SECONDS.sleep(1); //打断阻塞的线程  会抛异常，打断标记会被重置
                    log.debug("执行监控记录。。。。。。"); //打断正常的线程
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    //再次打断,重新设置打断标记
                    currentThread.interrupt();
                }
            }
        });

        monitor.start();
    }

    /**
     * 停止监控
     */
    private void stop() {
        monitor.interrupt();
    }

    public static void main(String[] args) throws InterruptedException {
        TwoPhaseTermination termination = new TwoPhaseTermination();
        termination.start();

        TimeUnit.SECONDS.sleep(3);
        termination.stop();
    }
}

/**
 * <p>
 * 主线程与守护线程
 * </p>
 *
 * @author wangruiyu
 * @since 2020/7/28
 */
@Slf4j
public class DaemonThread {
    private static void test1() throws InterruptedException {
        log.debug("开始运行...");
        Thread t1 = new Thread(() -> {
            log.debug("开始运行...");
            while (true) {
                if (Thread.currentThread().isInterrupted()) {
                    break;
                }
            }
            log.debug("运行结束...");
        }, "t1");
        t1.start();
        TimeUnit.SECONDS.sleep(1);
        log.debug("运行结束...");
    }

    public static void main(String[] args) throws InterruptedException {
        test1();
    }
}

/**
 * <p>
 * 主线程与守护线程
 * </p>
 *
 * @author wangruiyu
 * @since 2020/7/28
 */
@Slf4j
public class DaemonThread {
    private static void test1() throws InterruptedException {
        log.debug("开始运行...");
        Thread t1 = new Thread(() -> {
            log.debug("开始运行...");
            while (true) {
                if (Thread.currentThread().isInterrupted()) {
                    break;
                }
            }
            log.debug("运行结束...");
        }, "t1");
        // 设置该线程为守护线程
        t1.setDaemon(true);
        t1.start();
        TimeUnit.SECONDS.sleep(1);
        log.debug("运行结束...");
    }

    public static void main(String[] args) throws InterruptedException {
        test1();
    }
}

public enum State {
    /**
     * Thread state for a thread which has not yet started.
     */
    NEW,

    /**
     * Thread state for a runnable thread.  A thread in the runnable
     * state is executing in the Java virtual machine but it may
     * be waiting for other resources from the operating system
     * such as processor.
     */
    RUNNABLE,

    /**
     * Thread state for a thread blocked waiting for a monitor lock.
     * A thread in the blocked state is waiting for a monitor lock
     * to enter a synchronized block/method or
     * reenter a synchronized block/method after calling
     * {@link Object#wait() Object.wait}.
     */
    BLOCKED,

    /**
     * Thread state for a waiting thread.
     * A thread is in the waiting state due to calling one of the
     * following methods:
     * <ul>
     *   <li>{@link Object#wait() Object.wait} with no timeout</li>
     *   <li>{@link #join() Thread.join} with no timeout</li>
     *   <li>{@link LockSupport#park() LockSupport.park}</li>
     * </ul>
     *
     * <p>A thread in the waiting state is waiting for another thread to
     * perform a particular action.
     *
     * For example, a thread that has called <tt>Object.wait()</tt>
     * on an object is waiting for another thread to call
     * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
     * that object. A thread that has called <tt>Thread.join()</tt>
     * is waiting for a specified thread to terminate.
     */
    WAITING,

    /**
     * Thread state for a waiting thread with a specified waiting time.
     * A thread is in the timed waiting state due to calling one of
     * the following methods with a specified positive waiting time:
     * <ul>
     *   <li>{@link #sleep Thread.sleep}</li>
     *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
     *   <li>{@link #join(long) Thread.join} with timeout</li>
     *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
     *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
     * </ul>
     */
    TIMED_WAITING,

    /**
     * Thread state for a terminated thread.
     * The thread has completed execution.
     */
    TERMINATED;
}