问出这个问题，说明你对promise的使用还并不清楚。

说白了，你就是想要实现若干个互相之间不会相互干扰的操作链，不要用一个大步这样的描述，你首先就把自己给绕晕了。
每个操作后续都有N个操作，每个操作之间相互独立，每个操作完成立即执行它自己的后续。

单一的顺序操作链是这样的：

start()
    .then()
    .then()
    .then()

在promise的操作中，每一步都必须要要返回一个新的promise，为什么要这样做？想明白这个问题，你就知道怎么做了。

理论上每个promise都可以链接无数个后续动作，想要链接多个动作，这么写就行了：

start = new Promise(/*code*/);
move1 = start.then(/*code*/);
move2 = start.then(/*code*/);

move11 = move1.then(/*code*/);
move12 = move1.then(/*code*/);

move21 = move2.then(/*code*/);
move22 = move2.then(/*code*/);

start后面接了move1和move2
move1后面接了move11和move12
move2后面接了move21和move22

写段简单的代码：

function delay(time, value) {
    return(new Promise(function executor(resolve) {
        setTimeout(function asyn() {
            console.log(value);
            resolve();
        }, time);
    }));
}
function log1(value) {
    return function handler() {
        return delay(3000, value)
    };
}
function log2(value) {
    return function handler() {
        return delay(1000, value)
    };
}
let start = log2("start:")(),
    move1 = start.then(log1('Step 1;')),
    move2 = start.then(log2('Step 2;')),
    move11 = move1.then(log1('Step 1.1;')),
    move12 = move1.then(log1('Step 1.2;')),
    move21 = move2.then(log2('Step 2.1;')),
    move22 = move2.then(log2('Step 2.2;'));

Promise.all() 并发执行

这应该是一个单子变换的问题。

我很好奇，什么样的应用场景需要并发这么多ajax请求？

可以先将ajax转换成promise的方式,然后分步调用.

var ajax_1_1 = promise,
    ajax_2_1 = promise,
    ...
    ajax_n_1 = promsie;
 
var AJAX_1 = ajax_1_1.then( return ajax_1_2 ).then( return ajax_1_3 )....then( return ajax_1_n ),
    AJAX_2 = ajax_2_1.then( return ajax_2_2 ).then( return ajax_2_3 )....then( return ajax_2_n ),
    ...
    AJAX_n = ajax_n_1.then( return ajax_n_2 ).then( return ajax_n_3 )....then( return ajax_n_n );
    
Promise.all([AJAX_1,AJAX_2,...,AJAX_n])
        .then(all promise done);

Promsie.all等所有的promise链完成调用之后才触发.

按你的意思第一大步并不依赖上一大步的所有结果,如果是这样,
试试看下面的模拟代码，可以到Console中直接运行

//模拟ajax请求,sp 只是为了区别现在是第几步用的
var ajax_test = function(v,sp){
    return new Promise(function(ok,no){
        setTimeout(function(){
            console.log(v + " -> " + sp + ' --ok')
            var str = v+"."+sp
            ok([str+'_1',str+'_2']);
        },Math.random()*1000)
    })
}

var ajax1_Promise = function(a){
    return ajax_test(a,1).then(function(arr){
        var p1 = ajax2_Promise(arr[0]);
        var p2 = ajax2_Promise(arr[1]);
        //每一步要裂变几个都可以
        return Promise.all([p1,p2])
    })
}
var ajax2_Promise = function(a){
    return ajax_test(a,2).then(function(arr){
        var p1 = ajax3_Promise(arr[0]);
        var p2 = ajax3_Promise(arr[1]);
        return Promise.all([p1,p2])
    })
}
var ajax3_Promise = function(a){
    //假设第三步最后一步
    return ajax_test(a,3)
}

var arr = ["A","B"]
var arr_p = [];
arr.forEach(function(v){
    arr_p.push(ajax1_Promise(v))
})

Promise.all(arr_p).then(function(d){
    console.log(d);
    console.log("all ok")
})

结果类似这样

B -> 1 --ok
A -> 1 --ok
A.1_2 -> 2 --ok
A.1_2.2_1 -> 3 --ok
A.1_1 -> 2 --ok
A.1_1.2_2 -> 3 --ok
A.1_2.2_2 -> 3 --ok
B.1_2 -> 2 --ok
B.1_1 -> 2 --ok
B.1_2.2_1 -> 3 --ok
A.1_1.2_1 -> 3 --ok
B.1_2.2_2 -> 3 --ok
B.1_1.2_1 -> 3 --ok
B.1_1.2_2 -> 3 --ok
[Array[2], Array[2]]
all ok