进程调度算法

news2024/9/21 12:46:52

文章目录

主要内容

一.进程调度算法

1.各调度算法思想

  1. 先来先服务算法（First Come, First Served，FCFS）：这是最简单的调度算法之一。进程按照它们进入就绪队列的顺序进行调度，首先进入队列的进程首先被执行。这意味着后来的进程必须等待前面的进程完成才能执行。

  2. 短作业优先调度算法（Shortest Job First，SJF）：这种算法会优先选择执行时间最短的进程。当一个新的进程进入就绪队列时，系统会比较它的执行时间与当前就绪队列中所有进程的执行时间，然后选择执行时间最短的进程来执行。

  3. 时间片轮转调度算法（Round Robin）：在这种算法中，每个进程被分配一个时间片，当时间片用完时，操作系统会将该进程移到就绪队列的末尾，然后选择下一个就绪队列中的进程来执行。这种方法确保了每个进程都有机会执行，并且避免了长时间的等待。

  4. 优先级调度算法（Priority Scheduling）：这种算法根据每个进程的优先级来决定执行顺序。较高优先级的进程会优先执行，而较低优先级的进程则会被推迟执行。这种算法可以是静态的（优先级在进程创建时确定）或者动态的（优先级可以随着时间变化）。
    在这里插入图片描述

这些调度算法各有优劣，适用于不同的场景和需求。选择适当的调度算法可以提高系统的性能和效率。

2.程序流程图

在这里插入图片描述

3.源代码

代码如下（示例）:
#include<bits/stdc++.h>
#include<windows.h>
using namespace std;
struct PCB
{
 int pid;//进程号
 char pname;//进程名
 double priority;//优先级
 int arrive;//到达时间
 int service;//服务时间
 int start;//开始时间
 int end;//结束时间
 int turnover;//周转时间
 double author_turnover;//带权周转时间
} pcb[5];

double fcfs_author,fcfs_turnover,sjf_author,sjf_turnover,hrrn_author,hrrn_turnover;
vector<PCB> fcfs;
vector<PCB> sjf;
vector<PCB> hrrn;

int cmp(PCB a,PCB b)//fcfs
{
 return a.arrive<b.arrive;
}

int cmp1(PCB a,PCB b)//sjf  排序，按service升序排序，如果service相等，则按arrive升序排序
{
 return (a.service<b.service)||(a.service==b.service&&a.arrive<b.arrive);
}

int cmp2(PCB p1, PCB p2) //hrrn 
{
 return (p1.priority > p2.priority) || (p1.priority==p2.priority && p1.arrive<p2.arrive);
}

void Compare()//打印算法对比 
{
 cout<<"先来先服务调度算法！"<<endl;
 cout<<"\t进程名\t\t"<<"到达时间\t"<<"服务时间\t"<<"完成时间\t"<<"周转时间\t"<<"带权周转"<<endl;
 for(int i=0;i<fcfs.size();i++)
 {
  cout<<"\t"<<fcfs[i].pname<<"\t\t"<<fcfs[i].arrive<<"\t\t"<<fcfs[i].service<<"\t\t"<<fcfs[i].end<<"\t\t"<<fcfs[i].turnover<<"\t\t";
  printf("%.2lf\n",fcfs[i].author_turnover);
 }
 printf("\t平均周转时间：%.2lf\t",fcfs_turnover);
 printf("\t平均带权周转时间：%.2lf\n",fcfs_author);
 
 cout<<endl;
 cout<<endl;
 
 cout<<"短作业优先算法！"<<endl;
 cout<<"\t进程名\t\t"<<"到达时间\t"<<"服务时间\t"<<"完成时间\t"<<"周转时间\t"<<"带权周转"<<endl;
 for(int i=0;i<sjf.size();i++)
 {
  cout<<"\t"<<sjf[i].pname<<"\t\t"<<sjf[i].arrive<<"\t\t"<<sjf[i].service<<"\t\t"<<sjf[i].end<<"\t\t"<<sjf[i].turnover<<"\t\t";
  printf("%.2lf\n",sjf[i].author_turnover);
 }
 printf("\t平均周转时间：%.2lf\t",sjf_turnover);
 printf("\t平均带权周转时间：%.2lf\n",sjf_author);
 
 cout<<endl;
 cout<<endl;
 
 cout<<"高响应比优先算法！"<<endl;
 cout<<"\t进程名\t\t"<<"到达时间\t"<<"服务时间\t"<<"完成时间\t"<<"周转时间\t"<<"带权周转"<<endl;
 for(int i=0;i<hrrn.size();i++)
 {
  cout<<"\t"<<hrrn[i].pname<<"\t\t"<<hrrn[i].arrive<<"\t\t"<<hrrn[i].service<<"\t\t"<<hrrn[i].end<<"\t\t"<<hrrn[i].turnover<<"\t\t";
  printf("%.2lf\n",hrrn[i].author_turnover);
 }
 printf("\t平均周转时间：%.2lf\t",hrrn_turnover);
 printf("\t平均带权周转时间：%.2lf\n",hrrn_author);
 system("pause");
 system("cls");
}

