Xxl-job 是目前比较主流的轻量级定时任务框架，该框架以相对简单的使用方式，灵活的配置，和可读性强的源码 等优势，深得广大开发者的喜欢。让我们的定时任务实现起来变得简单。具体的使用方法这里就不介绍了，想了解的可以直接访问官网：分布式任务调度平台XXL-JOB
 
今天我们主要解决一下使用xxl-job中的一个痛点，就是动态创建任务。使用过xxl-job的朋友们都知道，xxl-job给我们提供一个管理后台，我们可以在管理后台上，配置执行器，配置任务，管理任务。如下图。
 
这种方式使用起来虽然方便，可以有时候，我们就是需要在代码中动态创建一个定时任务，而不是到页面上进行配置，这个时候该怎么办呢？方式就是动态的扩展源码中提供的api。 这里着重强调一下，截止至当前，xxl-job的最新版本是2.2.0，这个版本中已经提供了一些开放的Rest Api供我们调用，不过只有心跳检测，忙碌检测，触发任务，终止任务，查看执行日志，等接口，如果你的需求是上述的这几个功能，完全可以使用开放的api进行扩展。但是这几个接口是不包含动态创建修改的。
 
 
 
好了，接下来回归正题，如果想动态创建任务该怎么办呢？目前的方式是只能通过调用xxl-job中的新增修改等接口完成。我们可以去github上把xxl-job的源码下载下来，其实我们正常部署xxl-job服务也是这个过程，在源码中主要有两个模块，一个是admin,一个是core, admin就是我们部署的服务，是一个springboot项目。
 
 
 
在admin项目中，有一个JobInfoController, 这个类就是处理各种新增任务，修改任务，触发任务的Controller, 
 
 
 
但是有个问题就是，这些接口都是后台使用的，要想调用，就必须得登录才行，不登录是没有办法访问的。那怎么办？难道还要模拟登录一次，其实大可不必，因为xxl-job中已经为我们提供了一个口子，就是一个注解和一个拦截器，通过这个注解可以配置接口是否可以跳过登录进行访问。也就是我们可以把接口配置成跳过登录验证进行访问就可以了，这样我们就能不登录而进行请求 。这个注解就是 @PermissionLimit(limit = false)  ,默认是true,也就是需要做登录验证。
 
好了有了这个注解就好办了，但是这里要注意，我们最好不要直接把这个注解配置到刚才截图中的对任务的操作的方法上，因为这些方法都是通过后台调用的，也就是对于操作者这些接口是可见的，如果打开了他们的权限，其实对于接口是有威胁的。所以我们可以自己扩展几个接口，保留原接口不变。那么我们直接在JobInfoController中添加几个方法
 
 
/*------------------自定义方法----------------------  */
	@RequestMapping("/addJob")
	@ResponseBody
	@PermissionLimit(limit = false)
	public ReturnT<String> addJobInfo(@RequestBody XxlJobInfo jobInfo) {
		return xxlJobService.add(jobInfo);
	}

	@RequestMapping("/updateJob")
	@ResponseBody
	@PermissionLimit(limit = false)
	public ReturnT<String> updateJobCron(@RequestBody XxlJobInfo jobInfo) {
		return xxlJobService.updateCron(jobInfo);
	}

	@RequestMapping("/removeJob")
	@ResponseBody
	@PermissionLimit(limit = false)
	public ReturnT<String> removeJob(@RequestBody XxlJobInfo jobInfo) {
		return xxlJobService.remove(jobInfo.getId());
	}

	@RequestMapping("/pauseJob")
	@ResponseBody
	@PermissionLimit(limit = false)
	public ReturnT<String> pauseJob(@RequestBody XxlJobInfo jobInfo) {
		return xxlJobService.stop(jobInfo.getId());
	}

	@RequestMapping("/startJob")
	@ResponseBody
	@PermissionLimit(limit = false)
	public ReturnT<String> startJob(@RequestBody XxlJobInfo jobInfo) {
		return xxlJobService.start(jobInfo.getId());
	}

	@RequestMapping("/addAndStart")
	@ResponseBody
	@PermissionLimit(limit = false)
	public ReturnT<String> addAndStart(@RequestBody XxlJobInfo jobInfo) {
		ReturnT<String> result = xxlJobService.add(jobInfo);
		int id = Integer.valueOf(result.getContent());
		xxlJobService.start(id);
		return result;
	}
 
【新增】在  JobGroupController 中添加一个方法：获取groupId,
 
@RequestMapping("/getGroupId")
@ResponseBody
@PermissionLimit(limit = false)
public ReturnT<String> getGroupId(@RequestBody XxlJobGroup jobGroup) {
	XxlJobGroup group = xxlJobGroupDao.findByName(jobGroup.getAppname());
	return new ReturnT<String>(String.valueOf(group.getId()));
}
 
如果上面的findByName找不到，那就自己写一个，就是根据名字查询数据的一个方法：因为我忘了这个方法是自带的还是我自己加的。
 
