Linux组调度

为什么引入组调度可以参考这篇文章的讨论。核心原因是基础的调度算法都是基于任务的，如果用户A有10个任务，用户B只有1个任务，假设这些任务的优先级都相同，那么用户A得到的CPU时间将是用户B的10倍，这样从任务的角度看虽然是公平的，但是从用户角度看这不一定合理。引入组调度后，可以将用户A的任务安排为GroupA，用户B的任务安排为GroupB，调度算法在GroupA和GroupB之间平均分配CPU时间即可，由此可以解决上面提到的问题。

组调度是一个可选的特性，基础开关为CONFIG_SCHED_GROUP，开启该开关后，将基于CGROUP机制实现一个名为cpu的资源控制器，该控制器实现对CPU时间的管理。目前只有RT调度器和CFS调度器支持组调度，它们的开关分别为CONFIG_RT_GROUP_SCHED和CONFIG_FAIR_GROUP_SCHED，要实现完整的组调度功能，这两个宏至少要打开一个。

为了减小理解组调度的难度，这篇笔记以RT组调度为例分析组调度相关的实现，CFS组调度的实现在单独的笔记中总结。

关键数据结构

任务组: task_group

组调度引入了task_group表示任务组，task_group和cgroup分组对应，每个cgroup分组都会存在一个对应的task_group实例。

struct task_group {struct cgroup_subsys_state css; // ---(1)#ifdef CONFIG_FAIR_GROUP_SCHED // ---(2)/* schedulable entities of this group on each cpu */struct sched_entity **se;/* runqueue "owned" by this group on each cpu */struct cfs_rq **cfs_rq;unsigned long shares;
#endif
#ifdef CONFIG_RT_GROUP_SCHEDstruct sched_rt_entity **rt_se;struct rt_rq **rt_rq;struct rt_bandwidth rt_bandwidth;
#endifstruct rcu_head rcu; // ---(3)struct list_head list;struct task_group *parent;struct list_head siblings;struct list_head children;struct cfs_bandwidth cfs_bandwidth;
};
  1. CGROUP相关字段。
  2. 分别对应RT任务组调度和CFS任务组调度的字段。核心字段是rq数组和se数组，每个CPU对应一个调度实体和一个运行队列。见下面“任务的组织”部分介绍
  3. 用来组织系统中所有的task_group实例，见下面“任务组的管理”部分介绍。

任务组的管理

系统用一个链表+一棵树来管理所有的task_group实例：

  1. 用list字段将所有task_group实例组织为一个链表，表头为task_groups。
LIST_HEAD(task_groups);
  1. 属于同一层的task_group实例用siblings字段组织成链表，链表头为上一层task_group实例中的children字段。下一层task_group实例的parent字段指向上一层的task_group实例。系统定义了一个根任务组root_task_group实例，根分组也是默认的任务分组。
/** Default task group.* Every task in system belongs to this group at bootup.*/
struct task_group root_task_group;

下图表示在根分组下有两个一级分组的数据结构示意图：

  • 红色线条表示所有的分组形成单链表；绿色的线条表示相邻两个层级之间的task_group实例是如何组织的。
  • 根分组没有parent，其它分组的parent指向其上一层级的task_group实例。

任务的组织

每个task_group实例对应一个分组，一个分组进一步由若干个任务和子分组组织，如此嵌套，则系统中所有的任务都分散组织在了task_group树中。我们知道调度单位是任务，所以每个task_group实例需要能够合理的管理属于自己的任务和子分组。

首先，task_group针对每个CPU都有一个运行队列，该运行队列管理了所有属于该分组并且调度到该CPU上的任务。

其次，支持组调度后，调度实体的概念进行了扩展，它不仅仅可以代表一个任务，也可以代表一个任务组。task_group针对每个CPU都分配一个调度实体，这样，每当该分组有任务分配到某个CPU上时，就可以将对应CPU的调度实体挂到该任务组的父亲的对应CPU运行队列中。