void print()
{
 system("cls");
 cout<<"\n\n";
 cout<<"\t 进程名：";
 for(int i=0; i<5; i++)
 {
  cout<<"\t"<<pcb[i].pname;
 }
 cout<<endl;
 cout<<"\t到达时间：";
 for(int i=0; i<5; i++)
 {
  cout<<"\t"<<pcb[i].arrive;
 }
 cout<<endl;
 cout<<"\t服务时间：";
 for(int i=0; i<5; i++)
 {
  cout<<"\t"<<pcb[i].service;
 }
 cout<<endl;
 cout<<endl;
 system("pause");
 system("cls");
}

void FCFS()   //先来先服务
{

 system("cls");
 cout<<"先来先服务调度算法！"<<endl;
 //打印
 cout<<"\n\n";
 cout<<"\t 进程名：";
 for(int i=0; i<5; i++)
 {
  cout<<"\t"<<pcb[i].pname;
 }
 cout<<endl;
 cout<<"\t到达时间：";
 for(int i=0; i<5; i++)
 {
  cout<<"\t"<<pcb[i].arrive;
 }
 cout<<endl;
 cout<<"\t服务时间：";
 for(int i=0; i<5; i++)
 {
  cout<<"\t"<<pcb[i].service;
 }
 cout<<endl;
 cout<<endl;
 int finish = 0;//当前时间，初始化为0
 sort(pcb,pcb+5,cmp);
 int sum_turnover = 0;
 double sum_author_turnover = 0.0;
 for(int i=0; i<5; i++)
 {
  if(pcb[i].arrive>finish)
   pcb[i].end = pcb[i].arrive+pcb[i].service;
  else
   pcb[i].end = pcb[i].service+finish;
  finish = pcb[i].end;
  pcb[i].turnover = pcb[i].end-pcb[i].arrive;//周转时间=完成时间-到达时间
  pcb[i].start = pcb[i].end-pcb[i].service;
  pcb[i].author_turnover = double(pcb[i].turnover)/pcb[i].service;//带权周转时间=周转时间/服务时间
  sum_turnover+=pcb[i].turnover;
  sum_author_turnover+=pcb[i].author_turnover;
  fcfs.push_back(pcb[i]);
 }

 //过程
 int cpu = 0;
 int f[5] = {0};//初始化为0，代表不占用
 while(1)
 {
  if(cpu==pcb[4].end)
  {
   cout<<"\t"<<pcb[4].end<<" "<<"进程"<<pcb[4].pname<<"结束\n"<<endl;
   break;
  }
  for(int i=0; i<5; i++)
  {
   if(pcb[i].arrive==cpu)
   {
    cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"到达内存\n"<<endl;
   }
  }
  for(int i=0; i<5; i++)
  {
   if((pcb[i].start==cpu&&i==0)||(pcb[i].start==cpu&&f[i-1]==0))
   {
    f[i]=1;//占用cpu
    cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"开始执行\n"<<endl;
    Sleep(pcb[i].service*100);
   }
   if(pcb[i].end==cpu)
   {
    cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"结束\n"<<endl;
    f[i]=0;//解除占用cpu
   }
  }
  cpu++;
 }

 //计算
 double avg_turnover = (double)sum_turnover/5;
 double avg_author_turnover = (double)sum_author_turnover/5;
 cout<<"\t进程名\t\t"<<"到达时间\t"<<"服务时间\t"<<"完成时间\t"<<"周转时间\t"<<"带权周转"<<endl;
 for(int i=0; i<5; i++)
 {
  cout<<"\t"<<pcb[i].pname<<"\t\t"<<pcb[i].arrive<<"\t\t"<<pcb[i].service<<"\t\t"<<pcb[i].end<<"\t\t"<<pcb[i].turnover<<"\t\t";
  printf("%.2lf\n",pcb[i].author_turnover);
 }
 printf("\t平均周转时间：%.2lf\t",avg_turnover);
 fcfs_turnover=avg_turnover;
 printf("\t平均带权周转时间：%.2lf\n",avg_author_turnover);
 fcfs_author=avg_author_turnover;
 system("pause");
 system("cls");
}



