生产调度算法

1. 万紫千红高级生产计划调度系统APS可以算法深度个性化吗

万紫千红wonderful wzqh精益生产平台ERP是行业领先的B/S架构的软件。基于精益生产排程APS：人的大脑指挥中心。基于精益生产流程BPM：人的神经顺畅汇聚。实现精益生产平台ERP：人的身体各个部分。
强大的工作流程引擎，可视化监控，高灵活结合：1.支持串行、并行、分支、合支、循环复杂流程。2.提供流程的催办、撤回、跳转、退回等审批处理功能。3.提供所见即所得的图形化流程自定义功能，不用更改程序就可以实现流程的更改。
精确掌握整个生产过程，对每道工序、每个设备、每种物料进行精确管理。可以个性化考虑约束条件，减少模具切换次数，在满足交期下，排程相同模具相同产品连续生产。继承优良生产经验，帮助企业不断改进生产，逐步实现精益生产。
万紫千红wonderful wzqh精益生产排程APS实现生产计划自动排程，把人从复杂排程工作中解放出来，让计划员腾出更多时间处理非排程工作，优化工序，收集数据，优化数据准确度，协调人员资源，统筹计划等工作。就像计算器代替人工计数一样，就像汽车代替人工步行一样。把排程要求，排程规则输入电脑，由软件运算得出排程结果，并做评估分析，为决策提供有效支持，让计划员腾出时间优化排程规则，规则优化越好，资源调配越好，生产效率越高，不断向精益生产靠近。
APS排程算法要求高，既要技术高手，又是算法高手，又是业务流程高手，这样的人才很难，智商情商要求高，在实现算法的时候，遇到很多困难，需要很耐心，很有毅力。支持并行工序模具工人人数这些约束，减少模具切换次数，可视化插单，调整。可以演示，录入样例数据，真正看到实现算法效果。

2. 编写代码实现作业的三种调度算法

#include<windows.h>
#include<iostream>
#include<stdio.h>
#include<string>
using namespace std;
const int maxnum=100;
int N; /*进程数*/
double start[maxnum],endtime[maxnum],arrive[maxnum],runtime[maxnum],zhou[maxnum];
double averagezhou; // 平均周转时间
double average_zhou; //平均带权周转时间
char name; //进程名
double dqzhou[maxnum]; //带权周转时间
typedef struct node
{
char name[10]; //进程名
int round; //进程时间轮转时间片
int cputime; //进程占用CPU时间
int needtime; //进程到完成还要的时间
char state; //进程的状态
struct node *next; //链指针
}PCB;
PCB *finish,*ready,*tail,*run; /*队列指针*/

void firstin() /*将就绪队列中的第一个进程投入运行*/
{
run=ready; /*就绪队列头指针赋值给运行头指针*/
run->state='R'; /*进程状态变为运行态*/
ready=ready->next; /*就绪对列头指针后移到下一进程*/
}
void print1(PCB *q) /*进程PCB输出*/
{
printf("进程名 已运行时间 还需要时间 时间片 状态\n");
printf(" %-10s%-15d%-10d%-10d %-c\n",q->name,q->cputime,q->needtime,q->round,q->state);
}
void print() /*输出函数*/
{
PCB *p;
if(run!=NULL) /*如果运行指针不空*/
print1(run); /*输出当前正在运行的PCB*/
p=ready; /*输出就绪队列PCB*/
while(p!=NULL)
{
print1(p);
p=p->next;
}
p=finish; /*输出完成队列的PCB*/
while(p!=NULL)
{
print1(p);
p=p->next;
}
}
void insert(PCB *p2) //轮转法插入函数
{
tail->next=p2; //将新的PCB插入在当前就绪队列的尾
tail=p2;
p2->next=NULL;
}
void create() /*创建进程PCB*/
{
PCB *p;
int i,time;
char na[10];
ready=NULL;
finish=NULL;
run=NULL;
printf("请输入进程名称和所需要CPU的时间:\n");
for(i=1;i<=N;i++)
{
p=(PCB *)malloc(sizeof(PCB));
scanf("%s",na);
scanf("%d",&time);
strcpy(p->name,na);
p->cputime=0;
p->needtime=time;
if(i==1)
p->state='R';
else
p->state='W';
p->round=1; /*时间片*/
if(ready!=NULL)
insert(p);
else
{
p->next=ready;
ready=p;
tail=p;
}
}
printf("------------------------------------------------------------------\n");
print(); /*输出进程PCB信息*/
run=ready; /*将就绪队列的第一个进程投入运行*/
ready=ready->next;
run->state='R';
}
void RR() //时间片轮转调度
{
while(run!=NULL)
{
run->cputime=run->cputime+1;
run->needtime=run->needtime-1;
if(run->needtime==0) /*运行完将其变为完成态，插入完成队列*/
{
run->next=finish;
finish=run;
run->state='F';
run=NULL;
if(ready!=NULL)
firstin(); /*就绪对列不空，将第一个进程投入运行*/
}
else
if(ready!=NULL) /*如就绪队列不空*/
{
run->state='W'; /*将进程插入到就绪队列中等待轮转*/
insert(run);
firstin(); /*将就绪对列的第一个进程投入运行*/
}
printf("------------------------------------------------------------------\n");
print(); /*输出进程信息*/
}
}