假设一个系统有任务TaskA、TaskB以及任务组GroupA、GroupB，其中GroupA为根分组，GroupA包含GroupB分组以及TaskA，TaskB属于GroupB。下图为相关数据结构（以RT任务为例）示意图。

  1. GroupA为根任务组，它包含了GroupB和TaskA，所以TaskA的调度实体和GroupB的调度实体会被组织到GroupA的运行队列中。特别的，GroupA为根分组，其运行队列就是CPU的运行队列。
  2. 由于GroupA为根分组，所以其不需要调度实体，因为调度器总是会从它的运行队列开始寻找要运行的任务。
  3. GoupB作为一个普通分组，它有自己的调度实体，通过该调度实体才能将GroupB组织到GroupA的运行队列中。
  4. GroupB只包含了TaskB，所以它的运行队列中只有TaskB的调度实体。

运行队列&调度实体

运行队列（以RT运行队列为例）中增加了如下和组调度相关的字段：

  1. 保存了运行队列中最高优先级的调度实体，其作用后面介绍。
  2. rq指向CPU的运行队列。tg指向运行队列所属任务组，特别的，CPU运行队列中的该字段指向根任务组。
struct rt_rq {struct rt_prio_array active;
...
#if defined CONFIG_SMP || defined CONFIG_RT_GROUP_SCHED
struct {int curr; /* highest queued rt task prio */} highest_prio; // ---(1)
#endif#ifdef CONFIG_RT_GROUP_SCHEDunsigned long rt_nr_boosted;struct rq *rq; // ---(2)struct task_group *tg;
#endif
};

调度实体（以RT调度实体为例）中增加了如下和组调度相关的字段：

  1. 如果调度实体代表一个任务，rt_rq指向所属任务组的运行队列；parent指向所属任务组的调度实体；my_q为NULL。如果它代表一个任务组，rt_rq指向上一层任务组的运行队列；parent指向上一层任务组的调度实体；my_q指向该任务组自己的运行队列，即用来管理属于自己这个任务组的调度实体的运行队列。
struct sched_rt_entity {struct list_head run_list;struct sched_rt_entity *back; // 作用见下面RT任务组优先级部分介绍
...
#ifdef CONFIG_RT_GROUP_SCHEDstruct sched_rt_entity    *parent; // ---(1)/* rq on which this entity is (to be) queued: */struct rt_rq *rt_rq;/* rq "owned" by this entity/group: */struct rt_rq *my_q;
#endif
};

开机初始化

开机时，在sched_init()中会对根任务组实例进行初始化，下面列出相关代码：

  1. 根据CPU个数，为根任务组root_task_group分配调度实体指针数组和运行队列指针数组。
  2. 带宽控制相关逻辑。
  3. 将根任务组root_task_group添加到全局任务组链表中，并初始化其树形结构字段。
  4. 根据每个CPU运行队列，初始化根任务组的调度实体和运行队列。
void __init sched_init(void)
{int i, j;unsigned long alloc_size = 0, ptr;#ifdef CONFIG_FAIR_GROUP_SCHED // ---(1)alloc_size += 2 * nr_cpu_ids * sizeof(void **);
#endif
#ifdef CONFIG_RT_GROUP_SCHEDalloc_size += 2 * nr_cpu_ids * sizeof(void **);
#endifif (alloc_size) {ptr = (unsigned long)kzalloc(alloc_size, GFP_NOWAIT);#ifdef CONFIG_FAIR_GROUP_SCHEDroot_task_group.se = (struct sched_entity **)ptr;ptr += nr_cpu_ids * sizeof(void **);root_task_group.cfs_rq = (struct cfs_rq **)ptr;ptr += nr_cpu_ids * sizeof(void **);#endif /* CONFIG_FAIR_GROUP_SCHED */
#ifdef CONFIG_RT_GROUP_SCHEDroot_task_group.rt_se = (struct sched_rt_entity **)ptr;ptr += nr_cpu_ids * sizeof(void **);root_task_group.rt_rq = (struct rt_rq **)ptr;ptr += nr_cpu_ids * sizeof(void **);#endif /* CONFIG_RT_GROUP_SCHED */}init_rt_bandwidth(&def_rt_bandwidth, // ---(2)global_rt_period(), global_rt_runtime());init_dl_bandwidth(&def_dl_bandwidth,global_rt_period(), global_rt_runtime());#ifdef CONFIG_RT_GROUP_SCHEDinit_rt_bandwidth(&root_task_group.rt_bandwidth,global_rt_period(), global_rt_runtime());
#endif /* CONFIG_RT_GROUP_SCHED */#ifdef CONFIG_CGROUP_SCHEDlist_add(&root_task_group.list, &task_groups); // ---(3)INIT_LIST_HEAD(&root_task_group.children);INIT_LIST_HEAD(&root_task_group.siblings);autogroup_init(&init_task);#endif /* CONFIG_CGROUP_SCHED */for_each_possible_cpu(i) {struct rq *rq = cpu_rq(i);
#ifdef CONFIG_FAIR_GROUP_SCHED // ---(4)root_task_group.shares = ROOT_TASK_GROUP_LOAD;INIT_LIST_HEAD(&rq->leaf_cfs_rq_list);init_cfs_bandwidth(&root_task_group.cfs_bandwidth);init_tg_cfs_entry(&root_task_group, &rq->cfs, NULL, i, NULL);
#endif /* CONFIG_FAIR_GROUP_SCHED */rq->rt.rt_runtime = def_rt_bandwidth.rt_runtime;
#ifdef CONFIG_RT_GROUP_SCHEDinit_tg_rt_entry(&root_task_group, &rq->rt, NULL, i, NULL); // ---(4)
#endif}
}