void SJF()
{
 system("cls");
 cout<<"短作业优先调度算法！"<<endl;
 //打印
 cout<<"\n\n";
 cout<<"\t 进程名：";
 for(int i=0; i<5; i++)
 {
  cout<<"\t"<<pcb[i].pname;
 }
 cout<<endl;
 cout<<"\t到达时间：";
 for(int i=0; i<5; i++)
 {
  cout<<"\t"<<pcb[i].arrive;
 }
 cout<<endl;
 cout<<"\t服务时间：";
 for(int i=0; i<5; i++)
 {
  cout<<"\t"<<pcb[i].service;
 }
 cout<<endl;
 cout<<endl;

 int i,j=0,finish=0;//j为当前就绪队列的末尾指针 
 sort(pcb,pcb+5,cmp);//排序

// for(int i=0;i<5;i++)
//  cout<<pcb[i].pname; 测试排序是否正确
 int sum_turnover = 0;
 double sum_author_turnover = 0.0;
 for(int i=0; i<5; i++)
 {
  while(j<5&&pcb[j].arrive<=finish)//当有新的进程的进入时间小于当前时间，就加入就绪队列 
   j++;
  sort(pcb+i,pcb+j,cmp1); 
  if(pcb[i].arrive>finish)
   pcb[i].end = pcb[i].arrive+pcb[i].service;
  else
   pcb[i].end = pcb[i].service+finish;
  finish = pcb[i].end;
  pcb[i].turnover = pcb[i].end-pcb[i].arrive;//周转时间=完成时间-到达时间
  pcb[i].start = pcb[i].end-pcb[i].service;
  pcb[i].author_turnover = double(pcb[i].turnover)/pcb[i].service;//带权周转时间=周转时间/服务时间
  sum_turnover+=pcb[i].turnover;
  sum_author_turnover+=pcb[i].author_turnover;
  sjf.push_back(pcb[i]);
 }
 
 //过程
 int cpu = 0;
 int f[5] = {0};//初始化为0，代表不占用
 while(1)
 {
  if(cpu==pcb[4].end)
  {
   cout<<"\t"<<pcb[4].end<<" "<<"进程"<<pcb[4].pname<<"结束\n"<<endl;
   break;
  }
  for(int i=0; i<5; i++)
  {
   if(pcb[i].arrive==cpu)
   {
    cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"到达内存\n"<<endl;
   }
  }
  for(int i=0; i<5; i++)
  {
   if((pcb[i].start==cpu&&i==0)||(pcb[i].start==cpu&&f[i-1]==0))
   {
    f[i]=1;//占用cpu
    cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"开始执行\n"<<endl;
    Sleep(pcb[i].service*100);
   }
   if(pcb[i].end==cpu)
   {
    cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"结束\n"<<endl;
    f[i]=0;//解除占用cpu
   }
  }
  cpu++;
 }
 
 
 //计算
 double avg_turnover = (double)sum_turnover/5;
 double avg_author_turnover = (double)sum_author_turnover/5;
 cout<<"\t进程名\t\t"<<"到达时间\t"<<"服务时间\t"<<"完成时间\t"<<"周转时间\t"<<"带权周转"<<endl;
 for(int i=0; i<5; i++)
 {
  cout<<"\t"<<pcb[i].pname<<"\t\t"<<pcb[i].arrive<<"\t\t"<<pcb[i].service<<"\t\t"<<pcb[i].end<<"\t\t"<<pcb[i].turnover<<"\t\t";
  printf("%.2lf\n",pcb[i].author_turnover);
 }
 printf("\t平均周转时间：%.2lf\t",avg_turnover);
 sjf_turnover=avg_turnover;
 printf("\t平均带权周转时间：%.2lf\n",avg_author_turnover);
 sjf_author=avg_author_turnover;
 system("pause");
 system("cls");
}