<select id="findByName" parameterType="java.lang.String" resultMap="XxlJobGroup">
		SELECT <include refid="Base_Column_List" />
		FROM xxl_job_group AS t
		WHERE t.app_name = #{appName}
	</select>
 
 
然后重新打包部署。然后在我们的项目中直接访问刚刚加好的接口就可以了。 但是说实话这种方式确实也不是很安全，毕竟相当于如果被别人发现了这些接口都是可以无限制进行调用的，所以大家还是要谨慎使用，最好用的时候在内网中访问，同时开启xxl-job的accessToken.
 
还有一个问题，也说明一下，我们在新增任务的时候，其实是要给这个任务选择一个执行器，也就是有一个jobGroup字段需要设置，这个最好不要写死，我们可以按照上面的方式在扩展一个根据appname获取group表中id的接口，这样通过appname去获取到groupid，在设置到任务中，就更加灵活一下。好了这篇文章就先分享到这里了，有问题的话，欢迎大家留言。最后附一个xxl-job的调用工具类：
 
@Slf4j
@Component
public class XxlJobUtil {

    @Value("${xxl.job.admin.addresses}")
    private String adminAddresses;

    @Value("${xxl.job.executor.appname}")
    private String appname;

    private RestTemplate restTemplate = new RestTemplate();

    private static final String ADD_URL = "/jobinfo/addJob";
    private static final String UPDATE_URL = "/jobinfo/updateJob";
    private static final String REMOVE_URL = "/jobinfo/removeJob";
    private static final String PAUSE_URL = "/jobinfo/pauseJob";
    private static final String START_URL = "/jobinfo/startJob";
    private static final String ADD_START_URL = "/jobinfo/addAndStart";
    private static final String GET_GROUP_ID = "/jobgroup/getGroupId";


    public String add(XxlJobInfo jobInfo){
        // 查询对应groupId:
        Map<String,Object> param = new HashMap<>();
        param.put("appname", appname);
        String json = JSON.toJSONString(param);
        String result = doPost(adminAddresses + GET_GROUP_ID, json);

        JSONObject jsonObject = JSON.parseObject(result);
        String groupId = jsonObject.getString("content");
        jobInfo.setJobGroup(Integer.parseInt(groupId));
        String json2 = JSON.toJSONString(jobInfo);
        return doPost(adminAddresses + ADD_URL, json2);
    }

    public String update(int id, String cron){
        Map<String,Object> param = new HashMap<>();
        param.put("id", id);
        param.put("jobCron", cron);
        String json = JSON.toJSONString(param);
        return doPost(adminAddresses + UPDATE_URL, json);
    }

    public String remove(int id){
        Map<String,Object> param = new HashMap<>();
        param.put("id", id);
        String json = JSON.toJSONString(param);
        return doPost(adminAddresses + REMOVE_URL, json);
    }

    public String pause(int id){
        Map<String,Object> param = new HashMap<>();
        param.put("id", id);
        String json = JSON.toJSONString(param);
        return doPost(adminAddresses + PAUSE_URL, json);
    }

    public String start(int id){
        Map<String,Object> param = new HashMap<>();
        param.put("id", id);
        String json = JSON.toJSONString(param);
        return doPost(adminAddresses + START_URL, json);
    }

    public String addAndStart(XxlJobInfo jobInfo){
        Map<String,Object> param = new HashMap<>();
        param.put("appname", appname);
        String json = JSON.toJSONString(param);
        String result = doPost(adminAddresses + GET_GROUP_ID, json);

        JSONObject jsonObject = JSON.parseObject(result);
        String groupId = jsonObject.getString("content");
        jobInfo.setJobGroup(Integer.parseInt(groupId));
        String json2 = JSON.toJSONString(jobInfo);

        return doPost(adminAddresses + ADD_START_URL, json2);
    }

    public String doPost(String url, String json){
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        HttpEntity<String> entity = new HttpEntity<>(json ,headers);
        log.info(entity.toString());
        ResponseEntity<String> stringResponseEntity = restTemplate.postForEntity(url, entity, String.class);
        return stringResponseEntity.getBody().toString();
    }

}
 
 
 

1. 事件轮询（Event Loop） 
  
js实现异步的具体解决方案
什么叫轮询？
 
2. 宏任务和微任务 
  
概念
宏任务
微任务
例题 
    
EXP1: 在主线程上添加宏任务与微任务
EXP2: 在微任务中创建微任务
EXP3: 宏任务中创建微任务
EXP4：微任务队列中创建的宏任务
 
总结
 
 
 
 
这篇博文仅为个人理解，文章内提供一些更加权威的参考，如有片面及错误，欢迎指正
 
 
1. 事件轮询（Event Loop）
 
什么是 Event Loop？ - 阮一峰
 
事件轮询（Event Loop） - 《你不懂JS：异步与性能》
 
【推荐】详解JavaScript中的Event Loop（事件循环）机制
 
Javascript的宿主环境中共通的一个“线程”（一个“不那么微妙”的异步玩笑，不管怎样）是，他们都有一种机制：在每次调用JS引擎时，可以随着时间的推移执行你的程序的多个代码块儿，这称为“事件轮询（Event Loop）”。
 
