BFS广度优先算法
1、任务调度依赖
什么是任务依赖？比如 “任务 a” 执行的前提是 “任务 b” 先执行完成，“任务b” 又依赖于 “任务 c” 先执行，那么就形成如下依赖关系。
这个还比较简单，如果复杂点的如下图所示，形成一个工作流，Azkaban 大数据调度器就实现了工作流模式调度依赖，这是一个典型的图应用案例。
2、图数据结构
提到图数据结构，大部分人既熟悉又陌生，因为大学基本都学过，但一般工作场景都不会用到，这里就先简单回顾一下图相关的知识。
图 graph ，图中的元素称为顶点 vertex。图中任一顶点可以与其他顶点建立连线关系，叫做边 edge。
上面图叫 “无向图”，如果边有 “方向” ，那么就是 “有向图” 了。
无向图中，顶点有几条边就叫几度；有向图中，顶点有入度，表示有多少边指向此顶点，顶点的出度表示该顶点有多少边指向 “远方” 。
上图中 a 指向 b，b 指向 d，d 又指向 a， a、b、d 之间形成一个环，如果将顶点比作调度的任务，那么任务 a 完成必须依赖任务 b，任务 b 又依赖任务 d，任务 d 又依赖任务 a，那么最终肯定无法完成，因此调度问题使用的是有向无环图 （DAG），比如我们最早那张图。
了解了图的基本概念，那么图结构如何用代码表示出来？这里涉及到图的两种存储方式：邻接矩阵、邻接表。
邻接矩阵底层为二维数据，如果有一条边顶点为 x 和 y，对无向图来说，对应的数据 Array[x][y] 和 Array[y][x] 标记为 1；对有向图 x->y ，只将 Array[x][y] 标记为 1 即可，下图为使用邻接矩阵表示的无向图和有向图。
对于无向图来说，邻接矩阵沿着红色对角线两边是对称的，如果图的顶点连线比较少，这种叫稀疏图，将存储大量的 0 ，浪费存储空间，这时候可以选择使用邻接表表示，相对稀疏图的叫稠密图，使用邻接矩阵可以更好地查询连通性，其原理也是用空间换时间。下图为使用邻接表表示的无向图和有向图。
最后说下图的遍历，和遍历树一样分为广度优先 BFS 和 深度优先 DFS，但图如果存在成环的情况，访问的节点要做记录，同时可用辅助队列存放待访问的邻接节点。
拓扑排序，对有向无环图的顶点进行遍历，将所有顶点形成一个线性序列，可以用数组（切片）或链表存储，如下图。
3、java 代码实现
回顾了图的相关知识，那么回到最开始的任务依赖工作流中，将每个任务看成图的顶点，任务 a 依赖 任务 b，使用一条有向线从 a 指向 b，最后将所有任务顶点连线形成一个图，这个图是一个有向无环图 DAG，对 DAG 进行拓扑排序，形成一个任务执行链表，反向执行即可解决依赖问题。
首先定义一个图结构体，这里使用邻接矩阵方式存储，图的顶点结构体存储 Key 和 Value 代表任务的相关执行信息。
@Data
public class Vertex implements Serializable {
private static final long serialVersionUID = 4543479112604840512L;
public Vertex(String key, String value) {
this.key = key;
this.value = value;
this.parents = new ArrayList<>();
this.children = new ArrayList<>();
}
/** 键 */
private String key;
/** 值 */
private String value;
private List<Vertex> parents;
private List<Vertex> children;
}
@Data
public class Dag implements Serializable {
private static final long serialVersionUID = -1469367483670741447L;
private List<Vertex> vertexs;
public Dag() {
this.vertexs = new ArrayList<>();
}
public void addVertex(Vertex vertexDTO){
vertexs.add(vertexDTO);
}
// 为图添加顶点和添加边，这里是有向图，from 代表边的起始顶点， to 代表边的终止顶点。
public void addEdge(Vertex from, Vertex to){
from.getChildren().add(to);
to.getParents().add(from);
}
}
建立 a - i 所有顶点，再对每个顶点连线。
public static Dag getDag(){
Dag dag = new Dag();
Vertex va = new Vertex("a","1");
Vertex vb = new Vertex("b","2");
Vertex vc = new Vertex("c","3");
Vertex vd = new Vertex("d","4");
Vertex ve = new Vertex("e","5");
Vertex vf = new Vertex("f","6");
Vertex vg = new Vertex("g","7");
Vertex vh = new Vertex("h","8");
Vertex vi = new Vertex("i","9");
// 设置顶点
dag.addVertex(va);
// 增加边
dag.addEdge(va,vb);
dag.addEdge(va,vc);
dag.addEdge(va,vd);
dag.addEdge(vb,ve);
dag.addEdge(vb,vh);
dag.addEdge(vb,vf);
dag.addEdge(vc,vf);
dag.addEdge(vc,vg);
dag.addEdge(vd,vg);
dag.addEdge(vh,vi);
dag.addEdge(ve,vi);
dag.addEdge(vf,vi);
dag.addEdge(vg,vi);
return dag;
}
对该图进行广度优先遍历，通过引入队列来减少时间复杂度，遍历后生成一个包含所有顶点的 slice 。
-
选择起始节点入队列
-
节点出队列
2.1 队列空了，说明遍历完毕返回
2.2 已访问跳过，未访问顶点放入输出 slice 中
2.3 将节点的所有未访问邻接节点 Children 放入队列
-
重复执行 2
注意 slice 加入顺序，因为执行要从 i 到 a 的顺序，所以将每次遍历后的元素放到 slice 第一个位置。
/**
* 广度遍历
* @param root
* @return
*/
public static List<Vertex> BFS(List<Vertex> root){
List<Vertex> all = new ArrayList<>();
Queue<Vertex> queue = new LinkedList<Vertex>();
for (Vertex vertex : root) {
queue.add(vertex);
}
Map<String, Vertex> visited = new HashMap<>();
while(queue.size()>0){
int size = queue.size();
for (int i = 0; i < size; i++) {
//pop vertex
Vertex currVert = queue.poll();
if(visited.get(currVert.getKey())!=null){
continue;
}
visited.put(currVert.getKey(),currVert);
all.add(currVert);
for (Vertex child : currVert.getChildren()) {
if(visited.get(child.getKey()) == null){
queue.add(child);
}
}
}
}
return all;
}
最后就是对所有任务进行执行，这里假定每个任务执行需要 1 秒，然后输出执行结果。
public static void doTasks(List<Vertex> vertexDTOList){
for (Vertex vertexDTO : vertexDTOList) {
try {
Thread.sleep(1000);
System.out.println("key:"+vertexDTO.getKey()+",value:"+vertexDTO.getValue());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
通过执行测试用例，可以看到执行按上述生成的 slice 顺序，从左向右逐个执行，满足任务依赖关系
但这里有个问题就是执行时间过长，因为每一个都是串行执行，9 个任务要执行 45 秒。那么并行不就解决了？但任务有依赖关系又如何并行呢？
通过这个图即可一目了然明白了，分层执行，上层任务依赖下层，但每一层的任务相互独立可以并发执行。
首先在 BFS 遍历生成顶点的时候，需要生成双层切片：
/**
* 广度遍历
* @param root
* @return
*/
public static Map<String, List<Vertex>> BFSNew(List<Vertex> root){
Map<String, List<Vertex>> all = new HashMap<>();
Queue<Vertex> queue = new LinkedList<Vertex>();
for (Vertex vertex : root) {
queue.add(vertex);
}
Map<String, Vertex> visited = new HashMap<>();
int num = 0;
while(queue.size()>0){
num++;
List<Vertex> tmp = new ArrayList<>();
int size = queue.size();
for (int i = 0; i < size; i++) {
//pop vertex
Vertex currVert = queue.poll();
if(visited.get(currVert.getKey())!=null){
continue;
}
visited.put(currVert.getKey(),currVert);
tmp.add(currVert);
for (Vertex child : currVert.getChildren()) {
if(visited.get(child.getKey()) == null){
queue.add(child);
}
}
}
all.put(String.valueOf(num),tmp);
}
return all;
}
同时执行时候按每一层并发执行。这里通过 sync.WaitGroup 保障并发同步等待。
public static void main(String[] args) {
Dag dag = getDag();
long start = System.currentTimeMillis();
Map<String, List<Vertex>> stringListMap = BFSNew(dag.getVertexs());
stringListMap.forEach((key,value)->{
doTasksNew(value);
});
end = System.currentTimeMillis();
System.out.println(end-start);
}
// 并发执行
public static void doTasksNew(List<Vertex> vertexDTOList){
Vector<Thread> threadVector = new Vector<Thread>();
for (Vertex vertexDTO : vertexDTOList) {
Thread t = new Thread(() -> {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("key:"+vertexDTO.getKey()+",value:"+vertexDTO.getValue());
});
threadVector.add(t);
t.start();
}
System.out.println("--------------------------------");
for (Thread thread : threadVector) {
try {
thread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
通过并发改造后，执行时间只有 4 秒了，大大提高了任务执行的效率。
精简 获取顶部没有入度的点
@Data
public class Dag2 implements Serializable {
private static final long serialVersionUID = 3247378463655231751L;
private Map<String, Vertex> map;
public Dag2() {
this.map = new HashMap<>();
}
public void addEdge(String from, String to){
Vertex vFrom= map.get(from)!=null?map.get(from):new Vertex(from,from);
Vertex vTo = map.get(to)!=null?map.get(to):new Vertex(to,to);
vFrom.getChildren().add(vTo);
vTo.getParents().add(vFrom);
map.put(from,vFrom);
map.put(to,vTo);
}
public List<Vertex> getRoot(){
List<Vertex> result = new ArrayList<>();
this.map.forEach((k,v)->{
if(v.getParents().size()==0){
result.add(v);
}
});
return result;
}
}
public static Dag2 getDag2(){
Dag2 dag = new Dag2();
dag.addEdge("a","b");
dag.addEdge("a","c");
dag.addEdge("a","d");
dag.addEdge("b","e");
dag.addEdge("b","h");
dag.addEdge("b","f");
dag.addEdge("c","f");
dag.addEdge("c","g");
dag.addEdge("d","g");
dag.addEdge("h","i");
dag.addEdge("e","i");
dag.addEdge("f","i");
dag.addEdge("g","i");
return dag;
}
625
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