初始化RT任务组

该函数用来初始化RT任务组的调度实体和运行队列，当创建一个新的分组时被调用。从上面也可以看到它还被用来初始化根任务的运行队列，特别的，根任务组不需要调度实体，传入的参数为NULL；运行队列就是CPU的运行队列。

void init_tg_rt_entry(struct task_group *tg, struct rt_rq *rt_rq,struct sched_rt_entity *rt_se, int cpu,struct sched_rt_entity *parent)
{struct rq *rq = cpu_rq(cpu);rt_rq->highest_prio.curr = MAX_RT_PRIO; // ---(1)rt_rq->rt_nr_boosted = 0;rt_rq->rq = rq;rt_rq->tg = tg;tg->rt_rq[cpu] = rt_rq; // ---(2)tg->rt_se[cpu] = rt_se;if (!rt_se)return;if (!parent) // ---(3)rt_se->rt_rq = &rq->rt;elsert_se->rt_rq = parent->my_q;rt_se->my_q = rt_rq;rt_se->parent = parent;INIT_LIST_HEAD(&rt_se->run_list);
}
  1. 设置新任务组的运行队列。新的任务组还没有包含任何调度实体，其最高优先级默认取100。其rq指向CPU运行队列，tg指向任务组实例。
  2. 保存任务组的调度实体和运行队列到任务组中。
  3. 设置任务组的调度实体。只有根任务组和一级任务组的parent为NULL，它们挂到CPU的运行队列中。其它任务组的rt_rq指向其上一层任务组的运行队列。

创建分组

当新建一个分组时，CGROUP框架会调用控制器的css_alloc回调函数来分配任务组，cpu控制器的实现函数为cpu_cgroup_css_alloc()。

static struct cgroup_subsys_state *
cpu_cgroup_css_alloc(struct cgroup_subsys_state *parent_css)
{struct task_group *parent = css_tg(parent_css);struct task_group *tg;if (!parent) {/* This is early initialization for the top cgroup */return &root_task_group.css;}tg = sched_create_group(parent); // 创建并初始化一个新的任务组对象if (IS_ERR(tg))return ERR_PTR(-ENOMEM);return &tg->css;
}

创建&初始化任务组

  1. 分配task_group对象。
  2. 为任务组分配调度实体和运行队列。
struct task_group *sched_create_group(struct task_group *parent)
{struct task_group *tg;tg = kzalloc(sizeof(*tg), GFP_KERNEL); // ---(1)if (!tg)return ERR_PTR(-ENOMEM);if (!alloc_fair_sched_group(tg, parent)) // ---(2)goto err;if (!alloc_rt_sched_group(tg, parent))goto err;return tg;
err:free_sched_group(tg);return ERR_PTR(-ENOMEM);
}

下面以RT组调度为例看其实现：

  1. 为RT任务组分配每个CPU上的运行队列指针数组和调度实体指针数组。
  2. 分配每个CPU上的调度实体和运行队列，并对其进行初始化。