void init()
{
 cout<<endl;
// for(int i=0;i<5;i++)
// {
//  pcb[i].pid = i;
//  cout<<"进程："<<i<<endl;
//  cout<<"进程名：";
//  cin>>pcb[i].pname;
//  cout<<"到达时间：";
//  cin>>pcb[i].arrive;
//  cout<<"服务时间：";
//  cin>>pcb[i].service;
//  cout<<endl;
// }
 pcb[0].pname='A';
 pcb[0].arrive=0;
 pcb[0].service=3;

 pcb[1].pname='B';
 pcb[1].arrive=4;
 pcb[1].service=6;

 pcb[2].pname='C';
 pcb[2].arrive=4;
 pcb[2].service=4;

 pcb[3].pname='D';
 pcb[3].arrive=6;
 pcb[3].service=5;

 pcb[4].pname='E';
 pcb[4].arrive=8;
 pcb[4].service=2;
 system("cls");
}

void menu()
{
 cout<<endl;
 cout<<endl;
 cout<<"\t   进程调度模拟程序"<<endl;
 cout<<endl;
 cout<<"\t1. 输入作业情况"<<endl;
 cout<<endl;
 cout<<"\t2. 显示作业情况"<<endl;
 cout<<endl;
 cout<<"\t3. 先来先服务算法"<<endl;
 cout<<endl;
 cout<<"\t4. 短作业优先算法"<<endl;
 cout<<endl;
 cout<<"\t5. 高响应比优先算法"<<endl;
 cout<<endl;
 cout<<"\t6. 算法结果对比"<<endl;
 cout<<endl;
 cout<<"\t0. 退出"<<endl;
 cout<<endl;
 cout<<"请输入选择:";
}