换句话说，JS引擎对 时间 没有天生的感觉，反而是一个任意JS代码段的按需执行环境。是它周围的环境在不停地安排“事件”（JS代码的执行）。
 
js实现异步的具体解决方案
 
同步代码直接执行
异步函数到了指定时间再放到异步队列
同步执行完毕，异步队列轮询执行。
 
什么叫轮询？
 
精简版：当第一个异步函数执行完之后，再到异步队列监视。一直不断循环往复，所以叫事件轮询。
 
详细版：js引擎遇到一个异步事件后并不会一直等待其返回结果，而是会将这个事件挂起，继续执行执行栈中的其他任务。当一个异步事件返回结果后，js会将这个事件加入与当前执行栈不同的另一个队列，我们称之为事件队列。被放入事件队列不会立刻执行其回调，而是等待当前执行栈中的所有任务都执行完毕， 主线程处于闲置状态时，主线程会去查找事件队列是否有任务。如果有，那么主线程会从中取出排在第一位的事件，并把这个事件对应的回调放入执行栈中，然后执行其中的同步代码…，如此反复，这样就形成了一个无限的循环。这就是这个过程被称为“事件循环（Event Loop）”的原因。
 
事实上，事件轮询与宏任务和微任务密切相关。
 
2. 宏任务和微任务
 
概念
 
微任务、宏任务与Event-Loop
 
在一个事件循环中，异步事件返回结果后会被放到一个任务队列中。然而，根据这个异步事件的类型，这个事件实际上会被对应的宏任务队列或者微任务队列中去。并且在当前执行栈为空的时候，主线程会 查看微任务队列是否有事件存在。如果不存在，那么再去宏任务队列中取出一个事件并把对应的回到加入当前执行栈；如果存在，则会依次执行队列中事件对应的回调，直到微任务队列为空，然后去宏任务队列中取出最前面的一个事件，把对应的回调加入当前执行栈…如此反复，进入循环。
 
我们只需记住当当前执行栈执行完毕时会立刻先处理所有微任务队列中的事件，然后再去宏任务队列中取出一个事件。同一次事件循环中，微任务永远在宏任务之前执行。
 
在当前的微任务没有执行完成时，是不会执行下一个宏任务的。
 所以就有了那个经常在面试题、各种博客中的代码片段：
 
setTimeout(_ => console.log(4))

new Promise(resolve => {
  resolve()
  console.log(1)
}).then(_ => {
  console.log(3)
})

console.log(2)
 
setTimeout就是作为宏任务来存在的，而Promise.then则是具有代表性的微任务，上述代码的执行顺序就是按照序号来输出的。
 所有会进入的异步都是指的事件回调中的那部分代码
 也就是说new Promise在实例化的过程中所执行的代码都是同步进行的，而then中注册的回调才是异步执行的。
 在同步代码执行完成后才回去检查是否有异步任务完成，并执行对应的回调，而微任务又会在宏任务之前执行。
 所以就得到了上述的输出结论1、2、3、4。
 
+部分表示同步执行的代码
 
+setTimeout(_ => {
-  console.log(4)
+})

+new Promise(resolve => {
+  resolve()
+  console.log(1)
+}).then(_ => {
-  console.log(3)
+})

+console.log(2)
 
本来setTimeout已经先设置了定时器（相当于取号），然后在当前进程中又添加了一些Promise的处理（临时添加业务）。
 
所以进阶的，即便我们继续在Promise中实例化Promise，其输出依然会早于setTimeout的宏任务：如EXP2
 
宏任务
 
分类：
 
#
浏览器
Node
I/O
✅
✅
setTimeout
✅
✅
setInterval
✅
✅
setImmediate
❌
✅
requestAnimationFrame
✅
❌
特性：
 
 
宏任务所处的队列就是宏任务队列
 
 
第一个宏任务队列中只有一个任务：执行主线程上的JS代码；如果遇到上方表格中的异步任务，会创建出一个新的宏任务队列，存放这些异步函数执行完成后的回调函数。
 
 
宏任务队列可以有多个
 
 
宏任务中可以创建微任务，且如果该微任务立即被加入执行栈的话，会打断当前宏任务的执行。(EXP3)
 
 
当一个宏任务队列中的任务全部执行完后，会查看是否有微任务队列，如果有就会优先执行微任务队列中的所有任务，如果没有就查看是否有宏任务队列
 
 
微任务
 
分类：
 
#
浏览器
Node
process.nextTick
❌
✅
MutationObserver
✅
❌
Promise.then catch finally
✅
✅
特性：
 
 
微任务所处的队列就是微任务队列
 
 
在上一个宏任务队列执行完毕后，如果有微任务队列就会执行微任务队列中的所有任务
 
 
new promise((resolve)=>{ 这里的函数在当前队列直接执行 }).then( 这里的函数放在微任务队列中执行 )
 
 
微任务队列上创建的微任务，仍会阻碍后方将要执行的宏任务队列 (EXP2)
 
 
由微任务创建的宏任务，会被丢在异步宏任务队列中执行 (EXP4)
 
 
例题
 