void FCFS(double *arrive,double *runtime,double n) //先来先服务调度算法
{
start[0]=arrive[0]; //开始执行时间=到达时间
endtime[0]=start[0]+runtime[0]; //完成时间=开始时间+服务时间
zhou[0]=endtime[0]-arrive[0]; //周转时间=完成时间-到达时间
dqzhou[0]=zhou[0]/runtime[0];
for(int i=0;i<n;i++)
{
if(endtime[i-1]>arrive[i]||endtime[i-1]==arrive[i])
endtime[i]=endtime[i-1]+runtime[i];
else
endtime[i]=arrive[i]+runtime[i];
zhou[i]=endtime[i]-arrive[i];
dqzhou[i]=zhou[i]/runtime[i];
averagezhou+=zhou[i];
average_zhou+=dqzhou[i];
}
averagezhou=averagezhou/n;
average_zhou=average_zhou/n;
cout<<"完成时间为:"<<endl;
for(int j=0;j<n;j++)
cout<<endtime[j]<<" "<<endl;
cout<<"周转时间为:"<<endl;
for(int k=0;k<n;k++)
cout<<zhou[k]<<" "<<endl;
cout<<"带权周转时间为:"<<endl;
for(int m=0;m<n;m++)
cout<<dqzhou[m]<<" "<<endl;
cout<<"平均周转时间为:"<<endl;
cout<<averagezhou<<" "<<endl;
cout<<"平均带权周转时间为:"<<endl;
cout<<average_zhou<<" "<<endl;
}

void SJF(double *arrive,double *runtime,double n) //短作业优先调度算法
{
int end[maxnum]; //用于标记进程是否已经执行，应经执行end[i]=1,否则为0;
for(int k=0;k<n;k++)
end[k]=0;
int temp,now=0,next=1,p=1; //now表示刚执行完的进程号，next表示下一个要执行的进程号
start[0]=arrive[0]; //开始执行时间=到达时间
endtime[0]=start[0]+runtime[0]; //完成时间=开始时间+服务时间
zhou[0]=endtime[0]-arrive[0]; //周转时间=完成时间-到达时间
dqzhou[0]=zhou[0]/runtime[0]; //带权周转时间=周转时间/服务时间
averagezhou=zhou[0];
average_zhou=dqzhou[0];
end[now]=1; //执行完的进程设置为1；
for(int i=1;i<n;i++)
{
int j;
for(j=1;j<n;)
{
if(arrive[j]<endtime[now]||arrive[j]==endtime[now])
j++;
else
break;
}
temp=j;
int min=p;
for(j=1;j<=temp;j++)
{
if(runtime[min]>runtime[j] && end[j]==0)
min=j;
}
next=min;
endtime[next]=endtime[now]+runtime[next];
zhou[next]=endtime[next]-arrive[next];
dqzhou[next]=zhou[next]/runtime[next];
averagezhou+=zhou[next];
average_zhou+=dqzhou[next];
end[next]=1;
now=next;
next=p;
while(end[p]!=0)
p++;
}
averagezhou=averagezhou/n;
average_zhou=average_zhou/n;
cout<<"完成时间为:"<<endl;
for(int j=0;j<n;j++)
cout<<endtime[j]<<" "<<endl;
cout<<"周转时间为:"<<endl;
for(k=0;k<n;k++)
cout<<zhou[k]<<" "<<endl;
cout<<"带权周转时间为:"<<endl;
for(int m=0;m<n;m++)
cout<<dqzhou[m]<<" "<<endl;
cout<<"平均周转时间为:"<<endl;
cout<<averagezhou<<" "<<endl;
cout<<"平均带权周转时间为:"<<endl;
cout<<average_zhou<<" "<<endl;
}