void HRRN()
{
 system("cls");
 cout<<"高响应比调度算法！"<<endl;
 //打印
 cout<<"\n\n";
 cout<<"\t 进程名：";
 for(int i=0; i<5; i++)
 {
  cout<<"\t"<<pcb[i].pname;
 }
 cout<<endl;
 cout<<"\t到达时间：";
 for(int i=0; i<5; i++)
 {
  cout<<"\t"<<pcb[i].arrive;
 }
 cout<<endl;
 cout<<"\t服务时间：";
 for(int i=0; i<5; i++)
 {
  cout<<"\t"<<pcb[i].service;
 }
 cout<<endl;
 cout<<endl;
 int sum_turnover = 0;
 double sum_author_turnover = 0.0;
 int j=0;
 int finish=0;
 sort(pcb, pcb+5, cmp);
 for(int i = 0; i < 5; i++)
 {
  while(j<5 && pcb[j].arrive <= finish)
   j++;
  for(int k = i; k < j; k++)
   pcb[k].priority = (finish-pcb[k].arrive+pcb[k].service) / pcb[k].service;
  sort(pcb+i, pcb+j, cmp2);

  if(pcb[i].arrive > finish)
   pcb[i].end = pcb[i].arrive + pcb[i].service;
  else
   pcb[i].end = finish + pcb[i].service;
  pcb[i].turnover = pcb[i].end - pcb[i].arrive;
  finish = pcb[i].end;
  pcb[i].start = pcb[i].end-pcb[i].service;
  pcb[i].author_turnover = double(pcb[i].turnover)/pcb[i].service;//带权周转时间=周转时间/服务时间
  sum_turnover+=pcb[i].turnover;
  sum_author_turnover+=pcb[i].author_turnover;
  hrrn.push_back(pcb[i]);
 }
 
 
 //过程
 int cpu = 0;
 int f[5] = {0};//初始化为0，代表不占用
 while(1)
 {
  if(cpu==pcb[4].end)
  {
   cout<<"\t"<<pcb[4].end<<" "<<"进程"<<pcb[4].pname<<"结束\n"<<endl;
   break;
  }
  for(int i=0; i<5; i++)
  {
   if(pcb[i].arrive==cpu)
   {
    cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"到达内存\n"<<endl;
   }
  }
  for(int i=0; i<5; i++)
  {
   if((pcb[i].start==cpu&&i==0)||(pcb[i].start==cpu&&f[i-1]==0))
   {
    f[i]=1;//占用cpu
    cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"开始执行\n"<<endl;
    Sleep(pcb[i].service*100);
   }
   if(pcb[i].end==cpu)
   {
    cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"结束\n"<<endl;
    f[i]=0;//解除占用cpu
   }
  }
  cpu++;
 }
 
 //计算
 double avg_turnover = (double)sum_turnover/5;
 double avg_author_turnover = (double)sum_author_turnover/5;
 cout<<"\t进程名\t\t"<<"到达时间\t"<<"服务时间\t"<<"完成时间\t"<<"周转时间\t"<<"带权周转"<<endl;
 for(int i=0; i<5; i++)
 {
  cout<<"\t"<<pcb[i].pname<<"\t\t"<<pcb[i].arrive<<"\t\t"<<pcb[i].service<<"\t\t"<<pcb[i].end<<"\t\t"<<pcb[i].turnover<<"\t\t";
  printf("%.2lf\n",pcb[i].author_turnover);
 }
 printf("\t平均周转时间：%.2lf\t",avg_turnover);
 hrrn_turnover=avg_turnover;
 printf("\t平均带权周转时间：%.2lf\n",avg_author_turnover);
 hrrn_author=avg_author_turnover;
 system("pause");
 system("cls");
}

int main()
{
 int flag=1;
 while(1)
 {
  menu();
  int sel;
  cin>>sel;
  switch(sel)
  {
   case 1:
    init();
    break;
   case 2:
    print();
    break;
   case 3:
    FCFS();
    break;
   case 4:
    SJF();
    break;
   case 5:
    HRRN();
    break;
   case 6:
    Compare();
    break;
   case 0:
    exit(0);
  }
 }
 return 0;
}

4.运行结果分析

展示及显示作业情况
在这里插入图片描述

5.先来先服务算法

在这里插入图片描述

6.短作业优先算法

在这里插入图片描述

7.高响应优先算法

在这里插入图片描述

8.算法结果对比

在这里插入图片描述

总结

以上是今天要讲的内容，练习了进程调度算法。

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Mysql：重点且常用的操作和理论知识整理 ^_^

Mysql：重点且常用的操作和理论知识整理 ^_^

目录 1 基础的命令操作 2 DDL 数据库定义语言 2.1 数据库操作 2.2 数据表操作 2.2.1 创建数据表 2.2.2 修改和删除数据表 2.2.3 添加外键 3 DML 数据库操作语言 3.1 插入语句(INSERT) 3.2 修改语句(UPDATE) 3.3 删除语句 3.3.1 DELETE命令 3.3.2 TRUNCATE命令 4 …
阅读更多...
java.sql.SQLException: Failed to fetch schema of XXX 问题

java.sql.SQLException: Failed to fetch schema of XXX 问题

遇到问题&#xff1a;java.sql.SQLException: Failed to fetch schema of pay_record表 i.s.r.d.s.s.c.AbstractTableMetaCache : get table meta of the table pay_record error: Failed to fetch schema of pay_record 原因分析&#xff1a; springcloud项目中使用了se…
阅读更多...
Yaklang 中的类型和变量

Yaklang 中的类型和变量