EXP1: 在主线程上添加宏任务与微任务
 
执行顺序：主线程 => 主线程上创建的微任务 => 主线程上创建的宏任务
 
console.log('-------start--------');

setTimeout(() => {
  console.log('setTimeout');  // 将回调代码放入另一个宏任务队列
}, 0);

new Promise((resolve, reject) => {
  for (let i = 0; i < 5; i++) {
    console.log(i);
  }
  resolve()
}).then(()=>{
  console.log('Promise实例成功回调执行'); // 将回调代码放入微任务队列
})

console.log('-------end--------');
 
结果：
 
-------start--------
0
1
2
3
4
-------end--------
Promise实例成功回调执行
setTimeout
 
由EXP1，我们可以看出，当JS执行完主线程上的代码，会去检查在主线程上创建的微任务队列，执行完微任务队列之后才会执行宏任务队列上的代码
 
EXP2: 在微任务中创建微任务
 
执行顺序：主线程 => 主线程上创建的微任务1 => 微任务1上创建的微任务2 => 主线程上创建的宏任务
 
setTimeout(_ => console.log(4))

new Promise(resolve => {
  resolve()
  console.log(1)
}).then(_ => {
  console.log(3)
  Promise.resolve().then(_ => {
    console.log('before timeout')
  }).then(_ => {
    Promise.resolve().then(_ => {
      console.log('also before timeout')
    })
  })
})

console.log(2)
 
结果：
 
1
2
3
before timeout
also before timeout
4
 
由EXP1，我们可以看出，在微任务队列执行时创建的微任务，还是会排在主线程上创建出的宏任务之前执行
 
EXP3: 宏任务中创建微任务
 
宏任务队列中创建的微任务，会打断当前宏任务队列的执行。
 
执行顺序：主线程（宏任务队列 1）=> 宏任务队列 2.1 => 微任务队列 1（打断宏任务队列 2）=>宏任务队列 2.2 => 宏任务队列 3
 
// 宏任务队列 1
setTimeout(() => {
  // 宏任务队列 2.1
  console.log('timer_1');
  setTimeout(() => {
    // 宏任务队列 3
    console.log('timer_3')
  }, 0)
  new Promise(resolve => {
    resolve()
    console.log('new promise')
  }).then(() => {
    // 微任务队列 1
    console.log('promise then')
  })
}, 0)

setTimeout(() => {
  // 宏任务队列 2.2
  console.log('timer_2')
}, 0)

console.log('========== Sync queue ==========')
 
结果：
 
========== Sync queue ==========
timer_1
new promise
promise then
timer_2
timer_3
 
EXP4：微任务队列中创建的宏任务
 
执行顺序：主线程 => 主线程上创建的微任务 => 主线程上创建的宏任务 => 微任务中创建的宏任务
 
异步宏任务队列只有一个，当在微任务中创建一个宏任务之后，他会被追加到异步宏任务队列上（跟主线程创建的异步宏任务队列是同一个队列）
 
// 宏任务1
new Promise((resolve) => {
  console.log('new Promise(macro task 1)');
  resolve();
}).then(() => {
  // 微任务1
  console.log('micro task 1');
  setTimeout(() => {
    // 宏任务3
    console.log('macro task 3');
  }, 0)
})

setTimeout(() => {
  // 宏任务2
  console.log('macro task 2');
}, 1000)

console.log('========== Sync queue(macro task 1) ==========');
 
结果：
 
========== Sync queue(macro task 1) ==========
micro task 1
macro task 3
macro task 2
 
总结
 
微任务队列优先于宏任务队列执行，微任务队列上创建的宏任务会被后添加到当前宏任务队列的尾端，微任务队列中创建的微任务会被添加到微任务队列的尾端。只要微任务队列中还有任务，宏任务队列就只会等待微任务队列执行完毕后再执行。
 
