当前位置：首页 > news >正文

实验四进程调度实验

news 2025/4/29 4:32:04

一、实验目的

1、了解操作系统CPU管理的主要内容。

2、加深理解操作系统管理控制进程的数据结构--PCB。

3、掌握几种常见的CPU调度算法（FCFS、SJF、HRRF、RR）的基本思想和实现过程。

4、用C语言模拟实现CPU调度算法。

5、掌握CPU调度算法性能评价指标的计算方法。

6、通过对进程调度算法的模拟加深对进程概念和进程调度算法的理解。

二、实验内容

1、用C语言编写程序，模拟单处理器下先来先服务算法FCFS，要求显示各进程的到达时间、服务时间、完成时间，周转时间以及该算法的平均周转时间和平均带权周转时间。运行以下参考程序，给出结果截图并分析该算法的优缺点。（3分）

参考程序：

#include <stdio.h>

#include <stdlib.h>

struct PCB //先来先服务FCFS

{

char name[10]; //进程名

float arrivetime; //到达时间

float servetime; //服务时间

float finishtime; //完成时间

float roundtime; //周转时间

float daiquantime; //带权周转时间

};

struct PCB a[50];//定义进程数组

struct PCB *sortarrivetime(struct PCB a[], int n);//声明到达时间冒泡排序函数

void FCFS(struct PCB a[],int n,float *t1,float *t2);//先来先服务算法

//按到达时间进行冒泡排序

