关于思维:借助产品思维解决人生难题含实践方法论分析工具

download：借助产品思维解决人生难题（含实际方法论 + 剖析工具）

在 java 中应用中断来告诉线程进行
失常进行螺纹
公共类 RightWayStopThreadWithoutSleep 实现 Runnable {

@笼罩
公共有效运行 (){
int num = 0；
而(！Thread.currentThread()。isInterrupted() && num
if (num % 10000 == 0) {
System.out.println(num+” 是 1W 的倍数 ”)；
}
num++；
}
System.out.println(“ 工作实现了！”);
}

公共动态 void main(String[] args)引发 InterruptedException {
Thread Thread = new Thread(new RightWayStopThreadWithoutSleep())；
thread . start()；
// 期待 1s
thread . sleep(1000)；
// 告诉进行线程
thread.interrupt()。
}
}
复制代码
应用 thread.interrupt()告诉线程进行。
然而线程须要合作:
应用 thread.currentthread()。isinterrupted () in while 来检测线程的以后状态。
运行后果:
……
……
21730000 是 1W 的倍数。
21740000 是 1W 的倍数。
21750000 是 1W 的倍数。
21760000 是 1W 的倍数。
21770000 是 1W 的倍数。
21780000 是 1W 的倍数。
21790000 是 1W 的倍数。
21800000 是 1W 的倍数。
工作实现了！

过程完结，退出代码为 0
复制代码
进行线程，以防它被阻塞。
公共类 RightWayStopThreadWithSleep {
公共动态 void main(String[] args)引发 InterruptedException {
runnable runnable =()–> {
int num = 0；
while(数字
if (num % 100 == 0) {
System.out.println(num+” 是 100 的倍数 ”)；
}
num++；
}
尝试{
// 期待 1 秒模仿阻塞。
thread . sleep(1000)；
} catch (InterruptedException e) {
System.out.println(“ 线程曾经进行！!”);
e . printstacktrace()；
}
};

Thread thread = 新线程 (runnable)；
thread . start()；
// 等待时间应小于下面设置的 1 秒，否则线程会在执行到下一个 thread.interrupt() 之前完结；明码
thread . sleep(500)；
// 告诉进行线程
thread.interrupt()。
}
}
复制代码
在线程休眠 1 秒的过程中，中断信号被中断，
在线程睡眠期间响应中断的形式是抛出 InterruptedException。
运行后果:
是 0 到 100 的倍数。
00 是 100 的倍数。
200 是 100 的倍数。
30 是 100 的倍数。
线程进行！！
中断异样: 睡眠中断
at java.lang.Thread.sleep(原生办法)
在进行线程处。rightwaystopthreadwithsleep . lambda＄main＄0(rightwaystopthreadwithsleep . Java:19)
位于 Java . lang . thread . run(thread . Java:748)

过程完结，退出代码为 0
复制代码
每次迭代后用阻塞来进行线程。
公共类 RightWayStopThreadWithSleepEveryLoop {
公共动态 void main(String[] args)引发 InterruptedException {
runnable runnable =()–> {
int num = 0；
尝试{
while(数字
if (num % 100 == 0) {
System.out.println(num+” 是 100 的倍数 ”)；
}
num++；
// 每个循环期待 10ms 以模仿阻塞
Thread.sleep(十)；
}
} catch (InterruptedException e) {
e . printstacktrace()；
}
};

Thread thread = 新线程 (runnable)；
thread . start()；
// 5 秒后告诉进行线程
thread . sleep(5000)；
thread.interrupt()。
}
}
复制代码
当每次迭代都会阻塞线程一段时间，判断 while/for 循环条件时，
不须要应用 thread.currentthread()。is interrupted () 确定线程是否中断。
运行后果:
是 0 到 100 的倍数。
00 是 100 的倍数。
200 是 100 的倍数。
30 是 100 的倍数。
40 是 100 的倍数。
中断异样: 睡眠中断
复制代码
如果将下面代码中的 try/catch 放在 while 循环中
公共类 RightWayStopThreadWithSleepEveryLoop {
公共动态 void main(String[] args)引发 InterruptedException {
runnable runnable =()–> {
int num = 0；
while(数字
if (num % 100 == 0) {
System.out.println(num+” 是 100 的倍数 ”)；
}
num++；
尝试{
// 每个循环期待 10ms 以模仿阻塞
Thread.sleep(十)；
} catch (InterruptedException e) {
e . printstacktrace()；
}
}
};

Thread thread = 新线程 (runnable)；
thread . start()；
// 5 秒后告诉进行线程
thread . sleep(5000)；
thread.interrupt()。
}
}
复制代码
运行后果:
是 0 到 100 的倍数。
00 是 100 的倍数。
200 是 100 的倍数。
30 是 100 的倍数。
40 是 100 的倍数。
中断异样: 睡眠中断
at java.lang.Thread.sleep(原生办法)
在进行线程处。rightwaystopthreadwithsleepeveryloop . lambda＄main＄0(rightwaystopthreadwithsleepeveryloop . Java:18)
位于 Java . lang . thread . run(thread . Java:748)
50 是 100 的倍数。
60 是 100 的倍数。
70 是 100 的倍数。
……
……