Yaklang 的类型其实非常简单&#xff0c;我们仅需要记住如下类型即可 string 字符串类型&#xff0c;用以快速构建一个字符串int 整数类型&#xff1a;在 64 位机中&#xff0c;int 和 int64 是一样的float 浮点类型&#xff0c;用来定义和表示浮点数byte 本质上等同于 uint8u…
阅读更多...
docker安装marcocesarato/php-conventional-changelog报错

docker安装marcocesarato/php-conventional-changelog报错

composer require --dev marcocesarato/php-conventional-changelog --no-update “marcocesarato/php-conventional-changelog”: “^1.17” 在小皮环境没问题&#xff0c;在dockerswoole环境下报错 "scripts": {"changelog": "conventional-chang…
阅读更多...
采用云端SaaS服务的云HIS基层医院信息管理系统源码

采用云端SaaS服务的云HIS基层医院信息管理系统源码

目录 一、日常运维工作内容 二、科室巡查工作 三、网络安全管理工作内容 四、业务能力提升学习 云HIS系统业务 一、日常运维工作内容 1. 系统监控&#xff1a;每天早晨第一件事就是打开电脑&#xff0c;查看各个系统的运行状况。通过监控系统&#xff0c;可以实时了解到服…
阅读更多...
大数据质量管制规范示例

大数据质量管制规范示例

大数据质量管制规范示例 一、前提概要二、相关概念三、管理原则四、治理委员五、应用管理六、查验方式七、考核比率八、扣分标准九、责任划分十、追责范围十一、其它条例十二、总结 一、前提概要 在当今大数据信息时代&#xff0c;大数据平台&#xff08;大数据平台开发规范示…
阅读更多...
【ChatGPT】利用ChatGPT将图片转换成JSON文件

【ChatGPT】利用ChatGPT将图片转换成JSON文件

前言 我在创建自己的GPT时，通常会上传一些JSON文件作为知识库，我还制作了一些脚本工具，将PDF文件转换成JSON文件。但是在这个过程中产生一个问题，PDF文件中会有一些图表，JSON文件就不能存储和表达这些图表的内容了。那该怎么办呢？这里跟大家介绍一个方法，可以有效地将图…
阅读更多...
【论文笔记】Fully Sparse 3D Panoptic Occupancy Prediction

【论文笔记】Fully Sparse 3D Panoptic Occupancy Prediction

原文链接&#xff1a;https://arxiv.org/abs/2312.17118 1. 引言 现有的3D占用预测方法建立密集的3D特征&#xff0c;没有考虑场景的稀疏性&#xff0c;因此难以满足实时要求。此外&#xff0c;这些方法仅关注语义占用&#xff0c;无法区分实例。 本文认为场景的稀疏性包含两…
阅读更多...
查询指定日期是否为法定工作日的服务接口

查询指定日期是否为法定工作日的服务接口

在现代社会中&#xff0c;人们的工作与生活节奏日益加快&#xff0c;为了更好地规划工作与休息时间&#xff0c;在开发应用软件时&#xff0c;通过查询指定日期是否为法定工作日的服务接口是一个非常有用的功能。本文将介绍一个API接口&#xff0c;可以根据国家的放假安排来判断…
阅读更多...
Schema Builder - Salesforce的图形化工具

Schema Builder - Salesforce的图形化工具

Schema Builder这个工具最近几年接触Salesforce的宝们用到的很少&#xff0c;这里给大家简单介绍下&#xff1a; 1. Schema Builder是一个动态的环境&#xff0c;在这个环境里管理员能查看或更改组织内对象及对象之间的关联关系&#xff1b;如果一开始接触CRM可以通过这个图形…
阅读更多...
JVM：垃圾收集器（7种）

JVM：垃圾收集器（7种）

垃圾收集器关系图&#xff1a; 如果两个收集器之间存在连线&#xff0c;就说明它们可以搭配使用。它们说在的区域则表示这个收集器属于新生代收集器还是老年代收集器。其中Serial&#xff08;串行&#xff09;、Parallel&#xff08;并行&#xff09; 1、Serial收集器 Serial收…
阅读更多...
F - Digital Roots HUOJ

F - Digital Roots HUOJ