int EDF() //最早截止时间的调度算法
{
int arrive_A,arrive_B; //标记进程A,进程B的到达时间
int zhouqi_A,zhouqi_B,serve_A,serve_B; //进程的周期时间和服务时间
int i,j,a=0,b=0,ka=0,kb=0; //ka,kb为开关,i,j,a,b为进程下标
int num_a=0,num_b=0; //服务累计时间
printf("输入进程A的周期时间,服务时间: ");
scanf("%d%d",&zhouqi_A,&serve_A);
printf("输入进程B的周期时间,服务时间: ");
scanf("%d%d",&zhouqi_B,&serve_B);
for(int T=0;T<=100;T++)
{
if(num_a==serve_A) //进程A完成
{
num_a=serve_A+1;
printf("当T=%d时",T);
printf("进程A%d结束\n",a);
if(num_b<serve_B)
{
printf(" 调用进程B%d\n",b);
kb=1;
}
ka=0;
}
if(num_b==serve_B)
{
num_b=serve_B+1;
printf("当T=%d时",T);
printf("进程B%d结束\n",b);
if(num_a<serve_A)
{
printf(" 调用进程A%d\n",a);
ka=1;
}
kb=0;
}
if(T%zhouqi_A==0 && T%zhouqi_B==0)
{
arrive_A=arrive_B=T;
j=++a;
i=++b;
printf("当T=%d时,进程A%d和进程B%d同时产生，此时，",T,j,i);
if(zhouqi_A<=zhouqi_B)
{
printf("调用进程A%d，阻塞进程B%d\n",j,i);
ka=1;
kb=0;
}
else
{
printf("调用进程B%d，阻塞进程A%d\n",i,j);
ka=0;
kb=1;
}
num_a=num_b=0;
}
if(T%zhouqi_A==0&&T%zhouqi_B!=0)
{
arrive_A=T;
printf("当T=%d时",T);
printf("进程A%d产生 ",++a); //不可能与进程A竞争处理器
num_a=0;
if(num_b<serve_B) //进程B没有完成
if(arrive_B+zhouqi_B>arrive_A+zhouqi_A) //若进程B最早截止时间大于进程A的,则执行进程A
{
printf("进程A%d执行。\n",a);
ka=1;
kb=0;
}
else //若进程B最早截止时间小于等于进程A的
printf("进程B%d继续执行。\n",b);
else //进程B完成
{
printf("进程A%d执行。\n",a);
ka=1;
}
}
if(T%zhouqi_A!=0 && T%zhouqi_B==0)
{
arrive_B=T;
printf("当T=%d时",T);
printf("进程B%d产生，",++b); //不可能与进程B竞争处理器
num_b=0;
if(num_a<serve_A) //进程A没有完成
if(arrive_B+zhouqi_B>=arrive_A+zhouqi_A) //进程A的最早截止时间不小于B
printf("进程A%d继续执行。\n",a);
else
{
printf("进程B%d执行。\n",b);
kb=1;
ka=0;
}

else //进程A完成
{
printf("进程B%d执行。\n",b);
kb=1;
}
}
if(ka)
num_a++;
if(kb)
num_b++;
}
return 1;
}