复制代码
将会发现，只管抛出了异样，程序并没有进行，而是持续输入，
即便加上了 while 条件判断！线程。以后线程 ()。是中断() 条件，还是不能进行程序！
因为
Java 在设计 sleep() 函数时就有这样的想法:
当它响应一个中断时，它将革除中断标记。
也就是说，线程尽管在睡眠时收到了中断告诉，但也捕捉到了异样，并打印出了异样信息。
然而，因为睡眠的设计理念，线程。currentthread()。is interrupted()标记将被革除，
这就是程序不能退出的起因。
如果要在这里进行线程，只须要在 catch 中再次调用 interrupt()即可；办法
尝试 {
// 每个循环期待 10ms 以模仿阻塞
Thread.sleep(十)；
} catch (InterruptedException e) {
e . printstacktrace()；
Thread.currentThread()。中断()；
}
复制代码
所以，不要认为调用 interrupt()办法线程就肯定会进行。
进行线程的两种最佳办法
1. 捕捉 InterruptedException 后的首选项: 在办法签名中引发异样。
公共类 RightWayStopThreadInProd 实现 Runnable {

公共动态 void main(String[] args)引发 InterruptedException {
Thread Thread = new Thread(new RightWayStopThreadInProd())；
thread . start()；
thread . sleep(1000)；
thread.interrupt()。
}

@笼罩
公共有效运行 (){
while (true) {
System.out.println(“go … “);
尝试{
throwin method()；
} catch (InterruptedException e) {
// 捕获异样，保留日志，进行程序等。
system . out . println(” stop “)；
e . printstacktrace()；
}
}
}

/**
* 如果你想在一个办法中抛出一个异样，最好是抛出去，让顶层调用者来解决，而不是 try/catch。
* 以便调用者能够捕获异样并执行其余操作。

• @throws 中断异样
  */
  公有 void throwInMethod()引发 InterruptedException {
  线程. 睡眠 (2000 年)；
  }
  }
  复制代码
  如果你想在一个办法中抛出一个异样，最好抛出这个异样，让顶层调用者解决它，而不是 try/catch。
  通过这种形式，调用者能够捕捉异样并采取其余操作。
  2. 调用 thread.currentthread()。catch 中的中断 ()；复原设置中断状态。
  公共类 RightWayStopThreadInProd2 实现 Runnable {

公共动态 void main(String[] args)引发 InterruptedException {
Thread Thread = new Thread(new rightwaystopthreadinprod 2())；
thread . start()；
thread . sleep(1000)；
thread.interrupt()。
}

@笼罩
公共有效运行 (){
while (true) {
if (Thread.currentThread()。isInterrupted()) {
System.out.println(“ 程序运行完结 ”)；
突破；
}
reInterrupt()；
}
}

公有 void reInterrupt() {
尝试 {
线程. 睡眠 (2000 年)；
} catch (InterruptedException e) {
Thread.currentThread()。中断()；
e . printstacktrace()；
}
}
}
复制代码
if (thread.currentthread()。is interrupted()) 这里的判断是你的代码要有响应中断的能力。

摘要
调用中断办法不肯定会中断线程。
告诉线程进行，线程不会立刻进行，而是会在适当的时候进行。
代码应该可能响应中断。