struct PCB *sortarrivetime(struct PCB a[], int n){

int i, j;

struct PCB t;

int flag; //标志变量，记录在每一趟冒泡中是否有元素交换，没有交换则结束冒泡

for (i = 1; i<n; i++) //外层循环控制比较趟数

{

flag = 0; //初始值设置为0

for (j = 0; j<n - i; j++) //内存循环控制每一趟的比较次数

{

if (a[j].arrivetime>a[j + 1].arrivetime) //将到达时间短的交换到前边

{

t = a[j];

a[j] = a[j + 1];

a[j + 1] = t;

flag = 1; //有交换，flag置1

}

if (flag == 0)//如果一趟排序中没发生任何交换，则排序结束

{

break;

}

return a; //返回排序后进程数组

}

//先来先服务算法

void FCFS(struct PCB a[],int n,float *t1,float *t2)

{

int i;

a[0].finishtime = a[0].arrivetime + a[0].servetime; //完成时间=到达时间+服务时间

a[0].roundtime = a[0].finishtime - a[0].arrivetime; //周转时间=完成时间-到达时间

a[0].daiquantime = a[0].roundtime / a[0].servetime; //带权时间=周转时间/服务时间

for (i = 1; i<n; i++)

{

if (a[i].arrivetime<a[i-1].finishtime)//当前到达时间在上一个作业结束时间之前

{

a[i].finishtime = a[i-1].finishtime + a[i].servetime;//完成时间=上一个完成时间+服务时间

a[i].roundtime = a[i].finishtime - a[i].arrivetime; //周转时间=完成时间-到达时间

a[i].daiquantime = a[i].roundtime / a[i].servetime; //带权时间=周转时间/服务时间

}

else //当前到达时间在上一个作业结束时间之后

{

a[i].finishtime = a[i].arrivetime + a[i].servetime;//完成时间=到达时间+服务时间

a[i].roundtime = a[i].finishtime - a[i].arrivetime; //周转时间=完成时间-到达时间

a[i].daiquantime = a[i].roundtime / a[i].servetime;//带权时间=周转时间/服务时间

}

printf("=============================================================\n");

printf("进程相关信息如下：\n\n");

printf("进程名 ");

printf("到达时间 ");

printf("服务时间 ");

printf("完成时间 ");

printf("周转时间 ");

printf("带权周转时间\n");

for (i = 0;i<n;i++)

{

printf("%-10s",a[i].name);

printf("%-10.0f",a[i].arrivetime);

printf("%-10.0f",a[i].servetime);

printf("%-10.0f",a[i].finishtime);

printf("%-10.0f",a[i].roundtime);

printf("%10.2f\n",a[i].daiquantime);

*t1 += a[i].roundtime;

*t2 += a[i].daiquantime;

}

int main()

{

float t1 ; //总周转时间

float t2 ; //总带权周转时间

float avr_t1 ; //平均周转时间

float avr_t2 ; //平均带权周转时间

int n, i;

char select = ' '; //选择算法变量标识

while (select != '2') //不为退出标识，保持循环

{

t1 = 0.0f;

t2 = 0.0f;

system("clear");

printf("\n请选择算法：1.先来先服务算法 2.退出程序\n\n请输入选择: ");

scanf("%c", &select);

if (select == '1') //先来先服务算法

{

printf("\n=====================先来先服务算法FCFS=====================\n\n");

printf("请输入进程数：");

scanf("%d", &n);

for (i = 0; i<n; i++)

{

printf("%d 进程名:", i + 1);

scanf("%s", a[i].name);

printf("到达时间：");

scanf("%f", &a[i].arrivetime);

printf("服务时间：");

scanf("%f", &a[i].servetime);

}

getchar();

sortarrivetime(a, n);//按到达时间先后进行冒泡排序

FCFS(a,n,&t1,&t2); //先来先服务算法

avr_t1 = t1 / n;

avr_t2 = t2 / n;

printf("\n");

printf("平均周转时间为：%2.2f\n", avr_t1);

printf("平均带权周转时间为：%2.2f\n", avr_t2);

getchar();

}

else if (select == '2')

{

exit(0);

}

else

{

printf("please enter right choose!\n");

}

return 0;

}

请同学按下列给出的数据测试运行结果：

进程	到达时间	服务时间
P1	0	4
P2	1	6
P3	2	3
P4	3	1
P5	7	2

要求给出编译及运行过程和运行结果：

分析该算法优缺点：

优点：

简单易实现，容易理解和掌握。
公平性较高，先到达的进程先被服务，避免了饥饿问题。
适用于短作业或者作业到达时间分布均匀的情况。

缺点：

无法考虑作业的优先级，如果有高优先级的作业到达，可能会导致低优先级作业等待时间较长。
依赖于作业到达时间的顺序，如果到达时间相同，则先被调度的作业将占据资源，导致其他作业等待时间增加。
无法充分利用资源，忙等问题较为明显。

编程实现最短作业优先算法 SJF。（3分）

参考程序框架：

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

struct PCB

{

char name[10]; //进程名

float arrivetime; //到达时间

float servetime; //服务时间

float finishtime; //完成时间

float roundtime; //周转时间

float daiquantime; //带权周转时间

};

struct PCB a[50];//初始化指针和数组

struct PCB *sortarrivetime(struct PCB a[], int n);//声明到达时间冒泡排序函数

void SJF(struct PCB a[], int n, float *t1, float *t2);//声明短作业优先算法函数

struct PCB *sortarrivetime(struct PCB a[], int n)

{

int i, j;

struct PCB t;

int flag; //标志变量，记录在每一趟冒泡中是否有元素交换，没有交换则结束冒泡

for (i = 1; i < n; i++) //外层循环控制比较趟数

{

flag = 0; //初始值设置为0

for (j = 0; j < n - i; j++) //内存循环控制每一趟的比较次数

{

if (a[j].arrivetime > a[j + 1].arrivetime) //将到达时间短的交换到前边

{

t = a[j];

a[j] = a[j + 1];

a[j + 1] = t;

flag = 1; //有交换，flag置1

}

if (flag == 0)//如果一趟排序中没发生任何交换，则排序结束

{

break;

}

return a; //返回排序后进程数组

}

//短作业优先算法

void SJF(struct PCB a[], int n, float *t1, float *t2)

{

int i, c, d;

struct PCB t;

a[0].finishtime = a[0].arrivetime + a[0].servetime; //完成时间=到达时间+服务时间

a[0].roundtime = a[0].finishtime - a[0].arrivetime; //周转时间=完成时间-提交时间

a[0].daiquantime = a[0].roundtime / a[0].servetime; //带权时间=周转时间/服务时间

for (i = 1; i < n; i++)

{

for (c = i; c < n - 1; c++)

{

for (d = c + 1; d < n; d++) //d=i+1改成d=c+1

{

if ((a[i - 1].finishtime >= a[c].arrivetime) && (a[i - 1].finishtime >= a[d].arrivetime) && (a[c].servetime > a[d].servetime))

{

t = a[c];

a[c] = a[d];

a[d] = t;

}

if (a[i].arrivetime < a[i - 1].finishtime) //当前到达时间在上一个作业结束时间之前

{

a[i].finishtime = a[i - 1].finishtime + a[i].servetime;

}

else //当前到达时间在上一个作业结束时间之后

{

a[i].finishtime = a[i].arrivetime + a[i].servetime;

}

a[i].roundtime = a[i].finishtime - a[i].arrivetime;

a[i].daiquantime = a[i].roundtime / a[i].servetime;

}

printf("=============================================================\n");

printf("进程相关信息如下：\n\n");

printf("进程名 ");

printf("到达时间 ");

printf("服务时间 ");

printf("完成时间 ");

printf("周转时间 ");

printf("带权周转时间\n");

for (i = 0; i < n; i++)

{

printf("%-10s", a[i].name);

printf("%-10.0f", a[i].arrivetime);

printf("%-10.0f", a[i].servetime);

printf("%-10.0f", a[i].finishtime);

printf("%-10.0f", a[i].roundtime);

printf("%10.2f\n", a[i].daiquantime);

*t1 += a[i].roundtime;

*t2 += a[i].daiquantime;

}

int main()

{

float t1; //总周转时间

float t2; //总带权周转时间

float avr_t1; //平均周转时间

float avr_t2; //平均带权周转时间

int n, i;

char select = ' '; //选择算法变量标识

while (select != '2') //不为退出标识，保持循环

{

t1 = 0.0f;

t2 = 0.0f;

system("clear");

printf("请选择算法：1.短作业优先算法 2.退出程序\n\n请输入选择: ");

scanf(" %c", &select);

if (select == '1') //短作业优先算法

{

printf("\n=====================短作业优先算法SJF=====================\n\n");

printf("请输入进程数：");

scanf("%d", &n);

for (i = 0; i < n; i++)

{

printf("%d 进程名:", i + 1);

scanf("%s", a[i].name);

printf("到达时间：");

scanf("%f", &a[i].arrivetime);

printf("服务时间：");

scanf("%f", &a[i].servetime);

}

getchar();

a[n] = *sortarrivetime(a, n);

SJF(a, n, &t1, &t2); //调短作业优先算法

avr_t1 = t1 / n; //平均周转时间

avr_t2 = t2 / n; //平均带权周转时间

printf("\n");

printf("平均周转时间为：%2.2f \n", avr_t1);

printf("平均带权周转时间为：%2.2f \n", avr_t2);

getchar();

}

else if (select == '2')

{

exit(0);

}

else

{

printf("please enter right choose!\n");

getchar();

}

return 0;

}编译及执行过程以及结果截屏：

分析该算法的优缺点：

优点：

可以保证平均等待时间最短，能够实现较高的系统运行效率。
由于短作业先执行，可以减少平均周转时间和平均等待时间，提高系统的响应速度。
可以确保最短的作业最先得到服务，从而避免了长作业占用系统资源的情况。
相对简单、容易实现。

缺点：

需要预先知道每个作业的估计运行时间，而实际的运行时间往往是未知的，这对于实际系统来说是很难预测的。
对于长作业来说，可能导致其长时间得不到服务，从而造成长作业的饥饿现象。
对于作业的估计运行时间要求较高，如果估计不准确，可能导致优先级排序错误，进一步影响系统的性能。
对于作业的到达时间不敏感，如果作业的到达时间不同，可能会出现饥饿现象或者长作业等待时间增加的情况。

3.编程实现最高响应比优先算法HRN，并分析该算法的优缺点。（要求给出程序设计分析和调试通过的程序，并给出编译，运行步骤和执行结果截图。）（3分）

编程程序：

#include <stdio.h>

#include <stdlib.h>

struct PCB {

char name[10]; // 进程名

float arrivetime; // 到达时间

float servetime; // 服务时间

float finishtime; // 完成时间

float roundtime; // 周转时间

float daiquantime; // 带权周转时间

float response_ratio; // 响应比

};

struct PCB a[50]; // 初始化指针和数组

struct PCB *sortarrivetime(struct PCB a[], int n); // 声明到达时间冒泡排序函数

void HRN(struct PCB a[], int n, float *t1, float *t2); // 声明最高响应比优先算法函数

// 按到达时间进行冒泡排序

struct PCB *sortarrivetime(struct PCB a[], int n)

{ int i, j;

struct PCB t;

int flag; //标志变量，记录在每一趟冒泡中是否有元素交换，没有交换则结束冒泡

for (i = 1; i<n; i++) //外层循环控制比较趟数

{

flag = 0; //初始值设置为0

for (j = 0; j<n - i; j++) //内存循环控制每一趟的比较次数

{

if (a[j].arrivetime>a[j + 1].arrivetime) //将到达时间短的交换到前边

{

t = a[j];

a[j] = a[j + 1];

a[j + 1] = t;

flag = 1; //有交换，flag置1

}

if (flag == 0)//如果一趟排序中没发生任何交换，则排序结束

{

break;

}

return a; //返回排序后进程数组

}

// 最高响应比优先算法

void HRN(struct PCB a[], int n, float *t1, float *t2) {

int i, j, max_idx;

float max_ratio;

struct PCB temp;

a[0].finishtime = a[0].arrivetime + a[0].servetime; // 完成时间=到达时间+服务时间

a[0].roundtime = a[0].finishtime - a[0].arrivetime; // 周转时间=完成时间-到达时间

a[0].daiquantime = a[0].roundtime / a[0].servetime; // 带权时间=周转时间/服务时间

*t1 += a[0].roundtime;

*t2 += a[0].daiquantime;

for (i = 1; i < n; i++) {

max_ratio = 0.0;

max_idx = -1;

for (j = i; j < n; j++) {

a[j].response_ratio = (a[i - 1].finishtime - a[j].arrivetime + a[j].servetime) / a[j].servetime;

if (a[j].response_ratio > max_ratio) {

max_ratio = a[j].response_ratio;

max_idx = j;

}

temp = a[i];

a[i] = a[max_idx];

a[max_idx] = temp;

if (a[i].arrivetime < a[i - 1].finishtime) { // 当前到达时间在上一个作业结束时间之前

a[i].finishtime = a[i - 1].finishtime + a[i].servetime;

a[i].roundtime = a[i].finishtime - a[i].arrivetime;

a[i].daiquantime = a[i].roundtime / a[i].servetime;

} else { // 当前到达时间在上一个作业结束时间之后

a[i].finishtime = a[i].arrivetime + a[i].servetime;

a[i].roundtime = a[i].finishtime - a[i].arrivetime;

a[i].daiquantime = a[i].roundtime / a[i].servetime;

}

*t1 += a[i].roundtime;

*t2 += a[i].daiquantime;

}

printf("=============================================================\n");

printf("进程相关信息如下：\n\n");

printf("进程名 ");

printf("到达时间 ");

printf("服务时间 ");

printf("完成时间 ");

printf("周转时间 ");

printf("带权周转时间\n");

for (i = 0; i < n; i++) {

printf("%-10s", a[i].name);

printf("%-10.0f", a[i].arrivetime);

printf("%-10.0f", a[i].servetime);

printf("%-10.0f", a[i].finishtime);

printf("%-10.0f", a[i].roundtime);

printf("%10.2f\n", a[i].daiquantime);

}

int main() {

float t1; // 总周转时间

float t2; // 总带权周转时间

float avr_t1; // 平均周转时间

float avr_t2; // 平均带权周转时间

int n, i;

char select = ' '; // 选择算法变量标识

while (select != '2') { // 不为退出标识，保持循环

t1 = 0.0f;

t2 = 0.0f;

system("clear");

printf("请选择算法：1.最高响应比优先算法 2.退出程序\n\n请输入选择: ");

scanf("%c", &select);

if (select == '1') { // 最高响应比优先算法

printf("\n=====================最高响应比优先算法HRN=====================\n\n");

printf("请输入进程数：");

scanf("%d", &n);

for (i = 0; i < n; i++) {

printf("%d 进程名:", i + 1);

scanf("%s", a[i].name);

printf("到达时间：");

scanf("%f", &a[i].arrivetime);

printf("服务时间：");

scanf("%f", &a[i].servetime);

}

getchar();

sortarrivetime(a, n); // 按到达时间进行冒泡排序

HRN(a, n, &t1, &t2); // 调用最高响应比优先算法

avr_t1 = t1 / n; // 平均周转时间

avr_t2 = t2 / n; // 平均带权周转时间

printf("\n");

printf("平均周转时间为：%2.2f \n", avr_t1);

printf("平均带权周转时间为：%2.2f \n", avr_t2);

getchar();

} else if (select == '2') {

exit(0);

} else {

printf("please enter right choose!\n");

getchar();

}

return 0;

}

分析该算法的优缺点：

优点：

能够保证每个作业都有机会执行，避免了作业饥饿的情况。
能够根据当前作业的响应比来决定下一个执行的作业，可以有效地提高作业的响应速度。
能够根据作业的响应比来动态调整作业的执行顺序，使得高响应比的作业能够更早执行，提高系统的整体性能。

缺点：

需要计算每个作业的响应比，这涉及到对作业的运行时间和等待时间的估计，因此计算复杂度较高。
不能满足实时性要求，因为它只关注作业的响应比而不考虑截止时间。

编程实现时间片轮换算法，并分析算法的优缺点。（要求给出程序设计分析和调试通过的程序，并给出编译，运行步骤和执行结果截图。）（附加题）

编程程序：

#include <stdio.h>

#include <stdlib.h>

struct PCB //定义进程控制块

{

char name[10]; //进程名

float arrivetime; //到达时间

float servetime; //服务时间

float finishtime; //完成时间

float roundtime; //周转时间

float daiquantime; //带权周转时间

};

struct PCB a[50];//定义进程数组

struct PCB *sortarrivetime(struct PCB a[], int n);//声明到达时间冒泡排序函数

void RR(struct PCB a[], int n, float qt, float *t1, float *t2);//时间片轮换算法

//按到达时间进行冒泡排序

struct PCB *sortarrivetime(struct PCB a[], int n){

int i, j;

struct PCB t;

int flag; //标志变量，记录在每一趟冒泡中是否有元素交换，没有交换则结束冒泡

for (i = 1; i < n; i++) //外层循环控制比较趟数

{

flag = 0; //初始值设置为0

for (j = 0; j < n - i; j++) //内循环控制每一趟的比较次数

{

if (a[j].arrivetime > a[j + 1].arrivetime) //将到达时间短的交换到前边

{

t = a[j];

a[j] = a[j + 1];

a[j + 1] = t;

flag = 1; //有交换，flag置1

}

if (flag == 0)//如果一趟排序中没发生任何交换，则排序结束

{

break;

}

return a; //返回排序后的进程数组

}

//时间片轮换算法

void RR(struct PCB a[], int n, float qt, float *t1, float *t2)

{

int i, j;

float remaintime[50]; //剩余服务时间数组

float starttime[50]; //开始时间数组

float responsetime[50]; //响应时间数组

float waitingtime[50]; //等待时间数组

int finishnum = 0; //已完成的进程数

float curtime = 0.0f; //当前时间

float nextstarttime = a[0].arrivetime; //下一个进程开始时间

for (i = 0; i < n; i++)

{

remaintime[i] = a[i].servetime; //剩余服务时间初始化为服务时间

starttime[i] = 0.0f; //开始时间初始化为0

responsetime[i] = 0.0f; //响应时间初始化为0

waitingtime[i] = 0.0f; //等待时间初始化为0

}

while (finishnum < n)

{

for (i = 0; i < n; i++)

{

if (a[i].arrivetime <= curtime && remaintime[i] > 0) //进程到达时间小于等于当前时间并且剩余服务时间大于0

{

if (starttime[i] == 0) //开始时间等于0，即第一次执行该进程

{

starttime[i] = curtime; //记录开始时间

responsetime[i] = curtime - a[i].arrivetime; //计算响应时间

}

if (remaintime[i] > qt) //剩余服务时间大于时间片

{

curtime += qt; //当前时间加上时间片

remaintime[i] -= qt; //剩余服务时间减去时间片

}

else

{

curtime += remaintime[i]; //当前时间加上剩余服务时间

a[i].finishtime = curtime; //记录完成时间

a[i].roundtime = curtime - a[i].arrivetime; //计算周转时间

a[i].daiquantime = a[i].roundtime / a[i].servetime; //计算带权周转时间

remaintime[i] = 0; //剩余服务时间置0

finishnum++; //已完成的进程数加1

}

else if (a[i].arrivetime > curtime) //进程到达时间大于当前时间

{

curtime = a[i].arrivetime; //当前时间更新为进程到达时间

break;

}

printf("=============================================================\n");

printf("进程相关信息如下：\n\n");

printf("进程名 ");

printf("到达时间 ");

printf("服务时间 ");

printf("完成时间 ");

printf("周转时间 ");

printf("带权周转时间 ");

printf("等待时间 ");

printf("响应时间\n");

for (i = 0; i < n; i++)

{

printf("%-10s", a[i].name);

printf("%-10.0f", a[i].arrivetime);

printf("%-10.0f", a[i].servetime);

printf("%-10.0f", a[i].finishtime);

printf("%-10.0f", a[i].roundtime);

printf("%10.2f", a[i].daiquantime);

waitingtime[i] = a[i].roundtime - a[i].servetime; //计算等待时间

printf("%10.0f", waitingtime[i]);

printf("%10.0f\n", responsetime[i]);

*t1 += a[i].roundtime;

*t2 += a[i].daiquantime;

}

int main()

{

float t1; //总周转时间

float t2; //总带权周转时间

float avr_t1; //平均周转时间

float avr_t2; //平均带权周转时间

int n, i;

float qt; //时间片大小

char select = ' '; //选择算法变量标识

while (select != '2') //不为退出标识，保持循环

{

t1 = 0.0f;

t2 = 0.0f;

system("clear");

printf("\n请选择算法：1.时间片轮换算法 2.退出程序\n\n请输入选择: ");

scanf("%c", &select);

if (select == '1') //时间片轮换算法

{

printf("\n=====================时间片轮换算法RR=====================\n\n");

printf("请输入进程数：");

scanf("%d", &n);

for (i = 0; i < n; i++)

{

printf("%d 进程名:", i + 1);

scanf("%s", a[i].name);

printf("到达时间：");

scanf("%f", &a[i].arrivetime);

printf("服务时间：");

scanf("%f", &a[i].servetime);

}

printf("时间片大小：");

scanf("%f", &qt);

getchar();

sortarrivetime(a, n); //按到达时间先后进行冒泡排序

RR(a, n, qt, &t1, &t2); //时间片轮换算法

avr_t1 = t1 / n;

avr_t2 = t2 / n;

printf("\n");

printf("平均周转时间为：%2.2f\n", avr_t1);

printf("平均带权周转时间为：%2.2f\n", avr_t2);

getchar();

}

else if (select == '2')

{

exit(0);

}

else

{

printf("please enter right choose!\n");

}

return 0；

分析该算法的优缺点：

优点：

公平性：时间片轮转算法保证每个进程都有相同的机会来执行，不会出现饥饿问题。
响应时间短：当一个新的进程就绪时，它可以很快的获得执行的机会，因为每个进程都有固定长度的时间片。
实现简单：时间片轮转算法的实现相对简单，只需要维护一个就绪队列，并在时间片用尽时进行进程切换。

缺点：

平均等待时间较长：如果一个进程需要执行的时间比较长，它可能需要等待很多轮才能再次获得执行的机会，导致平均等待时间较长。
频繁的上下文切换：当时间片长度很短时，会导致频繁的上下文切换，增加了系统开销。
不适合长任务：对于执行时间较长的任务，时间片轮转算法效果不好，因为

三、实验总结和体会（1分）

本次实验是关于操作系统进程调度的实验。在实验中，我学习了进程调度的基本概念和算法，并进行了实际操作。在实验中，我首先了解了进程调度的概念和作用。进程调度是操作系统中的一项重要功能，它负责决定哪个进程在何时运行。进程调度的目标是使系统的资源得到最优的利用，提高系统的吞吐量和响应速度。

在实验过程中，我学习了不同的进程调度算法，例如先来先服务（FCFS）、短作业优先（SJF）和时间片轮转（RR）等。我了解了这些算法的特点和适用场景。

在实验操作中，我通过编写和调试代码，实现了一个简单的进程调度模拟器。我能够根据不同的调度算法，对一组进程进行调度，并观察它们的运行情况。

通过这次实验，我对进程调度有了更深入的理解。我学会了如何选择合适的进程调度算法，以实现最优的资源利用和系统性能。同时，我也学会了如何编写和调试相关的代码，提高了自己的编程能力。

查看全文

http://www.xdnf.cn/news/152137.html

Adriuno：编程语言基础

使用 Truffle 和 Ganache 搭建本地以太坊开发环境并部署一个简单智能合约

[mysql]约束(上)

使用 Frida 绕过 iOS 应用程序中的越狱检测

自动化测试实战篇

【Web应用服务器_Tomcat】二、Tomcat 核心配置与集群搭建

关于Code_流苏：商务合作、产品开发、计算机科普、自媒体运营，一起见证科技与艺术的交融！

Kettle学习

利器善其事：软件开发工具管理之道

Sam算法基本原理解析

基于大模型对先天性幽门肥厚性狭窄预测及临床方案的研究报告

MH2103 MH22D3系列的JTAG/SWD复用功能和引脚映射，IO初始化的关键点

C#中常见的设计模式

第十六届蓝桥杯网安初赛wp

关于flink两阶段提交高并发下程序卡住问题

2025.04.26-美团春招笔试题-第四题

设计看似完美却测不过？ Intra-Pair Skew 是「讯号完整性（Signal Integrity）」里最隐形的杀手

【C】初阶数据结构12 -- 冒泡排序

买币永续合约成全球交易热点，XBIT去中心化交易所平台显著提升市场流动性

联想笔记本电脑在Windows下通过联想驱动实现风扇控制

从像素到驾驶决策：Python与OpenCV赋能自动驾驶图像识别

django之账号管理功能

MySQL 数据类型

WPF高级用法示例

【含文档+PPT+源码】基于Python校园跑腿管理系统设计与实现

案例拆解：主数据平台如何支撑智能推荐系统精准发力？

相关文章：