02 Java多线程及并发 runable、callable；理解interrupt中断；jvm信息如何查看；线程可以被中断吗？

1、Runable、Callable

• 只有Thread代表线程，Runable仅代表一个任务，可以被任何线程执行的任务。
• Runable不能有返回值，不能抛出checked exception。
• Callable 可以有返回值，也能抛出异常。

2、Thread中断

• 为什么线程中使用Thread.sleep等方法时，需要抛出InterruptedException
• Thread.interrupt 唯一的用处就是取消一个耗时的操作。中断别的线程。
• 允许线程A对线程B进行有限度的控制。
• 线程可以选择不影响InterruptedException，但不推荐。
• 除非你非常确定目标线程的中断特性，否则不要中断它。

Thread.interrupt 中断其它线程的示例

主线程中断Thread线程。

public static void main(String[] args) throws InterruptedException {
       Thread newThread = new Thread(() -> {
           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               System.err.println("Thread被中断了。");
               e.printStackTrace();
           }
       });
       newThread.start();
       //主线程睡500ms
       Thread.sleep(500);
       newThread.interrupt();//在主线程中 中断Thread线程

   }

输出：

Thread被中断了。
java.lang.InterruptedException
	at java.lang.Thread.sleep(Native Method)
	at java.lang.Thread.sleep(Thread.java:953)
	at com.lingyiwin.thread.ThreadInterrupt.lambda$main$0(ThreadInterrupt.java:13)
	at com.lingyiwin.thread.ThreadInterrupt$$Lambda$1/000000000000000000.run(Unknown Source)
	at java.lang.Thread.run(Thread.java:823)

1、任何线程都可以被中断吗？

不是的，取决于这个线程自己的决定。

public class ThreadInterrupt {
    public static void main(String[] args) throws InterruptedException {
        Thread newThread = new Thread(() -> {
            try {
                int i = 0;
                while (true){
                    doNothing();
                    i++;
                }
            } catch (InterruptedException e) {
                System.err.println("Thread被中断了。");
                e.printStackTrace();
            }
        });
        newThread.start();
        //主线程睡500ms
        Thread.sleep(500);
        newThread.interrupt();//在主线程中 中断Thread线程
    }

    public static void doNothing() throws InterruptedException{
        System.out.println("doNothing function....");
    }
}

输出：

doNothing function....
doNothing function....
doNothing function....
//........
doNothing function....
doNothing function....
doNothing function....

看看jvm干了什么.如下代码一直在执行循环。

"Thread-3" Id=28 RUNNABLE
        at com.lingyiwin.thread.ThreadInterrupt.lambda$main$0(ThreadInterrupt.java:15)
        at com.lingyiwin.thread.ThreadInterrupt$$Lambda$1/000000000000000000.run(Unknown Source)
        at java.lang.Thread.run(Thread.java:823)

2、中断只能发生在如下方法中吗？

==取决于线程自己的策略，JVM的阻塞方法都会正常响应。

3、如果没有能力处理中断，请重新设置中断标志位，使其它调用者知道该线程被中断了。

示例：

private static class T1 extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    TimeUnit.MICROSECONDS.sleep(500);
                } catch (InterruptedException e) {
                	//重新设置中断标志位。
                    Thread.currentThread().interrupt();
                    //e.printStackTrace();
                }
                System.out.println("T1");
            }
        }
    }

3、如何让线程一直等待

countDownLatch 这个类使一个线程等待其他线程各自执行完毕后再执行。

通过一个计数器来实现的，计数器的初始值是线程的数量。每当一个线程执行完毕后，计数器的值就-1，当计数器的值为0时，表示所有线程都执行完毕，然后在闭锁上等待的线程就可以恢复工作了。

调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行.

示例：

public class CountDownLatchTest {

    public static void main(String[] args) {
        final CountDownLatch latch = new CountDownLatch(2);
        System.out.println("主线程开始执行…… ……");
        //第一个子线程执行
        ExecutorService es1 = Executors.newSingleThreadExecutor();
        es1.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000);
                    System.out.println("子线程："+Thread.currentThread().getName()+"执行");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                latch.countDown();
            }
        });
        es1.shutdown();

        //第二个子线程执行
        ExecutorService es2 = Executors.newSingleThreadExecutor();
        es2.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("子线程："+Thread.currentThread().getName()+"执行");
                latch.countDown();
            }
        });
        es2.shutdown();
        System.out.println("等待两个线程执行完毕…… ……");
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("两个子线程都执行完毕，继续执行主线程");
    }
}

输出：

主线程开始执行…… ……
等待两个线程执行完毕…… ……
子线程：pool-1-thread-1执行
子线程：pool-2-thread-1执行
两个子线程都执行完毕，继续执行主线程

Semaphore 也是一个线程同步的辅助类，可以维护当前访问自身的线程个数，并提供了同步机制。使用Semaphore可以控制同时访问资源的线程个数.

void acquire():从此信号量获取一个许可，在提供一个许可前一直将线程阻塞，否则线程被中断。
示例：

public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();

        //信号量，只允许 3个线程同时访问
        Semaphore semaphore = new Semaphore(3);

        for (int i = 0; i < 10; i++) {
            final long num = i;
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        //获取许可
                        semaphore.acquire();
                        //执行
                        System.out.println("Accessing: " + num);
                        Thread.sleep(new Random().nextInt(5000)); // 模拟随机执行时长
                        //释放
                        semaphore.release();
                        System.out.println("Release..." + num);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }

        executorService.shutdown();
    }

4、如何看JVM中的信息

使用 jps 和 jstack命令