最后上一张几乎涵盖基本情况的例图和例子
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-E9JbttZi-1622687528232)(https://ws1.sinaimg.cn/large/a71efaafly1g232hxfbhrj21350h9406.jpg)]
 
console.log('======== main task start ========');
new Promise(resolve => {
  console.log('create micro task 1');
  resolve();
}).then(() => {
  console.log('micro task 1 callback');
  setTimeout(() => {
    console.log('macro task 3 callback');
  }, 0);
})

console.log('create macro task 2');
setTimeout(() => {
  console.log('macro task 2 callback');
  new Promise(resolve => {
    console.log('create micro task 3');
    resolve();
  }).then(() => {
    console.log('micro task 3 callback');
  })
  console.log('create macro task 4');
  setTimeout(() => {
    console.log('macro task 4 callback');
  }, 0);
}, 0);

new Promise(resolve => {
  console.log('create micro task 2');
  resolve();
}).then(() => {
  console.log('micro task 2 callback');
})

console.log('======== main task end ========');
 
结果：
 
======== main task start ========
create micro task 1
create macro task 2
create micro task 2
======== main task end ========
micro task 1 callback
micro task 2 callback
macro task 2 callback
create micro task 3
create macro task 4
micro task 3 callback
macro task 3 callback
macro task 4 callback

一.协同任务规划的功能与结构
 
多无人机协同任务规划即是根据一组特定条件的约束，以实现某个准则函数的最优或次优为目标，将某项作战任务分解成一些子任务并分配给多无人机系统中的各个无人机分别去完成的过程。 通常多无人机任务规划可以分成两大部分：上层的任务分配(Task Assignment or Task Allocation)和下层的路径规划(Path Planning)
 
任务分配考虑各种约束条件，以总体任务有效达成为目标，将具体目标和行动任务分配给各机，而各机根据分配的任务再进行具体的作战路径规划。
 
而路径规划的功能是在满足如最大线性速度、最大转角速度、操作的安全性、时间和环境变量等自身或外部限制的前提下在一系列位置之间设计或生成路径。同时，多无人机协同任务规划系统本身又是整个多无人机协同控制系统的重要组成部分。
 
二.任务分配
 
按照无人机作战任务之间的相关联性，可归类为
 1.独立任务分配
 2.协同任务分配
 按照无人机作战任务所处环境可分为
 1.静态任务分配
 2.动态任务分配
 按照分配方法可分为
 1.集中式任务分配
 2.分布式任务分配
 3.分层式分布任务分配
 
协同任务分配
 
多无人机协同任务分配的目标是在考虑各种诸如任务执行顺序、时间、无人机自身物理条件等约束条件的前提下，以总体任务效率最优或次优为目标，离线地或实时地将具体目标和行动任务分配给各机。
 
三.建模
 
以集中式控制系统为基础进行任务分配最常用的模型有
 多旅行商问题（multiple traveling salesman problem,MTSP）模型[13]、
 车辆路径问题(Vehicle Routing,VRP)模型[14]、
 多机路径分配模型(mVRP)[19]、
 混合整数线性规划问题(Mixed-Integer Linear Programming ,MILP,)模型[15]、
 动态网络流优化（Dynamic Network Flow Optimization ,DNFO)模型[16]、
 多处理器资源分配问题模型(Multiple Processsors Resources Allocation ,CMTMP)模型[17]
 除了上述模型外，美国空军研究实验室在无人机任务分配研究中建立了
 带时间窗的不同能力约束车辆路径问题(CVRPTW,Capacitated Vehicle Routing Problem with Time Windows）
 
四.方法
 
1. 集中式任务分配方法
 
集中式控制系统就是编队中的无人机之间的通信、信号的传输和控制均由唯一的一个控制中心来进行。
 常用的模型有MTSP、VRP、MILP、DNFO、CMTAP。
 
1.1最优化方法
 
(1)穷举法，适用于离散且规模小的情况
 (2)整数规划法(Mixed-Integer Linear Programming,MIP)根据既定的目的和目标，通过建立目标函数和约束条件的方法对规模较小的任务分配问题进行解决的一种最优化方法矩阵作业法、单纯型法、匈牙利法、分支定界法等是比较常用的整数规划方法。
 (3)约束规划(Constaint Programming CP)方法由变量集和约束集两者组成，变量集内的所有变量都有自己对应的值域，且变量的取值也只能从其值域中选取，它是求解组合优化问题的一种通用方法。
 (4)图论方法是通过图示的方法把任务和接受任务的成员特征表述出来，同时在任务和系统成员之间用图论方法建立匹配，以此设计出合理可行的任务分配方案。网络流模型和偶图匹配模型是两种经典的图论任务分配模型。
 
1.2启发式算法
 
在能够接受的时间范围内求得局部最优解或满意解。
 (1)列表规划（List Scheduling，LS）方法的步骤是首先建立任务的优先权函数，求得任务的处理次序，然后按照求得的任务处理次序将任务分派给系统成员。最常见的列表规划方法有动态列表规划（Dynamic List Scheduling ，DLS）法、多维动态列表规划（Multi-Dimensional Dynamic List Scheduling,MDLS）方法、多优先级动态列表规划（Multi-Priority List Dynamic Scheduling ,MPLDS）等。
 (2)智能优化算法
 ①进化算法EA 遗传算法GA 遗传规划Genetic Programming-GP 进化规划Evolutionary Programming-GP等
 ②群智能算法 PSO ACO
 ③人工免疫、禁忌搜索、模拟退火。
 
2.分布式任务分配
 
分布式控制系统与集中式控制系统不同的是实现信号传输的方式，前者无人机还可以在编队内进行通信，具有更好的灵活性。分布式控制系统结构相比集中式控制系统结构来说对无人机的要求更高，需要无人机具备独立计算、分析与决策等能力。
 
2.1合同网方法
 
目前，合同网（ContractNet）是应用范围最广的一种分布式任务分配方法，它的核心是为防止产生冲突，对每个问题的求解用通信的方式协商处理。[25]
 合同网方法有发布者和竞标者两个角色，由“招标- 投标- 中标- 确认”4 个交互阶段组成。在合同网协作方法中，系统成员的角色不用提前规定，任何系统成员可以是管理者，也可以是工作者，区别只在于成员是发布任务通知还是应答任务通知，于是任务能够被层次地分解分派。这种方法的缺点是通信量大、作为发布者的系统成员工作强度大且任务分解分配没有有效融合等。
 
2.2 拍卖方法
 
拍卖方法是实现资源配置的一种市场机制，指的是买方在清楚了解拍卖规则的前提下，采用竞价的方式决定特定物品的价格，也就是将要拍卖的物品用公开竞价的方式转卖给应价最高（ 最低）者的一种交易方式。一个拍卖主要由参与方、拍卖品、收益函数和应价策略4 个要素组成，在无人机任务分配问题中，无人机需要执行的任务可视为拍卖品，无人机的任务分配方和任务接受方共同组成参与者，且双方都有各自对应的收益函数和出价策略。拍卖方法是一种协商协议，因其规则明确且便于操作，近年来受到越来越多学者们的关注。拍卖方法用明确的规则引导买卖双方进行交互，可操作性非常强，能在较短时间内将资源合理分配，得到问题的最优解或较优解。该方法现已广泛运用在无人机作战和传感器等资源分配问题中。
 
综述
 
文献[1] 将任务分配方法归纳为集中式任务分配、分布式任务分配、分层次分布式任务分配三类，并对方法进行了简单阐述，提出了几个任务分配的可能的未来发展趋势。
 
文献［6］归纳和总结了多无人机协同任务规划的国内外研究现状，重点总结了任务分配方法的常见模型和算法，对各种算法的优缺点进行了讨论，得出多智能体的市场机制类算法在空战中将有广泛的应用价值。
 
模型
 
文献［5］探索了对不同种类的目标进行侦察、打击和评估任务时异构无人机的协同任务分配问题。对于侦察与评估任务中所得到的信息量，运用信息论中熵的变化量对其进行度量，把无人机对不同类型目标的打击能力简化为对目标的毁伤概率，同时把每个任务之间的关联性考虑在内，建立了异构多无人机协同任务分配模型。
 
文献［7］建立了以合同网协议和多智能体系统理论为基础的有人机／ 无人机编队MAS(Multi-agent System MAS)结构和基于投标过程的无人机任务分配模型。
 
文献[23]提出了集群组网任务分配模型和任务分配求解算法。分析了集群组网的任务分配问题，并剖析了任务分配分层递阶结构；借助层次分析思路，建立了集群组网任务分配模型；结合群体智能优化算法的优势，提出了基于PSO-ICWPA 的集群组网任务分配算法；
 
同构
 
文献[20]针对较为真实的战场环境,将避障约束、禁飞区约束、任务执行时间窗口约束、任务执行次序约束等加入到CMTAP模型中,建立了较为完整的UAV协同任务分配模型, 但忽略了UAV间的避碰约束、UAV的异构性、任务执行时间约束等。
 
1.蚁群
 
文献［8］在无人机协同多任务分配的研究中，运用了基于分工机制的蚁群算法进行求解，并给出了基于作战任务能力评估的问题解构造策略和基于作战任务代价的状态转移规则，大幅度提升了算法的性能。
 
2.粒子群
 
文献［11］设计出一种多无人机任务分配与航迹规划相结合的整体控制架构，假设威胁和障碍区域为合理的多边形模型，使用改进的算法求出两个航迹点之间的最短路径，将此路径当成任务分配过程全局目标函数的输入，然后用粒子群优化任务分配迭代寻优。
 
文献［10］在基于任务依赖关系和ISO–DATA（Iterative Self-organizing Data Analysis Technique）算法相结合的基础上设计了新的任务分组方法，在保持无人机负载均衡的基础上，给出了基于资源福利的任务组级组粗粒度的无人机任务分配方法，在任务组内提出了结合粒子群算法的细粒度任务分配算法。
 
文献[21]通过综合考虑多无人机任务分配约束条件，以多UCAV 总飞行航程和多UCAV 总飞行时间两个关
 键指标作为任务分配方案的评价标准，构建多无人机任务分配模型，采用改进的QPSO 算法进行优化求解多无人机任务分配问题。
 
文献[22]，综合考虑了协同多任务分配问题的任务优先级和任务协同约束、任务时间约束，同时针对无人机载弹量有限的实际情况，将无人机的载弹量约束等同于无人机执行攻击任务的最大次数限制，建立了协同多任务分配模型，在算法引入自组织惯性权重和加速系数，增强了算法的全局和局部搜索能力，优于遗传算法的协同多任务分配。
 
GA
 
文献[20]针对较为真实的战场环境,将避障约束、禁飞区约束、任务执行时间窗口约束、任务执行次序约束等加入到CMTAP模型中,建立了较为完整的UAV协同任务分配模型, 用整数规划法MIP和遗传算法求解。但忽略了UAV间的避碰约束、UAV的异构性、任务执行时间约束等。
 
文献[24]针对战场环境的多目标、多任务以及无人机能力有限等特点，设计了一种适应于多目标、多无人机、多任务种类的无人机群协同多任务分配模型。结合该模型以及其中的任务偏序约束、协同任务约束、无人机能力约束等约束条件提出了基于任务序列的遗传算法染色体编码方法，和基于同类任务的遗传算法交叉、变异算子。该方法利用遗传算法的全局搜索优化解特点，对无人机群的协同任务分配进行优化.
 
动态及不确定环境下
 
文献[12]分析了实际战场上信息的不确定性，同时指出了在此条件下多无人机面临的任务分配问题。将收益毁伤代价指标、目标价值及航程代价指标的不确定信息作为参考依据，在此基础上建立了基于区间
 信息环境下多无人机的任务分配模型，采用随机概率的多属性方案排序（Stochastic Multi-criteria Acceptability Analysis,SMAA）方法，得出不确定环境下多无人机动态任务分配求解方法。
 
文献[3]建立了多UCAV任务分配模型，对动态重分配策略进行研究并做出改进，将周期性重调度和事件驱动重调度进行有机结合。提出了一种改进的混合重调度策略．增加了对突发事件的处理能力，并结合粒子群算法和细菌觅食算法的优缺点。提出了混合细菌觅食算法(PBFO)解决多UCAV的动态任务分配问题。
 
异构
 
文献［9］以异构类型多目标多无人机任务分配问题为原型，设计了一种基于时间窗的多无人机联盟组任务分配方法，此算法使用冲突消解机制来防止无人机实时任务分配过程中出现多机资源死锁，其次通过无人机两阶段任务联盟构成算法，组成了任务联盟，使无人机任务分配的有效性和实时性有了很大的提高。
 文献[18]以多异构无人机执行SEAD任务为背景采用图论的方法完成问题的建模,将无人机本体等效为Dubins Car模型,并对其在相应目标处执行侦查、打击、评估任务时的进入角度进行约束,通过Dubins路径完成对无人机飞行路径的等效,采用分布式遗传算法完成对问题的快速求解.
 
文献[4]基于文献[20]的研究成果,将模型适用范围扩展到了异构UAV,但对约束条件的假设仍然相对理想.
 
引用文献
任务空间特性
建模方法
约束条件
算法求解架构
[3]
同类UAV

文献
 
[1]陈侠,乔艳芝.无人机任务分配综述[J].沈阳航空航天大学学报,2016,33(6):1-7. DOI:10.3969/j.issn.2095-1248.2016.06.001.
 [2]李炜,张伟. 基于粒子群算法的多无人机任务分配方法[J].控制与决策，2010,25(9):1359 -1364.
 [3]杨尚君,王社伟,陶军, 等.动态环境下的多UCAV协同任务分配研究[J].电光与控制,2012,19(7):32-36,79. DOI:10.3969/j.issn.1671-637X.2012.07.008.
 [4]Wang J, Zhang Y F, Geng L, et al. A heuristicmission planning algorithm for heterogeneous tasks with
 heterogeneous UAVs[J]. Unmanned Systems, 2015, 3(3):205-219.
 [5]邸斌,周锐,丁全心. 多无人机分布式协同异构任务分配[J].控制与决策,2013,28(2):274 -278.
 [6]朱毅,张涛,程农,等.多UAV协同任务规划研究[J]. 系统仿真学报,2009(20):194 -199.
 [7]刘跃峰,张安.有人机/无人机编队协同任务分配方法[J]. 系统工程与电子技术,2010，32(3):584-588.
 [8]苏菲,，陈岩,沈林成.基于蚁群算法的无人机协同多任务分配[J]. 航空学报,2008(29):184-191.
 [9]林林,孙其博,王尚广,等.基于时间窗的多无人机联盟任务分配方法研究[J].电子与信息学报,2013,35(8):1983-1988.
 [10]谭何顺,曹雷,彭辉,等. 一种多无人机层次化任务分配方法[J]. 解放军理工大学学报(自然科学版),2014,15(1):18 -24.
 [11]孙小雷,齐乃明,董程,等. 无人机任务分配与航迹规划协同控制方法[J]. 火力与指挥控制,2015,37(12):2772 -2776.
 [12]陈侠,唐婷.不确定环境下多无人机动态任务分配方法.火力与指挥控制[J].2013,38(1):45 -49.
 [13]SECREST. Traveling salesman problem for surveillance mission using particel swarm optimization [Ｄ]. wright-PattersonAFB:Air Force Institute of Technologhy,2003.
 [14]O’Rourke K P,Bailey T G,Hill R,et al. Dynamic Routing of Unmanned Aerial Vehicles Using Reactive Tabu Search[J].Military Operations Research Journal, 2001(6):5 -30.
 [15]ALIGHANBARI M.Task assignment algorithms for teams of UAVs in dynamic environments[D].Cambridge:Massachusetts Institute of Technology,2004.
 [16]NYGARD K E,CHANDLER P R,PACHTER M.Dynamic network flow optimization modles for air vehicle resourceallocation[C]//Proceedingsofthe 2001 American Control Conference,2001,3:1853-1858.
 [17] ALVARO E G .Stability Analysis of Network-based Cooperative Resource Allocation Strategies[D].Columbus:Ohio State University,2003.
 [18]吴蔚楠,关英姿,郭继峰, 等.基于SEAD任务特性约束的协同任务分配方法[J].控制与策,2017,32(9):1574-1582. DOI:10.13195/j.kzyjc.2016.0858.
 [19] Arsie A, Savla K, Frazzoli E. Efficient routing algorithmsfor multiple vehicles with no explicit communications[J].IEEE Trans on Automatic Control, 2009, 54(10):2302-2317.
 [20]Geng L, Zhang Y F, Wang J, et al. Cooperative missionplanning with multipleUAVs in realistic environments[J].Unmanned Systems, 2014, 2(1): 73-86.
 [21]邓可,连振江,周德云, 等.基于改进量子粒子群算法的多无人机任务分配[J].指挥控制与仿真,2018,40(5):32-36. DOI:10.3969/j.issn.1673-3819.2018.05.007.
 [22]梁国强,康宇航,邢志川, 等.基于离散粒子群优化的无人机协同多任务分配[J].计算机仿真,2018,35(2):22-28. DOI:10.3969/j.issn.1006-9348.2018.02.005.
 [23]汪汝根,李为民,刘永兰,刘金松.无人机集群组网任务分配方法研究[J].系统仿真学报,2018,30(12):4794-4801+4807.
 [24]姚敏,王绪芝,赵敏.无人机群协同作战任务分配方法研究[J].电子科技大学学报,2013,(5):723-727. DOI:10.3969/j.issn.1001-0548.2013.05.015.
 [25]SM ITH R G.The Contractnet Protocol :High level Communication and Control in a Distributed problem solver [J]. IEEE Transaction and Computers

宏任务与微任务
 
1.同步任务和异步任务
 
JavaScript是单线程执行的语言，在同一个时间只能做一件事情。这就导致后面的任务需要等到前面的任务完成才能执行，如果前面的任务很耗时就会造成后面的任务一直等待。为了解决这个问题JS中出现了同步任务和异步任务。
 
（1）同步任务
 
在主线程上排队执行的任务只有前一个任务执行完毕，才能执行后一个任务，形成一个执行栈。
 
（2）异步任务
 
不进入主线程，而是进入任务队列，当主线程中的任务执行完毕，就从任务队列中取出任务放进主线程中来进行执行。由于主线程不断重复的获得任务、执行任务、再获取再执行，所以者种机制被叫做事件循环（Event Loop）
 
2.宏任务与微任务
 
我们会发现异步任务种的事件并不是严格按照顺序来执行的，如下：
 
    <script>  
setTimeout(() => {
            console.log("定时器");
        }, 0);
        Promise.resolve().then(value=>{
             console.log('Promise');
        })
        console.log('console');
</script>
 
执行结果为：
 
 
​ 这时我们就会发现任务队列中的任务是有优先级的，上文中的代码Promise的优先级高于setTimeout。再往下探索发现，任务队列中的任务也是分为两种，宏任务和微任务。
 
常见的微任务有Promise、process.nextTick、MutationObserver
 
常见的宏任务：script、setTimeout、setInterval、setImmediate
 
发出疑问：到底是宏任务优先还是微任务优先？（个人观点：微任务优于宏任务）
 
经过实践并参考了前辈们的文章后做出总结：
 
Event Loop执行顺序为：
 
先执行宏任务script，并执行里面的同步任务；执行栈为空后查询是否存在微任务，存在就立即执行，然后开始下一轮的事件循环。
 
从上面的执行顺序可知，如果宏任务中有大量的计算并且需要操作DOM的话，为了更快响应，可以把操作DOM放进微任务务中。
 
３.定时器
 
定时器在开发中经常能用到，一个是超时调用定时器setTimeout()，也叫做爆炸定时器，另一个是间歇调用定时器setInterval()。但是在我们设置延时后会发现延时的时间和触发回调函数的时间不一样，究其原因，仍然是和执行机制有关。
 
首先我们知道定时器是宏任务，在定时器计时完毕后会将它的回调函数加入到任务队列中，等待下一次的事件循环。这也就是说下一次执行的定时器仅仅只是回调函数，计时已经在定时器模块中完成了。
 
如下代码：
 
setInterval(()=>{
            console.log('计时5S');
        },5000)
        for(let i=0;i<10009;i++){
            console.log('');
        }
 
毫无疑问，首先执行的是for循环，但是当for循环执行结束后会立即打印出“计时5S”两次。
 
4.Promise代表的微任务
 
代码：
 
 setTimeout(()=>{
            console.log('定时器');//1
        },0)
        new Promise(resolve=>{
            console.log('Promise');//2
            resolve()
        })
        .then(()=>{console.log('then')});//3
        console.log('console');//4
//输出结果：2>4>3>1
 
5.任务共享内存
 
let i=0
        setTimeout(()=>{
            console.log(++i);//1
        },0)
        setTimeout(()=>{
            console.log(++i);//2
        },0)
//把两个定时器加入到任务队列中，执行完第一个时i自增变为1，再执行第二个定时器函数后i为2