int alloc_rt_sched_group(struct task_group *tg, struct task_group *parent)
{struct rt_rq *rt_rq;struct sched_rt_entity *rt_se;int i;tg->rt_rq = kzalloc(sizeof(rt_rq) * nr_cpu_ids, GFP_KERNEL); // ---(1)if (!tg->rt_rq)goto err;tg->rt_se = kzalloc(sizeof(rt_se) * nr_cpu_ids, GFP_KERNEL);if (!tg->rt_se)goto err;init_rt_bandwidth(&tg->rt_bandwidth,ktime_to_ns(def_rt_bandwidth.rt_period), 0);for_each_possible_cpu(i) { // ---(2)rt_rq = kzalloc_node(sizeof(struct rt_rq),GFP_KERNEL, cpu_to_node(i));if (!rt_rq)goto err;rt_se = kzalloc_node(sizeof(struct sched_rt_entity),GFP_KERNEL, cpu_to_node(i));if (!rt_se)goto err_free_rq;init_rt_rq(rt_rq, cpu_rq(i));rt_rq->rt_runtime = tg->rt_bandwidth.rt_runtime;init_tg_rt_entry(tg, rt_rq, rt_se, i, parent->rt_se[i]);}return 1;err_free_rq:kfree(rt_rq);
err:return 0;
}

任务创建

在新任务创建完毕后，CGROUP框架会调用控制器的fork回调函数，让控制器在任务创建时执行一些逻辑，cpu控制器的实现函数为cpu_cgroup_fork()。

static void cpu_cgroup_fork(struct task_struct *task)
{sched_move_task(task); // 任务切换分组也是调用该函数
}/* change task's runqueue when it moves between groups.*    The caller of this function should have put the task in its new group*    by now. This function just updates tsk->se.cfs_rq and tsk->se.parent to*    reflect its new group.*/
void sched_move_task(struct task_struct *tsk)
{struct task_group *tg;int queued, running;unsigned long flags;struct rq *rq;rq = task_rq_lock(tsk, &flags);running = task_current(rq, tsk); // ---(1)queued = task_on_rq_queued(tsk);if (queued)dequeue_task(rq, tsk, 0);if (unlikely(running))put_prev_task(rq, tsk);/** All callers are synchronized by task_rq_lock(); we do not use RCU* which is pointless here. Thus, we pass "true" to task_css_check()* to prevent lockdep warnings.*/tg = container_of(task_css_check(tsk, cpu_cgrp_id, true),struct task_group, css); // ---(2)tg = autogroup_task_group(tsk, tg);tsk->sched_task_group = tg;#ifdef CONFIG_FAIR_GROUP_SCHEDif (tsk->sched_class->task_move_group)tsk->sched_class->task_move_group(tsk, queued);
else
#endifset_task_rq(tsk, task_cpu(tsk)); // ---(3)if (unlikely(running)) // ---(1)tsk->sched_class->set_curr_task(rq);if (queued)enqueue_task(rq, tsk, 0);task_rq_unlock(rq, tsk, &flags);
}

如注释所描述，调用sched_move_task()函数之前，真正的CGROUP分组相关的任务设置已经完成，该函数负责更新任务的调度实体中和组调度相关的内容：

  1. 执行该动作前，任务可能已经在CPU运行队列中，或者正在运行，那么先将其从队列中移除，设置完组调度相关内容后再将其加回去。
  2. 根据CGROUP的层级关系，找到该任务所属任务组对象，将其保存到任务的sched_task_group字段中。
  3. 调用set_task_rq()函数设置任务的调度实体中的parent为所属任务组的调度实体，xxx_rq为所属任务组的运行队列。

设置任务调度实体

set_task_rq()函数将任务的调度实体中的xx_rq和parent分别设置为所属任务组的运行队列和调度实体。

static inline void set_task_rq(struct task_struct *p, unsigned int cpu)
{
#if defined(CONFIG_FAIR_GROUP_SCHED) || defined(CONFIG_RT_GROUP_SCHED)struct task_group *tg = task_group(p);
#endif#ifdef CONFIG_FAIR_GROUP_SCHEDp->se.cfs_rq = tg->cfs_rq[cpu];p->se.parent = tg->se[cpu];
#endif#ifdef CONFIG_RT_GROUP_SCHEDp->rt.rt_rq  = tg->rt_rq[cpu];p->rt.parent = tg->rt_se[cpu];
#endif
}

