前言 ：
假设有一个很大的任务。这个任务可以分成 a 、 b 、 c三个步骤同时进行，
在同时进行的情况下，如果有一个任务被取消掉了或者遇到错误了，然后所有的都应该结束，要求高效完成，主要是高效。
严格来讲这是一个分布式事务的问题，也就是说有一个事务，此事务的某一段放到a级上去执行，其余两段分别放到b和c，其中有一个半截单子的子事务没有完成，那整个事务取消掉。
面试题：
关于线程同步的面试题，凡是从时间角度或者是优先级角度考虑解决思路的，基本全不对！凡是从join sleep考虑的，99.99%的不对，线程优雅的结束，一般不用interrupt stop resume，不得已再使用interrupt。
经典面试题：synchronized和ReentrantLock的区别是什么？
答案：ReentrantLock可以多个队列，synchronized只有一个队列，ReentrantLock可以做公平锁，synchronized只有非公平(没有公平可言)，ReentrantLock还可以tryLock尝试上锁，上不了锁可以去做别的(做出一定的处理)，但是synchronized只能上来就死等傻傻等待，等不到就死在那，第四个区别：锁可以被打断，就是我在锁的过程中我可以让别人打断我，打折我的腿我就醒了这个叫lock.incorruptibly可以做这个操作就是entry.lock,但是synchronized不可以，因为synchronized不能打断，除非把整个线程给砍掉。
面试题：【面试过程中现场实现】
提示：以下是本篇文章正文内容，下面案例可供参考
举例：张三李四一行人现在要吃火锅要有很多步骤
- 张三要去用锅烧开水
- 李四要准备买菜洗菜
- 路人王要去请王二来一起吃
假设现在张三去起锅烧水，李四去买菜了，路人王要去请王二来一起吃。
然后其中路人王在去请王二的路上遇到了pk无法去请王二来吃火锅，这个时候应该考虑什么，整个任务全取消，即便是张三在烧水，李四在买菜也取消，停掉。
示例方案一（存在问题）：
可以翻看下面的几个案例有一个循序渐进的过程。
package com.aaa.blbl_Test2;
import java.io.IOException;
public class T0_F1 {
public static void main(String[] args) {
/*假设我们有三个任务，t1、t2、t3，然后假设每一个任务正常执行完结束之后,分别应该是3秒钟、
1秒钟、五秒钟，当然为了模拟这个任务t1、t2的两个任务都能正常执行完，所以后面传true的意思是说
让它正常执行完，穿false的意思是说，让它执行到一秒的时候报个错
因为是模拟任务，所以在这里直接给了线程的执行时间,1000毫秒=1秒*/
Thread t1 = new MyTask("t1",3000,true);
Thread t2 = new MyTask("t2",1000,false);
Thread t3 = new MyTask("t3",5000,true);
//演示回滚过程
t1.start();
t2.start();
t3.start();
try {
System.in.read();
} catch (IOException e) {
e.printStackTrace();
}
}
private static class MyTask extends Thread
{
private String name;//名字
private int timeInSeconds;//执行时间
private boolean success;//执行成功还是失败
public MyTask(String name, int timeInSeconds, boolean success) {
this.name = name;
this.timeInSeconds = timeInSeconds;
this.success = success;
}
@Override
public void run()
{
//模拟业务执行时间
//实际中时间不固定，可能在处理计算任务，或者是等待Io任务
try {
sleep(timeInSeconds);
System.out.println(name+"任务结束!");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
存在问题：因为程序正常的结束取决于你最长的这个时间段，比如t1执行时间是十秒sleep(10000)我们整个程序要想结束，别的线程就要等它十秒才能结束。
但是按照题目的要求一秒就应该结束，因为一秒钟有一个任务已经报错了，所以一秒就应该结束。
示例方案二：（小白玩法）
我们给每一个任务，给它指定一个执行的结果，注意看第二个版本的玩法，这里是分成一个一个版本来实现的，如果不分版本的话对于基础稍弱的很可能写不到最后的那个版本。
package com.aaa.blbl_Test2;
import java.util.ArrayList;
import java.util.List;
public class T0_F2 {
public static void main(String[] args) {
/*版本二玩法:
需要有某一个东西来告知这个线程是正常成功了
还是没成功他的状态还是说没结束呢？
所以在下面做了一个枚举类型，这个枚举类型主要，指带的每一个线程它的状态，
一共有三个状态。
第一个状态是NOTEND也就是说现在正在运行之中。
第二个状态：SUCCESSED代表正常运行结束。
第三个状态：FAILED代表运行失败。
这样做的需求，因为需要知道这个线程他执行失败了，需要知道他的状态。
如果执行失败了通知所有的线程结束。
实现步骤：
private static enum Result{
NOTEND,SUCCESSED,FAILED
}
*/
Thread t1 = new T0_F2.MyTask("t1",3000,true);
Thread t2 = new T0_F2.MyTask("t2",1000,false);
Thread t3 = new T0_F2.MyTask("t3",5000,true);
List<MyTask> tasks = new ArrayList<>();
tasks.add((MyTask) t1);
tasks.add((MyTask) t2);
tasks.add((MyTask) t3);
//启动线程
tasks.stream().forEach((t -> t.start()));
/*
接上面：实现步骤：首先把所有的线程全装到一个list里，然后让所有的线程启动，
启动完成之后，就启动一个监视程序也就是下面的for循环，一直不停的检测它。
*/
//启动监视
for (; ; ) {
for (MyTask task : tasks)
{
// 如果有某一个线程getResult()它的Result是FAILED的了整个线程失败、System.exit(0)整个程序结束。
if (task.getResult() == Result.FAILED)
{
System.exit(0);
}
}
}
}
private static enum Result{
NOTEND,SUCCESSED,FAILED
}
private static class MyTask extends Thread
{
private Result result = Result.NOTEND;
private String name;
private int timeInSeconds;
private boolean success;
public MyTask(String name, int timeInSeconds, boolean success) {
this.name = name;
this.timeInSeconds = timeInSeconds;
this.success = success;
}
public Result getResult() {
return result;
}
@Override
public void run()
{
//模拟业务执行时间
//实际中时间不固定，可能在处理计算任务，或者是等待Io任务
try {
sleep(timeInSeconds);
System.out.println(name+"任务结束!");
result = success ? Result.SUCCESSED : Result.FAILED;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
这个方法也是绝对不能够被允许的：
接上图它里面的for循环是一个盲等待，盲等待（就是一直不停循环代表不停的消耗cpu，
是效率上的降低，不能够被允许，第二点：System.exit(0)：粗暴的干掉一切线程，
假设路人王去请王二来吃火锅，一秒钟之后失败了，李四在买菜的路上遇到了修路，张三在烧水把锅踢飞，完全有可能是不一致的状态，打开了半截文件直接就退出了，这个文件还没有close,建立了一个链接对方还在等着我说话，这边还没说直接就close了，所以该方案也是存在问题的不能被允许）
示例方案三：（循序渐进）
示例：每一个线程在运行的时候，加一个最终的处理方法叫boss.end
package com.aaa.blbl_Test2;
/**
* 最原始的方法 Thread run()重写
*/
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
public class T0_F3 {
private static class Boss extends Thread{
private List<Worker> tasks = new ArrayList<>();
public void addTask(Worker t)
{
tasks.add(t);
}
@Override
public void run()
{
tasks.stream().forEach((t) -> t.start());
}
public void end(Worker worker)
{
if (worker.getResult()==Result.FAILED)
{
System.exit(0);
}
}
}
public static void main(String[] args) {
/*
Boss boss = new Boss();
boos是最大管理员，每一个Worker都拥有一个boos的引用，
如果某一个线程结束了，在boss.end(this)处理方法如果该线程Result.FAILED
那么就整个退出 System.exit(0),这样解决了盲等待的问题。
*/
Boss boss = new Boss();
Worker t1 = new Worker(boss,"t1",3000,true);
Worker t2 = new Worker(boss,"t2",1000,false);
Worker t3 = new Worker(boss,"t3",5000,true);
boss.addTask(t1);
boss.addTask(t2);
boss.addTask(t3);
//启动线程
boss.start();
try {
System.in.read();
} catch (IOException e) {
e.printStackTrace();
}
}
private static enum Result{
NOTEND,SUCCESSED,FAILED
}
private static class Worker extends Thread
{
private Result result = Result.NOTEND;
private Boss boss;
private String name;
private int timeInSeconds;
private boolean success;
public Worker(Boss boss, String name, int timeInSeconds, boolean success) {
this.boss = boss;
this.name = name;
this.timeInSeconds = timeInSeconds;
this.success = success;
}
public Result getResult() {
return result;
}
@Override
public void run()
{
//模拟业务执行时间
//实际中时间不固定，可能在处理计算任务，或者是Io任务
try {
sleep(timeInSeconds);
System.out.println(name+"任务结束！");
result = success ? Result.SUCCESSED : Result.FAILED;
boss.end(this);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
最终方案：
书写回滚，回滚这个事件就是每种是每种不同的方式，就是每一个线程有每一个线程不同的回滚方式。
package com.aaa.blbl_Test2;
import java.util.ArrayList;
import java.util.List;
/**
* 最原始的方法 Thread run()重写
*/
public class F0_F4 {
private static class Boss extends Thread{
private List<Worker> tasks = new ArrayList<>();
public void addTask(Worker t)
{
tasks.add(t);
}
@Override
public void run()
{
tasks.stream().forEach((t) -> t.start());
}
public void end(Worker worker)
{
//当某一个线程结束了，并不是把其他线程的腿打断
//而是要让它取消cancel
if (worker.getResult() == Result.FAILED)
{
cancel(worker);
}
}
private void cancel(Worker worker)
{
for (Worker w : tasks)
{
if (w != worker) w.cancel();
}
}
}
public static void main(String[] args) {
Boss boss = new Boss();
Worker t1 = new Worker(boss,"A===",3,true);
Worker t2 = new Worker(boss,"B===",1,false);
Worker t3 = new Worker(boss,"C===",5,true);
boss.addTask(t1);
boss.addTask(t2);
boss.addTask(t3);
//启动线程
boss.start();
try {
System.in.read();
} catch (Exception e) {
e.printStackTrace();
}
}
private static enum Result{
NOTSET,SUCCESSED,FAILED,CANCELLED
}
private static class Worker extends Thread
{
private Result result = Result.NOTSET;
private Boss boss;
private String name;
private int timeInSeconds;
private boolean success;
private volatile boolean cancelling = false;
public Worker(Boss boss, String name, int timeInSeconds, boolean success) {
this.boss = boss;
this.name = name;
this.timeInSeconds = timeInSeconds;
this.success = success;
}
public Result getResult() {
return result;
}
@Override
public void run()
{
int interval = 100;
int total = 0;
for ( ; ; )
{
try {
sleep(interval);//cpu密集型
total += interval;
if (total / 1000 >= timeInSeconds)
{
// System.out.println(total+"$$$$");
// System.out.println(timeInSeconds);
System.out.println(name+"任务结束！"+result);//正常结束
result = success ? Result.SUCCESSED : Result.FAILED;
System.out.println("的撒大");
break;
}
if (cancelling)
{
rollback();
result = Result.CANCELLED;
cancelling = false;
System.out.println(name="执行完毕！"+result);
break;
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
boss.end(this);
}
private void rollback()
{
try {
//书写回滚
System.out.println(name+"rollback start....");
/* rollback事务回滚，不同的事务是不同的回滚
举例：所有事件整体是一个大事务，它要求第一个事务是关于数据库的
那么插入五条数据就要(cancel)删除五条数据、假设第二个事务是关于文件拷贝
文件拷贝完之后就要进行删除、第三个是关于MQ里面往里面发消息的
假设发进去几条消息，然后在发几条取消掉的消息这叫rollback
如果在rollback过程中出错，假设插入五条数据删到三条的时候出错了
举例：发出总任务的这个人一定有一个最大等待时间，
假如你在特定的时间内没有完成，那就说明任务失败，那其中有一个子任务，
那这个子任务，如果中间rollback失败了，那就是一定抛出异常了
这个时候一定要记录日志，发告警必须人工处理了，那上面的数据的那个来说删不掉了
说明里面有脏数据了，可能不是删除可能是修改，这时候必须人工处理了，把运维程序员从睡梦中叫醒来处理
*/
sleep(500);
System.out.println(name+"rollback end!");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void cancel() {
cancelling = true;//设立标志位
}
}
}
先进处理方案：
package com.aaa.blbl_Test2;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
/**
* 问题：可以归分为分布式事务失败回滚的手工实现
* 代码不完善，可扩展
*/
public class F0_F5 {
//任务执行结束的三种状态
private static enum Result
{
SUCCESS,FAIL,CANCELLED
}
static List<MyTask> tasks = new ArrayList<>();
public static void main(String[] args) {
MyTask task1 = new MyTask("task1===",3,Result.SUCCESS);
MyTask task2 = new MyTask("task2===",5,Result.SUCCESS);
MyTask task3 = new MyTask("task3===",1,Result.FAIL);
tasks.add(task1);
tasks.add(task2);
tasks.add(task3);
for (MyTask task : tasks)
{
/*可以使用线程的CompletableFuture可以使用异步任务这个线程池CompletableFuture.supplyAsync
使用纯异步的方式去调用第一个任务，第一个任务如果有了结果之后，
用callback处理结果。
*/
CompletableFuture f = CompletableFuture.supplyAsync(() -> task.runTask())
.thenAccept((result -> callback(result,task)));
}
try {
TimeUnit.SECONDS.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
private static Result callback(Result result,MyTask task)
{
//在处理结果的时候，判断结果如果是FAIL那么让所有的任务全部cancel
if (Result.FAIL == result)
{
for (MyTask ts : tasks )
{
if (ts!=task)
{
ts.cancel();
}
}
}
return result;
}
private static class MyTask
{
private String name;
private int timeInSeconds;
private Result ret;
boolean cancelling = false;
volatile boolean cancelled = false;
public MyTask(String name, int timeInSeconds, Result ret) {
this.name = name;
this.timeInSeconds = timeInSeconds * 1000 ;
this.ret = ret;
}
public Result runTask()
{
int interval = 100;
int total = 0;
try {
for (; ;)
{
Thread.sleep(interval);
if (cancelling) continue;
total += interval;
if (total >= timeInSeconds)break;
if (cancelled) return Result.CANCELLED;
}
}catch (Exception e)
{
e.printStackTrace();
}
System.out.println(name+"end!");
return ret;
}
//任务cancel过程synchronized (this)
public void cancel()
{
cancelling = true;
//不上锁的话关系也不大
synchronized (this)
{
System.out.println(name+"cancelling");
try {
//然后让它去任务结束
Thread.sleep(50);
System.out.println(name+"cancelled");
} catch (InterruptedException e) {
e.printStackTrace();
}
//最后cancel
cancelled = true;
}
}
}
}
总结
以上就是今天要讲的内容，以上代码还有可扩展性，当然“笔者还深度欠缺，如果错误还请指正”。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