int main()
{
system("color 0b"); //设置颜色
cout<<"最早截止时间的调度算法如下: "<<endl<<endl;
EDF();
int n;
cout<<endl;
cout<<"请输入进程的数目: ";
cin>>n;
cout<<"请按进程到达时间从小到大依次输入n个进程的到达时间: "<<endl;
for(int i=0;i<n;i++)
cin>>arrive[i];
cout<<"请按上面进程的顺序依次输入n个进程的服务时间: "<<endl;
for(int j=0;j<n;j++)
cin>>runtime[j];
cout<<"先来先服务调度算法如下: "<<endl;
FCFS(arrive,runtime,n);
cout<<endl<<endl;
cout<<"短作业优先调度算法如下: "<<endl;
SJF(arrive,runtime,n);
cout<<endl<<endl;
printf("轮转调度算法如下:\n\n");
printf("输入创建进程的数目:\n");
scanf("%d",&N);
create();
RR();
return 0；
}

3. 举例说明运输生产作业计划是如何调整的

咨询记录 · 回答于2021-10-12

4. 关于遗传算法做生产调度问题

我觉得是这里出了问题。数组定义有问题。

%选择复制采取两两随机配对竞争的方式，具有保留最优个体的能力
Ser=randperm(2*N);
for i=1:N
f1=FITNESS(Ser(2*i-1));
f2=FITNESS(Ser(2*i));
if f1<=f2
farm=FARM;
fitness(i)=FITNESS(Ser(2*i-1));
else
farm=FARM;
fitness(i)=FITNESS(Ser(2*i));
end

5. 生产管理中 调度的 多级多机 是什么意思 有什么优化算法解决

我做调度多年，但没听说过这个词，英文叫什么？
我的理解是：多分层，多机器
也就是排计划的时候要考虑到产品的多层性，和在多个机器上生产的特性
所以，如果能有效得利用运筹学的原理，在最短的时间内做最多的产品，不浪费人力，工时，地方，成本就是最优化的调度

6. 工业工程毕业论文要写生产调度方面的，算法用matlab可以吗

matlab非常不错的，不管老师是否同意，你都应该试试，学习matlab你就会感到数学的强大。注意我不是说matlab强大，而是说的数学，matlab是数学应用到方方面面的体现

7. 调度算法有哪些

先来先服务(FCFS, First Come First Serve)
时间片轮转法
多级反馈队列算法(Round Robin with Multiple Feedback)
最短进程优先
最短剩余时间优先
最高响应比优先
常用的应该就这么几种吧 具体实现算法原理其实不是很难

8. 作业调度的算法有哪些

作业调度的算法有：算法有先来先服务、最短作业优先算法、最高响应比优先算法、基于优先数调度算法。

1、算法有先来先服务

最简单的调度算法，按作业的先后顺序进行调度，只考虑每个作业的等待时间而未考虑执行时间的长短。

2、最短作业优先算法

最短作业优先算法是对先来先服务算法的改进，其目标是减少平均周转时间。对预计执行时间短的作业优先分派处理机。通常后来的短作业不抢先正在执行的作业。 只考虑执行时间而未考虑等待时间的长短。

3、最高响应比优先算法

最高响应比优先算法是对先来先服务方式和最短作业优先算法方式的一种综合平衡。最高响应比优先法调度策略同时考虑每个作业的等待时间的长短和估计需要的执行时间长短，从中选出相应比最高的作业投入执行。

4、基于优先数调度算法

优先数调度算法常用于批处理系统中。在进程调度中，每次调度时，系统把处理机分配给就绪队列中优先数最高的进程。它又分为两种：非抢占式优先数算法和抢占式优先数算法。

(8)生产调度算法扩展阅读：

作业调度是指按照时间周期(年、月、日、时、分、秒等)对作业进行分割，并根据业务需求、作业长度、存储管理及依赖性关系对作业的执行方式加以调度。主要任务是从作业后备队列中选择作业进入主存运行。作业调度的功能主要有以下几方面：

1、记录各作业在系统中的状态；

2、从后备队列中挑选一部分作业投入运行；

3、从被选中的作业做好执行前的准备工作；

4、在作业执行结束时，做善后处理工作。

进行作业调度有很多作业调度算法，这些作业调度算法要实现的目标是：

1、调度对所有作业都是公平合理的；

2、应使设备有较高的利用率（提供系统利用率）；

3、每次运行尽可能多的作业（提高系统吞吐量）；

4、较快的相应时间。

9. 什么是调度算法

调度算法

通常将作业或进程归入各种就绪或阻塞队列。有的算法适用于作业调度，有的算法适用于进程调度，有的两者都适应。