RT调度器选择任务

在没有组调度的情况下，调度框架在调用RT的pick_next_task回调选择任务时，直接从CPU运行队列中选择优先级最高的任务即可。支持组调度后，由于每个任务组都是用独立的运行队列来管理组内调度实体的，所以任务的选择过程应该是个递归的过程，下面重新来看其中最终要的_pick_next_rt()函数实现。

static struct task_struct *_pick_next_task_rt(struct rq *rq)
{struct sched_rt_entity *rt_se;struct task_struct *p;struct rt_rq *rt_rq  = &rq->rt;do {rt_se = pick_next_rt_entity(rq, rt_rq); // ---(1)BUG_ON(!rt_se);rt_rq = group_rt_rq(rt_se);} while (rt_rq); // ---(2)p = rt_task_of(rt_se);p->se.exec_start = rq_clock_task(rq);return p;
}static struct sched_rt_entity *pick_next_rt_entity(struct rq *rq,struct rt_rq *rt_rq)
{struct rt_prio_array *array = &rt_rq->active;struct sched_rt_entity *next = NULL;struct list_head *queue;int idx;idx = sched_find_first_bit(array->bitmap);queue = array->queue + idx;next = list_entry(queue->next, struct sched_rt_entity, run_list);return next;
}
  1. pick_next_rt_entity()函数从参数指定的运行队列中找到优先级最高的调度实体，该调度实体可能时任务，也可能是一个任务组。
  2. group_rt_rq()函数返回调度实体的my_q，如果找到的是任务组，则返回的是该任务组的运行队列，循环会继续下一层的遍历；如果找到的是任务，那么返回为NULL，结束循环。

通过上面的遍历过程，只要每一个任务组都能够正确维护运行队列中的优先级数组，那么每次调用就都可以找到优先级最高的任务。

RT任务组优先级

如前面对RT调度器选择任务过程的分析，每个任务组都需要维护自己的优先级数组。支持组调度后，优先级数组中除了任务的调度实体外，还会有任务组的调度实体，所以也需要为任务组定义优先级。RT任务组的优先级定义为自己运行队列中优先级最高的调度实体的优先级。RT任务组的优先级保存在任务组运行队列的rt_rq.highest.curr字段中。

为了维护RT任务组的优先级，在调度实体入队和出队时需要进行优先级的更新，具体的函数为__enqueue_rt_entity()-->inc_rt_tasks()-->inc_rt_prio()和__dequeue_rt_entity()-->dec_rt_tasks()-->dec_rt_prio()。

static voidinc_rt_prio(struct rt_rq *rt_rq, int prio)
{// 入队时，如果新的优先级更高则更新运行队列的最高优先级int prev_prio = rt_rq->highest_prio.curr;if (prio < prev_prio)rt_rq->highest_prio.curr = prio;inc_rt_prio_smp(rt_rq, prio, prev_prio);
}static void dec_rt_prio(struct rt_rq *rt_rq, int prio)
{// 出队的是最高优先级时重新计算最高优先级。队列为空时，优先级设置为100int prev_prio = rt_rq->highest_prio.curr;if (rt_rq->rt_nr_running) {WARN_ON(prio < prev_prio);if (prio == prev_prio) {struct rt_prio_array *array = &rt_rq->active;rt_rq->highest_prio.curr = sched_find_first_bit(array->bitmap);}} elsert_rq->highest_prio.curr = MAX_RT_PRIO;dec_rt_prio_smp(rt_rq, prio, prev_prio);
}

上面的inc_rt_prio()和dec_rt_prio()仅仅维护了参数指定的运行队列的优先级，但每个CPU的运行队列中的可能有多个任务组，任何一个低层级的任务组中任务的需要入队或出队，都会影响从根任务组到其直属任务组的优先级。因此在入队和出队时需要额外的流程来维护所有层级上任务组的优先级，下面以一个虚拟的任务组结构来分析入队和出队时的任务组优先级变化。

当TaskA入队和出队时，GroupA、GroupB、GroupD的优先级都需要更新。为了简化实现流程，内核在TaskA入队过程中，按照如下步骤执行：