题目 The digital root of a positive integer is found by summing the digits of the integer. If the resulting value is a single digit then that digit is the digital root. If the resulting value contains two or more digits, those digits are summed and the pro…
阅读更多...
Spring Boot 学习之——@SpringBootApplication注解(自动注解原理)

Spring Boot 学习之——@SpringBootApplication注解(自动注解原理)

SpringBootApplication注解 springboot是基于spring的新型的轻量级框架&#xff0c;最厉害的地方当属**自动配置。**那我们就可以根据启动流程和相关原理来看看&#xff0c;如何实现传奇的自动配置 SpringBootApplication//标注在某个类上&#xff0c;表示这个类是SpringBoot…
阅读更多...
大数据开发之Kafka（broker、消费者、eagle监控、kraft模式）

大数据开发之Kafka（broker、消费者、eagle监控、kraft模式）

第 4 章&#xff1a;Kafka Broker 4.1 Kafka Broker工作流程 4.1.1 Zookeeper存储的Kafka的信息 1、查看zookeeper中的kafka节点所存储的信息 启动Zookeeper客户端 [atguiguhadoop104 zookeeper-3.5.7]$ bin/zkCli.sh 通过ls命令列出kafka节点内容 [zk: localhost:2181(CO…
阅读更多...
Docker（六）数据管理

Docker（六）数据管理

作者主页&#xff1a; 正函数的个人主页 文章收录专栏&#xff1a; Docker 欢迎大家点赞 &#x1f44d; 收藏 ⭐ 加关注哦&#xff01; Docker 数据管理 这一章介绍如何在 Docker 内部以及容器之间管理数据&#xff0c;在容器中管理数据主要有两种方式&#xff1a; 数据卷&…
阅读更多...
【Java】JDBC练习

【Java】JDBC练习

JDBC练习 环境准备 -- 删除tb_brand表 drop table if exists tb_brand; -- 创建tb_brand表 create table tb_brand (-- id 主键id int primary key auto_increment,-- 品牌名称brand_name varchar(20),-- 企业名称company_name varchar(20),-- 排序字段ordered …
阅读更多...
Flink处理函数（3）—— 窗口处理函数

Flink处理函数（3）—— 窗口处理函数

窗口处理函数包括&#xff1a;ProcessWindowFunction 和 ProcessAllWindowFunction 基础用法 stream.keyBy( t -> t.f0 ).window( TumblingEventTimeWindows.of(Time.seconds(10)) ).process(new MyProcessWindowFunction()) 这里的MyProcessWindowFunction就是ProcessWi…
阅读更多...
STM32 GD32 瑞萨 psoc 等单片机 无线wifi蓝牙最佳解决方案

STM32 GD32 瑞萨 psoc 等单片机 无线wifi蓝牙最佳解决方案

新联鑫威一系列低功耗高性价比sdio wifi/蓝牙combo的模块CYWL6208 , CYWL6312, CYW6209等可以搭配stm32 各种型号例如以下,支持sta/ap/apsta&#xff0c;双模蓝牙的应用&#xff0c;支持rt-thread, freertos, Azure RTOS, Linux, Android系统. 稳定强&#xff0c;功耗低&#x…
阅读更多...
从规则到神经网络：机器翻译技术的演化之路

从规则到神经网络：机器翻译技术的演化之路

文章目录 从规则到神经网络&#xff1a;机器翻译技术的演化之路一、概述1. 机器翻译的历史与发展2. 神经机器翻译的兴起3. 技术对现代社会的影响 二、机器翻译的核心技术1. 规则基础的机器翻译&#xff08;Rule-Based Machine Translation, RBMT&#xff09;2. 统计机器翻译&am…
阅读更多...
[ELK] ELK企业级日志分析系统

[ELK] ELK企业级日志分析系统

一、ELK 概述 1.1 ELK 简介与组件 ELK平台是一套完整的日志集中处理解决方案&#xff0c;将 ElasticSearch、Logstash 和 Kiabana 三个开源工具配合使用&#xff0c; 完成更强大的用户对日志的查询、排序、统计需求。 ●ElasticSearch&#xff1a;是基于Lucene&#xff08;一个…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023