• linux系统Qt实现简单的任务管理器

    继续上次的操作系统课设，这次需要设计一个简单的任务管理器，大部分人选择GTK来实现，我剑走偏锋，使用Qt来完成这个任务。

    用户和应用程序可以通过/proc得到系统的信息，并可以改变内核的某些参数。由于系统的信息是动态改变的，所以用户或应用程序读取proc文件时，proc文件系统是动态从系统内核读出所需信息并提交的。

    我们要显示系统信息，只需进行相应的文件操作就行了。

    首先需要下载一份Qt的SDK，这是Qt的英文官网：http://qt.nokia.com/，当然也有中文版的：http://qt.nokia.com/title-cn/。

    别问我为什么有个nokia，那是因为Qt是诺基亚开发的一个跨平台的C++图形用户界面应用程序框架。

    Qt商业版只能试用30天，不过有GPL版的，可以免费使用。官网上还有一个非常不错的免费Qt集成开发环境Qt Creator IDE。我使用的就是这个软件：

    打开相应的文件，读取所需要的信息，将其显示在控件上就可以了。

    我采用的是Qt来实现图形界面。

     

    工程文件夹：

      

    编译完成后的实现效果：

     

    这个实验总的来讲还是比较简单的，源码如下：

    main.cpp

    1. #include <QtGui/QApplication> 
    2. #include "mainwindow.h" 
    3.  
    4. int main(int argc, char *argv[]) 
    5. { 
    6.     QApplication a(argc, argv); //应用程序类，每个应用程序有且只有一个 
    7.     MainWindow w; //实例化MainWindow类 
    8.     w.show(); //显示界面 
    9.     return a.exec(); //进入应用程序的循环中,直到程序退出 
    10. } 

    mainwindow.h

    1. #ifndef MAINWINDOW_H 
    2. #define MAINWINDOW_H 
    3.  
    4. #include <QMainWindow> 
    5.  
    6. namespace Ui { 
    7.     class MainWindow; 
    8. } 
    9.  
    10. class MainWindow : public QMainWindow 
    11. { 
    12.     Q_OBJECT 
    13. public: 
    14.     explicit MainWindow(QWidget *parent = 0); 
    15.     ~MainWindow(); 
    16. private: 
    17.     Ui::MainWindow *ui; //界面资源类，所有的界面元素都是通过该类来调用 
    18.     QTimer *timer; //计时器 
    19.  
    20. private slots: 
    21.     void on_pushButton_pkill_clicked(); 
    22.     void on_pushButton_prefresh_clicked(); 
    23.     void on_pushButton_Model_install_clicked(); 
    24.     void on_pushButton_Model_remove_clicked(); 
    25.     void on_pushButton_Model_refresh_clicked(); 
    26.     void on_pushButton_reboot_clicked(); 
    27.     void on_pushButton_halt_clicked(); 
    28.     void on_tabWidget_INFO_currentChanged(int index); 
    29.     void timer_update_currentTabInfo(); 
    30.     //显示tab中的内容 
    31.     void show_tabWidgetInfo(int index); 
    32. }; 
    33.  
    34. #endif // MAINWINDOW_H 

    mainwindow.cpp

    1. #include "mainwindow.h" 
    2. #include "ui_mainwindow.h" 
    3.  
    4. #include <QFile> 
    5. #include <QMessageBox> 
    6. #include <QDir> 
    7. #include <QListWidget> 
    8. #include <QListWidgetItem> 
    9. #include <QStringList> 
    10. #include <QTimer> 
    11.  
    12. int a0 = 0, a1 = 0, b0 = 0, b1 = 0; 
    13.  
    14. MainWindow::MainWindow(QWidget *parent) : //构造函数，初始化ui，计时器 
    15.     QMainWindow(parent), 
    16.     ui(new Ui::MainWindow) 
    17. { 
    18.     ui->setupUi(this); 
    19.     timer = new QTimer(this); 
    20.     QWidget::connect( timer, SIGNAL( timeout() ), this, SLOT( timer_update_currentTabInfo() ) ); 
    21.     QWidget::connect( ui->tabWidget_INFO, SIGNAL( currentChanged() ), 
    22.                       this, SLOT( on_tabWidget_currentChanged() ) ); 
    23.     timer->start(1000); 
    24. } 
    25.  
    26. MainWindow::~MainWindow() 
    27. { 
    28.     delete ui; 
    29.     delete timer; 
    30. } 
    31.  
    32. void MainWindow::timer_update_currentTabInfo() 
    33. { 
    34.     int index = ui->tabWidget_INFO->currentIndex(); 
    35.     //定时器只刷新内存tab页面，用于进度条动态显示 
    36.     if (index == 0) 
    37.     { 
    38.         show_tabWidgetInfo(index); 
    39.     } 
    40. } 
    41.  
    42. void MainWindow::show_tabWidgetInfo(int index) 
    43. { 
    44.     QString tempStr; //读取文件信息字符串 
    45.     QFile tempFile; //用于打开系统文件 
    46.     int pos; //读取文件的位置 
    47.  
    48.     if (index == 0) //内存資源 
    49.     { 
    50.         tempFile.setFileName("/proc/meminfo"); //打开内存信息文件 
    51.         if ( !tempFile.open(QIODevice::ReadOnly) ) 
    52.         { 
    53.             QMessageBox::warning(this, tr("warning"), tr("The meminfo file can not open!"), QMessageBox::Yes); 
    54.             return ; 
    55.         } 
    56.         QString memTotal; 
    57.         QString memFree; 
    58.         QString memUsed; 
    59.         QString swapTotal; 
    60.         QString swapFree; 
    61.         QString swapUsed; 
    62.         int nMemTotal, nMemFree, nMemUsed, nSwapTotal, nSwapFree, nSwapUsed; 
    63.  
    64.         while (1) 
    65.         { 
    66.             tempStr = tempFile.readLine(); 
    67.             pos = tempStr.indexOf("MemTotal"); 
    68.             if (pos != -1) 
    69.             { 
    70.                 memTotal = tempStr.mid(pos+10, tempStr.length()-13); 
    71.                 memTotal = memTotal.trimmed(); 
    72.                 nMemTotal = memTotal.toInt()/1024; 
    73.             } 
    74.             else if (pos = tempStr.indexOf("MemFree"), pos != -1) 
    75.             { 
    76.                 memFree = tempStr.mid(pos+9, tempStr.length()-12); 
    77.                 memFree = memFree.trimmed(); 
    78.                 nMemFree = memFree.toInt()/1024; 
    79.             } 
    80.             else if (pos = tempStr.indexOf("SwapTotal"), pos != -1) 
    81.             { 
    82.                 swapTotal = tempStr.mid(pos+11, tempStr.length()-14); 
    83.                 swapTotal = swapTotal.trimmed(); 
    84.                 nSwapTotal = swapTotal.toInt()/1024; 
    85.             } 
    86.             else if (pos = tempStr.indexOf("SwapFree"), pos != -1) 
    87.             { 
    88.                 swapFree = tempStr.mid(pos+10,tempStr.length()-13); 
    89.                 swapFree = swapFree.trimmed(); 
    90.                 nSwapFree = swapFree.toInt()/1024; 
    91.                 break; 
    92.             } 
    93.         } 
    94.  
    95.         nMemUsed = nMemTotal - nMemFree; 
    96.         nSwapUsed = nSwapTotal - nSwapFree; 
    97.  
    98.         memUsed = QString::number(nMemUsed, 10); 
    99.         swapUsed = QString::number(nSwapUsed, 10); 
    100.         memFree = QString::number(nMemFree, 10); 
    101.         memTotal = QString::number(nMemTotal, 10); 
    102.         swapFree = QString::number(nSwapFree, 10); 
    103.         swapTotal = QString::number(nSwapTotal, 10); 
    104.  
    105.         ui->label_RAM_Used->setText(memUsed+" MB"); 
    106.         ui->label_RAM_Left->setText(memFree+" MB"); 
    107.         ui->label_RAM_Total->setText(memTotal+" MB"); 
    108.         ui->label_SWAP_Used->setText(swapUsed+" MB"); 
    109.         ui->label_SWAP_Left->setText(swapFree+" MB"); 
    110.         ui->label_SWAP_Total->setText(swapTotal+" MB"); 
    111.  
    112.         ui->progressBar_RAM->setValue(nMemUsed*100/nMemTotal); 
    113.         ui->progressBar_SWAP->setValue(nSwapUsed*100/nSwapTotal); 
    114.  
    115.         tempFile.close(); //关闭内存信息文件 
    116.  
    117. 　　//wsj这段计算cpu使用率的方法有问题，使用另一篇中的方法：https://www.cnblogs.com/liushui-sky/p/9258101.html
    118.         int tt = 2; //取2个点采样计算cpu当前利用律 
    119.         int cpuInfo[2][7]; 
    120.         int cpuTotal[2][2]; 
    121.         while (tt) 
    122.         { 
    123.             tempFile.setFileName("/proc/stat"); //打开CPU使用状态信息 
    124.             if ( !tempFile.open(QIODevice::ReadOnly) ) 
    125.             { 
    126.                 QMessageBox::warning(this, tr("warning"), tr("The stat file can not open!"), QMessageBox::Yes); 
    127.                 return; 
    128.             } 
    129.             tempStr = tempFile.readLine(); 
    130.             for (int i = 0; i < 7; i++) 
    131.             { 
    132.                 cpuInfo[2-tt][i] = tempStr.section(" ", i+1, i+1).toInt(); 
    133.                 cpuTotal[1][2-tt] += cpuInfo[2-tt][i]; 
    134.                 if (i == 3) 
    135.                 { 
    136.                     cpuTotal[0][2-tt] += cpuInfo[2-tt][i]; 
    137.                 } 
    138.             } 
    139.             tt--; 
    140.             tempFile.close(); //关闭stat文件 
    141.         } 
    142.  
    143.         int a = cpuTotal[0][1] - cpuTotal[0][0]; 
    144.         int b = cpuTotal[1][1] - cpuTotal[1][0]; 
    145.         if (a < 0) 
    146.         { 
    147.             a = -a; 
    148.         } 
    149.         if (b < 0) 
    150.         { 
    151.             b = -b; 
    152.         } 
    153.         ui->progressBar_CPU->setValue(a*100/b); 
    154.  
    155.         tempFile.setFileName("/proc/stat"); 
    156.         if ( !tempFile.open(QIODevice::ReadOnly) ) 
    157.         { 
    158.             QMessageBox::warning(this, tr("warning"), tr("The stat file can not open!"), QMessageBox::Yes); 
    159.             return; 
    160.         } 
    161.  
    162.         tempStr = tempFile.readLine(); 
    163.         a0 = a1; 
    164.         b0 = b1; 
    165.         a1 = b1 = 0; 
    166.         int gg; 
    167.         for (int i = 0; i < 7; i++) 
    168.         { 
    169.             b1 += tempStr.section(" ", i+2, i+2).toInt(); 
    170.             gg = b1; 
    171.             if (i == 3) 
    172.             { 
    173.                 a1 += tempStr.section(" ", i+2, i+2).toInt(); 
    174.             } 
    175.         } 
    176.         int m, n; 
    177.         m = a1 - a0; 
    178.         n = b1 - b0; 
    179.         if (m < 0) 
    180.         { 
    181.             m = -m; 
    182.         } 
    183.         if (n < 0) 
    184.         { 
    185.             n = -n; 
    186.         } 
    187.         ui->progressBar_CPU->setValue( (n-m)*100/n ); 
    188.         tempFile.close(); //关闭stat文件 
    189.     } 
    190.  
    191.     else if (index == 1) //进程信息 
    192.     { 
    193.         ui->listWidget_process->clear(); 
    194.         QDir qd("/proc"); 
    195.         QStringList qsList = qd.entryList(); 
    196.         QString qs = qsList.join(" "); 
    197.         QString id_of_pro; 
    198.         bool ok; 
    199.         int find_start = 3; 
    200.         int a, b; 
    201.         int nProPid; //进程PID 
    202.         int number_of_sleep = 0, number_of_run = 0, number_of_zombie = 0; 
    203.         int totalProNum = 0; //进程总数 
    204.         QString proName; //进程名 
    205.         QString proState; //进程状态 
    206.         QString proPri; //进程优先级 
    207.         QString proMem; //进程占用内存 
    208.         QListWidgetItem *title = new QListWidgetItem("PID " + QString::fromUtf8("名称") + " " + 
    209.                                                      QString::fromUtf8("状态") + " " + 
    210.                                                      QString::fromUtf8("优先级") + " " + 
    211.                                                      QString::fromUtf8("占用内存"), ui->listWidget_process); 
    212.         //循环读取进程 
    213.         while (1) 
    214.         { 
    215.             //获取进程PID 
    216.             a = qs.indexOf(" ", find_start); 
    217.             b = qs.indexOf(" ", a+1); 
    218.             find_start = b; 
    219.             id_of_pro = qs.mid(a+1, b-a-1); 
    220.             totalProNum++; 
    221.             nProPid = id_of_pro.toInt(&ok, 10); 
    222.             if(!ok) 
    223.             { 
    224.                 break; 
    225.             } 
    226.  
    227.             //打开PID所对应的进程状态文件 
    228.             tempFile.setFileName("/proc/" + id_of_pro + "/stat"); 
    229.             if ( !tempFile.open(QIODevice::ReadOnly) ) 
    230.             { 
    231.                 QMessageBox::warning(this, tr("warning"), tr("The pid stat file can not open!"), QMessageBox::Yes); 
    232.                 return; 
    233.             } 
    234.             tempStr = tempFile.readLine(); 
    235.             if (tempStr.length() == 0) 
    236.             { 
    237.                 break; 
    238.             } 
    239.             a = tempStr.indexOf("("); 
    240.             b = tempStr.indexOf(")"); 
    241.             proName = tempStr.mid(a+1, b-a-1); 
    242.             proName.trimmed(); //删除两端的空格 
    243.             proState = tempStr.section(" ", 2, 2); 
    244.             proPri = tempStr.section(" ", 17, 17); 
    245.             proMem = tempStr.section(" ", 22, 22); 
    246.  
    247.             switch ( proState.at(0).toLatin1() ) 
    248.             { 
    249.                 case 'S':   number_of_sleep++; break; //Sleep 
    250.                 case 'R':   number_of_run++; break; //Running 
    251.                 case 'Z':   number_of_zombie++; break; //Zombie 
    252.                 default :   break; 
    253.             } 
    254.  
    255.             if (proName.length() >= 12) 
    256.             { 
    257.                 QListWidgetItem *item = new QListWidgetItem(id_of_pro + " " + 
    258.                                                             proName + " " + 
    259.                                                             proState + " " + 
    260.                                                             proPri + " " + 
    261.                                                             proMem, ui->listWidget_process); 
    262.             } 
    263.             else 
    264.             { 
    265.                 QListWidgetItem *item = new QListWidgetItem(id_of_pro + " " + 
    266.                                                             proName + " " + 
    267.                                                             proState + " " + 
    268.                                                             proPri + " " + 
    269.                                                             proMem, ui->listWidget_process); 
    270.             } 
    271.         } 
    272.         QString temp; 
    273.         temp = QString::number(totalProNum, 10); 
    274.         ui->label_pNum->setText(temp); 
    275.         temp = QString::number(number_of_run, 10); 
    276.         ui->label_pRun->setText(temp); 
    277.         temp = QString::number(number_of_sleep, 10); 
    278.         ui->label_pSleep->setText(temp); 
    279.         temp = QString::number(number_of_zombie, 10); 
    280.         ui->label_pZombie->setText(temp); 
    281.  
    282.         tempFile.close(); //关闭该PID进程的状态文件 
    283.     } 
    284.  
    285.     else if (index == 2) //模块信息 
    286.     { 
    287.         ui->listWidget_model->clear(); 
    288.         tempFile.setFileName("/proc/modules"); //打开模块信息文件 
    289.         if ( !tempFile.open(QIODevice::ReadOnly) ) 
    290.         { 
    291.             QMessageBox::warning(this, tr("warning"), tr("The modules file can not open!"), QMessageBox::Yes); 
    292.             return ; 
    293.         } 
    294.         //设置模块首行项目 
    295.         QListWidgetItem *title = new QListWidgetItem( QString::fromUtf8("名称") + " " + 
    296.                                                       QString::fromUtf8("使用内存数") + " " + 
    297.                                                       QString::fromUtf8("使用次數"), ui->listWidget_model); 
    298.  
    299.         QString mod_Name, mod_Mem, mod_Num; 
    300.         //循环读取文件内容，查找需要的信息 
    301.         while (1) 
    302.         { 
    303.             tempStr = tempFile.readLine(); 
    304.             if (tempStr.length() == 0) 
    305.             { 
    306.                 break; 
    307.             } 
    308.             mod_Name = tempStr.section(" ", 0, 0); 
    309.             mod_Mem = tempStr.section(" ", 1, 1); 
    310.             mod_Num = tempStr.section(" ", 2, 2); 
    311.             if (mod_Name.length() > 10) 
    312.             { 
    313.                 QListWidgetItem *item = new QListWidgetItem(mod_Name + " " + 
    314.                                                             mod_Mem + " " + 
    315.                                                             mod_Num, ui->listWidget_model); 
    316.             } 
    317.             else 
    318.             { 
    319.                 QListWidgetItem *item = new QListWidgetItem(mod_Name + " " + 
    320.                                                             mod_Mem + " " + 
    321.                                                             mod_Num, ui->listWidget_model); 
    322.             } 
    323.         } 
    324.         tempFile.close(); //关闭模块信息文件 
    325.     } 
    326.  
    327.     else if (index == 3) //系统信息 
    328.     { 
    329.         //int ok; 
    330.         tempFile.setFileName("/proc/cpuinfo"); //打开CPU信息文件 
    331.         if ( !tempFile.open(QIODevice::ReadOnly) ) 
    332.         { 
    333.             QMessageBox::warning(this, tr("warning"), tr("The cpuinfo file can not open!"), QMessageBox::Yes); 
    334.             return; 
    335.         } 
    336.  
    337.         //循环读取文件内容，查找需要的信息 
    338.         while (1) 
    339.         { 
    340.             tempStr = tempFile.readLine(); 
    341.             pos = tempStr.indexOf("model name"); 
    342.             if (pos != -1) 
    343.             { 
    344.                 pos += 13; //跳过前面的"model name："所占用的字符 
    345.                 QString *cpu_name = new QString( tempStr.mid(pos, tempStr.length()-13) ); 
    346.                 ui->label_CPUName->setText(*cpu_name); 
    347.             } 
    348.             else if (pos = tempStr.indexOf("vendor_id"), pos != -1) 
    349.             { 
    350.                 pos += 12; //跳过前面的"vendor_id："所占用的字符 
    351.                 QString *cpu_type = new QString( tempStr.mid(pos, tempStr.length()-12) ); 
    352.                 ui->label_CPUType->setText(*cpu_type); 
    353.             } 
    354.             else if (pos = tempStr.indexOf("cpu MHz"), pos != -1) 
    355.             { 
    356.                 pos += 11; //跳过前面的"cpu MHz："所占用的字符 
    357.                 QString *cpu_frq = new QString( tempStr.mid(pos, tempStr.length()-11) ); 
    358.                 double cpufrq = cpu_frq->toDouble(); //4核CPU 
    359.                 cpu_frq->setNum(cpufrq*4); 
    360.                 ui->label_CPUFrequency->setText(*cpu_frq + " HZ"); 
    361.             } 
    362.             else if (pos = tempStr.indexOf("cache size"), pos!=-1) 
    363.             { 
    364.                 pos += 13; //跳过前面的"cache size："所占用的字符 
    365.                 QString *cache_size = new QString( tempStr.mid(pos, tempStr.length()-16) ); 
    366.                 int cachesize = cache_size->toInt(); //4核CPU 
    367.                 cache_size->setNum(cachesize*4); 
    368.                 ui->label_CatheCapacity->setText(*cache_size + " KB"); 
    369.             } 
    370.             else //跳过其他的内容 
    371.             { 
    372.             } 
    373.         } 
    374.         tempFile.close(); //关闭CPU信息文件 
    375.  
    376.         //打开操作系统信息文件 
    377.         tempFile.setFileName("/proc/version"); 
    378.         if ( !tempFile.open(QIODevice::ReadOnly) ) 
    379.         { 
    380.             QMessageBox::warning(this, tr("warning"), tr("The version file can not open!"), QMessageBox::Yes); 
    381.             return ; 
    382.         } 
    383.         tempStr = tempFile.readLine(); 
    384.         pos = tempStr.indexOf("version"); 
    385.         QString *os_version = new QString( tempStr.mid(0, pos-1) ); 
    386.         ui->label_SystemType->setText(*os_version); 
    387.  
    388.         int pos1 = tempStr.indexOf("("); 
    389.         QString *os_type = new QString( tempStr.mid(pos, pos1-pos-1) ); 
    390.         ui->label_SystemVersion->setText(*os_type); 
    391.  
    392.         pos = tempStr.indexOf("gcc version"); 
    393.         pos1 = tempStr.indexOf("#"); 
    394.         QString *gcc_info = new QString( tempStr.mid(pos+12, pos1-pos-14) ); 
    395.         ui->label_GCCVersion->setText(*gcc_info); 
    396.  
    397.         tempFile.close(); //关闭操作系统信息文件 
    398.     } 
    399.  
    400.     else //说明 
    401.     { 
    402.     } 
    403.     return; 
    404. } 
    405.  
    406. void MainWindow::on_pushButton_halt_clicked() 
    407. { 
    408.     system("halt"); 
    409. } 
    410.  
    411. void MainWindow::on_pushButton_reboot_clicked() 
    412. { 
    413.     system("reboot"); 
    414. } 
    415.  
    416.  
    417. void MainWindow::on_tabWidget_INFO_currentChanged(int index) 
    418. { 
    419.     show_tabWidgetInfo(index); //显示tab中的内容 
    420.     return ; 
    421. } 
    422.  
    423. void MainWindow::on_pushButton_pkill_clicked() 
    424. { 
    425.     //获得进程号 
    426.     QListWidgetItem *item = ui->listWidget_process->currentItem(); 
    427.     QString pro = item->text(); 
    428.     pro = pro.section(" ", 0, 0); 
    429.     system("kill " + pro.toLatin1()); 
    430.     QMessageBox::warning(this, tr("kill"), QString::fromUtf8("该进程已被杀死!"), QMessageBox::Yes); 
    431.     //回到进程信息tab表 
    432.     show_tabWidgetInfo(1); 
    433. } 
    434.  
    435. void MainWindow::on_pushButton_prefresh_clicked() 
    436. { 
    437.     show_tabWidgetInfo(1); 
    438. } 
    439.  
    440. void MainWindow::on_pushButton_Model_install_clicked() 
    441. { 
    442.     show_tabWidgetInfo(2); //安装模块还不知道如何实现 
    443. } 
    444.  
    445. void MainWindow::on_pushButton_Model_remove_clicked() 
    446. { 
    447.     show_tabWidgetInfo(2); //卸载模块还不知道如何实现 
    448. } 
    449.  
    450. void MainWindow::on_pushButton_Model_refresh_clicked() 
    451. { 
    452.     show_tabWidgetInfo(2); 
    453. } 

    转自http://blog.51cto.com/rangercyh/521262
  • 相关阅读:
    QT设置窗口屏幕居中
    屏蔽ubuntu桌面鼠标右键以及Ctrl Alt F*
    ubuntu12.04 U盘自动挂载配置
    最受欢迎的15个Python开源框架
    异步非阻塞IO的Python Web框架--Tornado
    RabbitMQ RPC问题
    petapoco模板修改
    事件&表达式
    .net core2 单元测试
    检查邮箱IP是否在国际反垃圾邮件组织的黑名单中
  • 原文地址：https://www.cnblogs.com/liushui-sky/p/9241158.html
Copyright © 2020-2023  润新知