  1. 按照GroupB->GroupD的顺序执行出队，这样随着出队过程不断更新各任务组的优先级，出队完毕后，GroupA、GroupB、GroupD的优先级都是正确的；
  2. 按照TaskA->GroupD->GroupB的顺序执行入队，这样随着入队过程不断更新各任务组的优先级，入队完毕后，GroupA、GroupB、GroupD的优先级都是正确的。

内核在TaskA出队过程中，按照如下步骤执行：

  1. 按照GroupB->GroupD->TaskA的顺序执行出队，这样随着出队过程不断更新各任务组的优先级，出队完毕后，GroupA、GroupB、GroupD的优先级都是正确的。
  2. 按照GroupD->GroupB的顺序执行入队，这样随着入队过程不断更新各任务组的优先级，入队完毕后，GroupA、GroupB、GroupD的优先级都是正确的。

这么做的好处是可以简化每个任务组在执行入队和出队时的处理逻辑，它们只需要处理好自己直接管理的调度实体即可，不需要操心祖先任务组的优先级更新。

调度实体入队

enqueue_rt_entity()函数负责将一个调度实体入队，该调度实体可以是任务也可以是任务组。任务入队函数enqueue_task_rt()最后也是调用该函数将任务加入队列中的。

static void enqueue_rt_entity(struct sched_rt_entity *rt_se, bool head)
{struct rq *rq = rq_of_rt_se(rt_se);dequeue_rt_stack(rt_se); // 按照层级从高到低的顺序依次出队for_each_sched_rt_entity(rt_se)// 按照层级从低到高的顺序依次入队__enqueue_rt_entity(rt_se, head);enqueue_top_rt_rq(&rq->rt); // 重新设置CPU运行队列的可运行任务个数
}

dequeue_rt_stack()

#define for_each_sched_rt_entity(rt_se) \for (; rt_se; rt_se = rt_se->parent)static void dequeue_rt_stack(struct sched_rt_entity *rt_se)
{struct sched_rt_entity *back = NULL;// 通过back指针得到一个从GroupB->GroupD->TaskA的调度实体链表for_each_sched_rt_entity(rt_se) {rt_se->back = back;back = rt_se;}// rt_rq_of_se(back)得到的是CPU运行队列，所以直接会减去所有的任务dequeue_top_rt_rq(rt_rq_of_se(back));// 按照GroupB->GroupD->TaskA的顺序，将调度实体从所属运行队列中移除for (rt_se = back; rt_se; rt_se = rt_se->back) {if (on_rt_rq(rt_se))__dequeue_rt_entity(rt_se);}
}

调度实体出队

dequeue_rt_entity()函数负责将一个调度实体出队，该调度实体可以是任务也可以是任务组。任务入队函数dequeue_task_rt()最后也是调用该函数将任务从队列中移除的。

static void dequeue_rt_entity(struct sched_rt_entity *rt_se)
{struct rq *rq = rq_of_rt_se(rt_se);dequeue_rt_stack(rt_se); // 按照层级从高到低的顺序依次出队// 按照层级从低到高的顺序依次入队，这个过程只将非空的任务组调度实体入队，// 所以步骤一中移除的最底层调度实体不会重新入队for_each_sched_rt_entity(rt_se) {struct rt_rq *rt_rq = group_rt_rq(rt_se);if (rt_rq && rt_rq->rt_nr_running)__enqueue_rt_entity(rt_se, false);}enqueue_top_rt_rq(&rq->rt); // 重新设置CPU运行队列的可运行任务个数
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/192542.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Zigbee智能家居方案设计

Zigbee智能家居方案设计

背景 目前智能家居物联网中最流行的三种通信协议&#xff0c;Zigbee、WiFi以及BLE&#xff08;蓝牙&#xff09;。这三种协议各有各的优势和劣势。本方案基于CC2530芯片来设计&#xff0c;CC2530是TI的Zigbee芯片。 网关使用了ESP8266CC2530。 硬件实物 节点板子上带有继电器…
阅读更多...
java，springboot钉钉开发连接器，自定义连接器配合流程使用，流程加入连接器，连接器发送参数，然后你本地处理修改值，返回给流程

java，springboot钉钉开发连接器，自定义连接器配合流程使用，流程加入连接器，连接器发送参数，然后你本地处理修改值，返回给流程

1.绘制连接器&#xff0c;注意出餐入参的格式&#xff0c; 2.绘制流程&#xff0c;绑定连接器&#xff0c;是提交后出发还是表单值变化后 3.编写本地接口&#xff08;内网穿透&#xff09;&#xff0c;绑定连接器 钉钉开发连接器&#xff0c;自定义连接器配合流程使用&#x…
阅读更多...
学【Java多态】-- 写高质量代码

学【Java多态】-- 写高质量代码

多态的实现条件 在java中要实现&#xff0c;必须要满足如下几个条件&#xff0c;缺一不可。 1.必须在继承体系下2.子类必须要对父类中的方法进行重写3.通过父类的引用调用冲写的方法。 想要真正的学好多态需要去学习一些前置知识&#xff0c;那我们直接开始吧&#xff01; …
阅读更多...
Sealos 云操作系统一键集成 runwasi，解锁 Wasm 的无限潜力

Sealos 云操作系统一键集成 runwasi，解锁 Wasm 的无限潜力

WebAssembly (通常缩写为 Wasm) 是一种为网络浏览器设计的低级编程语言。它旨在提供一种比传统的 JavaScript 更快、更高效的方式来执行代码&#xff0c;以弥补 JavaScript 在性能方面的不足。通过使用二进制格式&#xff0c;WebAssembly 能够提供比传统 JavaScript 更快的解析…
阅读更多...
基于态、势、感、知的人机协同机理

基于态、势、感、知的人机协同机理

基于态、势、感、知的人机协同机理是一种以人类的状态、动机、感觉和知觉为基础&#xff0c;与机器系统进行协同合作的机理。这种机理将人类的主观算计能力与机器系统的客观计算功能相结合&#xff0c;以实现更加智能、自适应和人性化的人机协同。下面是对基于态、势、感、知的…
阅读更多...
防爆五参数气象仪的科技力量

防爆五参数气象仪的科技力量

WX-FBQ2 随着科技的不断进步&#xff0c;气象监测设备也在不断升级和完善。 防爆五参数气象仪是一种可以同时监测温度、湿度、压力、风速和风向五个基本气象参数的仪器。它采用了气象监测技术&#xff0c;不仅可以实时监测气象数据&#xff0c;还可以对数据进行分析和处理。 …
阅读更多...
深入理解JVM虚拟机第二十四篇：详解JVM当中的动态链接和常量池的作用

深入理解JVM虚拟机第二十四篇：详解JVM当中的动态链接和常量池的作用

大神链接&#xff1a;作者有幸结识技术大神孙哥为好友&#xff0c;获益匪浅。现在把孙哥视频分享给大家。 孙哥链接&#xff1a;孙哥个人主页 作者简介&#xff1a;一个颜值99分&#xff0c;只比孙哥差一点的程序员 本专栏简介&#xff1a;话不多说&#xff0c;让我们一起干翻J…
阅读更多...
【linux】centos7 yum安装nginx

【linux】centos7 yum安装nginx

查看系统中是否已安装 nginx 服务 yum list | grep nginx查看nginx运行进程 ps -ef | grep nginx添加源 rpm -ivh http://nginx.org/packages/centos/7/noarch/RPMS/nginx-release-centos-7-0.el7.ngx.noarch.rpm 安装Nginx yum install -y nginx 查看nginx安装目录 find …
阅读更多...
基于 Keras 的图像分类器

基于 Keras 的图像分类器

引言 深度学习是使用人工神经网络进行机器学习的一个子集&#xff0c;目前已经被证明在图像分类方面非常强大。尽管这些算法的内部工作在数学上是严格的&#xff0c;但 Python 库(比如 keras)使这些问题对我们所有人都可以接近。在本文中&#xff0c;我将介绍一个简单的图像分…
阅读更多...
Sentinel 流控规则

Sentinel 流控规则

Sentinel 是面向分布式、多语言异构化服务架构的流量治理组件&#xff0c;主要以流量为切入点&#xff0c;从流量路由、流量控制、流量整形、熔断降级、系统自适应过载保护、热点流量防护等多个维度来帮助开发者保障微服务的稳定性。 SpringbootDubboNacos 集成 Sentinel&…
阅读更多...
ACM练习——第三天

ACM练习——第三天

今天继续练习C和ACM模式 在写题之前先了解一些新的知识 1.#include <algorithm> #include <algorithm> 是 C 标准库中的头文件之一&#xff0c;其中包含了一系列用于处理各种容器&#xff08;如数组、向量、列表等&#xff09;和其他数据结构的算法。这个头文件提供…
阅读更多...
Windows下安装Anaconda5.3.1+Python3.8+TensorFlow2.13.0-CPU版本总结

Windows下安装Anaconda5.3.1+Python3.8+TensorFlow2.13.0-CPU版本总结

Python3.8安装可以参考博文https://janus.blog.csdn.net/article/details/55274849 进行安装即可。 【1】Anaconda 清华的开源软件镜像站&#xff1a;https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/下载&#xff0c;这里选择的是5.3.1版本。 然后正常安装就可以&am…
阅读更多...
构建Docker基础镜像（ubuntu20.04+python3.9.10+pytorch-gpu-cuda11.8）

构建Docker基础镜像（ubuntu20.04+python3.9.10+pytorch-gpu-cuda11.8）

文章目录 一、前置条件1.创建 ubuntu 镜像源文件【sources.list】2.下载 python 安装包【Python-3.9.10.tgz】 二、构建方法1.构建目录2.创建DockerFile3.打包镜像 一、前置条件 配置一下 ubuntu 的镜像源下载 python 安装包 1.创建 ubuntu 镜像源文件【sources.list】 内容…
阅读更多...
3ds Max渲染用专业显卡还是游戏显卡？

3ds Max渲染用专业显卡还是游戏显卡？

使用3dsmax建模时&#xff0c;会面临诸多选择&#xff0c;除了用vr还是cr的决策&#xff0c;硬件选择上也存在着疑问&#xff0c;比如用专业显卡还是消费级游戏显卡&#xff1f;一般来说&#xff0c;除非是特别专业的大型项目和软件&#xff0c;且预算在5位数以上&#xff0c;常…
阅读更多...
保姆级使用vuedraggable三方组件

保姆级使用vuedraggable三方组件

第一步 引入vuedraggable npm i vuedraggable -S 第二步 直接使用&#xff0c;源码如下 <template><draggableclass"list-group"tag"ul"v-model"list"v-bind"{animation: 1000,group: description,disabled: false,ghostClass:…
阅读更多...
mq具体使用方式

mq具体使用方式

代码方式 第一步方式导入依赖的方式 <dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><!--AMQP依赖&#xff0c;包含RabbitMQ--><…
阅读更多...
php+vue3实现点选验证码

php+vue3实现点选验证码

buildadmin 中的点选验证码实现 验证码类 <?phpnamespace ba;use Throwable; use think\facade\Db; use think\facade\Lang; use think\facade\Config;/*** 点选文字验证码类*/ class ClickCaptcha {/*** 验证码过期时间(s)* var int*/private int $expire 600;/*** 可以…
阅读更多...
理工ubuntu20.04电脑配置记录

理工ubuntu20.04电脑配置记录

8188gu无线网卡配置 首先下载github上的文件&#xff0c;进入文件夹 安装make命令 1. 查看usb无线网卡 sudo lsusb|grep 8188 2. 环境准备 sudo apt-get install git make build-essential git dkms linux-headers-$(uname -r) 3. 编译安装 git clone https://github.com…
阅读更多...
Linux_磁盘管理_df命令

Linux_磁盘管理_df命令

1、df命令是用来干什么的 df的全称是disk free&#xff0c;意为“磁盘空间”。 使用df命令可以查看系统中磁盘的占用情况&#xff0c;有哪些文件系统&#xff0c;在什么位置&#xff08;挂载点&#xff09;&#xff0c;总空间&#xff0c;已使用空间&#xff0c;剩余空间等。…
阅读更多...
SpringBoot写接口小记 以及 几个层的功能总结(自用 勿喷)

SpringBoot写接口小记 以及 几个层的功能总结(自用 勿喷)

目录 Entity层&#xff1a;实体层 数据库在项目中的类 Mapper层&#xff1a; 持久层 主要与数据库进行交互 Service层&#xff1a;业务层 控制业务 Controller层&#xff1a;控制层 控制业务逻辑 Entity层&#xff1a;实体层 数据库在项目中的类 Entity层是实体层&#xff…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023