1．先来先服务(FCFS, First Come First Serve)

先来先服务（FCFS, First Come First Serve）是最简单的调度算法，按先后顺序进行调度。

1. FCFS算法

按照作业提交或进程变为就绪状态的先后次序，分派CPU；

当前作业或进程占用CPU，直到执行完或阻塞，才出让CPU（非抢占方式）。

在作业或进程唤醒后（如I/O完成），并不立即恢复执行，通常等到当前作业或进程出让CPU。最简单的算法。

2. FCFS的特点

比较有利于长作业，而不利于短作业。

有利于CPU繁忙的作业，而不利于I/O繁忙的作业。

2. 轮转法(Round Robin)

轮转法(Round Robin)是让每个进程在就绪队列中的等待时间与享受服务的时间成正比例。

1. 轮转法

Ø 将系统中所有的就绪进程按照FCFS原则，排成一个队列。

Ø 每次调度时将CPU分派给队首进程，让其执行一个时间片。时间片的长度从几个ms到几百ms。

Ø 在一个时间片结束时，发生时钟中断。

Ø 调度程序据此暂停当前进程的执行，将其送到就绪队列的末尾，并通过上下文切换执行当前的队首进程。

Ø 进程可以未使用完一个时间片，就出让CPU（如阻塞）。

Ø

2. 时间片长度的确定

Ø 时间片长度变化的影响

² 过长－>退化为FCFS算法，进程在一个时间片内都执行完，响应时间长。

² 过短－>用户的一次请求需要多个时间片才能处理完，上下文切换次数增加，响应时间长。

Ø 对响应时间的要求：T(响应时间)=N(进程数目)*q(时间片)

Ø 就绪进程的数目：数目越多，时间片越小

Ø 系统的处理能力：应当使用户输入通常在一个时间片内能处理完，否则使响应时间，平均周转时间和平均带权周转时间延长。

3. 多级反馈队列算法(Round Robin with Multiple Feedback)

多级反馈队列算法时间片轮转算法和优先级算法的综合和发展。

优点：

² 为提高系统吞吐量和缩短平均周转时间而照顾短进程。

² 为获得较好的I/O设备利用率和缩短响应时间而照顾I/O型进程。

² 不必估计进程的执行时间，动态调节。

1. 多级反馈队列算法

² 设置多个就绪队列，分别赋予不同的优先级，如逐级降低，队列1的优先级最高。每个队列执行时间片的长度也不同，规定优先级越低则时间片越长，如逐级加倍。

² 新进程进入内存后，先投入队列1的末尾，按FCFS算法调度；若按队列1一个时间片未能执行完，则降低投入到队列2的末尾，同样按FCFS算法调度；如此下去，降低到最后的队列，则按“时间片轮转”算法调度直到完成。

² 仅当较高优先级的队列为空，才调度较低优先级的队列中的进程执行。如果进程执行时有新进程进入较高优先级的队列，则抢先执行新进程，并把被抢先的进程投入原队列的末尾。

²

2. 几点说明

² I/O型进程：让其进入最高优先级队列，以及时响应I/O交互。通常执行一个小时间片，要求可处理完一次I/O请求的数据，然后转入到阻塞队列。

² 计算型进程：每次都执行完时间片，进入更低级队列。最终采用最大时间片来执行，减少调度次数。

² I/O次数不多，而主要是CPU处理的进程。在I/O完成后，放回优先I/O请求时离开的队列，以免每次都回到最高优先级队列后再逐次下降。

² 为适应一个进程在不同时间段的运行特点，I/O完成时，提高优先级；时间片用完时，降低优先级。

10. matlab 生产调度的遗传算法，job shop 问题 源程序

我觉得是这里出了问题。数组定义有问题。

%选择复制采取两两随机配对竞争的方式，具有保留最优个体的能力
Ser=randperm(2*N);
for i=1:N
f1=FITNESS(Ser(2*i-1));
f2=FITNESS(Ser(2*i));
if f1<=f2
farm{i}=FARM{Ser(2*i-1)};
fitness(i)=FITNESS(Ser(2*i-1));
else
farm{i}=FARM{Ser(2*i)};
fitness(i)=FITNESS(Ser(2*i));
end