生產調度演算法

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