CPU占用率呈正弦实现,及实时输出进程和线程的CPU占用率

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

#include "stdafx.h"
#include <windows.h>
#include <math.h>
 
// 时间转换
static __int64 file_time_2_utc(const FILETIME* ftime)
{
    LARGE_INTEGER li;
 
    li.LowPart = ftime->dwLowDateTime;
    li.HighPart = ftime->dwHighDateTime;
    return li.QuadPart;
}
 
// 获得CPU的核数
static int get_processor_number()
{
    SYSTEM_INFO info;
    GetSystemInfo(&info);
    return (int)info.dwNumberOfProcessors;
}
// 获取进程CPU占用
int get_cpu_usage(HANDLE hand)
{  
    //cpu数量
    static int processor_count_ = -1;
    //上一次的时间
    static __int64 last_time_ = 0;
    static __int64 last_system_time_ = 0;
 
    FILETIME now;
    FILETIME creation_time;
    FILETIME exit_time;
    FILETIME kernel_time;
    FILETIME user_time;
    __int64 system_time;
    __int64 time;
    __int64 system_time_delta;
    __int64 time_delta;
 
    int cpu = -1;
    if(hand==NULL)
        return cpu;
    if(processor_count_ == -1)
    {
        processor_count_ = get_processor_number();
    }
 
    GetSystemTimeAsFileTime(&now);
 
    //HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, false, pid);
    if (!GetProcessTimes(hand, &creation_time, &exit_time, &kernel_time, &user_time))
    {
        return -1;
    }
    system_time = (file_time_2_utc(&kernel_time) + file_time_2_utc(&user_time)) / processor_count_;
    time = file_time_2_utc(&now);
 
    if ((last_system_time_ == 0) || (last_time_ == 0))
    {
        last_system_time_ = system_time;
        last_time_ = time;
        return -1;
    }
 
    system_time_delta = system_time - last_system_time_;
    time_delta = time - last_time_;
 
    if (time_delta == 0)
        return -1;
 
    cpu = (int)((system_time_delta * 100 + time_delta / 2) / time_delta);
    last_system_time_ = system_time;
    last_time_ = time;
    return cpu;
}
// 获取线程CPU占用
int get_thread_cpu_usage(HANDLE hand)
{
    //cpu数量
    static int processor_count_ = -1;
    //上一次的时间
    static __int64 last_time_ = 0;
    static __int64 last_system_time_ = 0;
     
    FILETIME now;
    FILETIME creation_time;
    FILETIME exit_time;
    FILETIME kernel_time;
    FILETIME user_time;
    __int64 system_time;
    __int64 time;
    __int64 system_time_delta;
    __int64 time_delta;
     
    int cpu = -1;
    if(hand==NULL)
        return cpu;
    if(processor_count_ == -1)
    {
        processor_count_ = get_processor_number();
    }
     
    GetSystemTimeAsFileTime(&now);
     
    //HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, false, pid);
    if (!GetThreadTimes(hand, &creation_time, &exit_time, &kernel_time, &user_time))
    {
    return -1;
    }
    system_time = (file_time_2_utc(&kernel_time) + file_time_2_utc(&user_time)) / processor_count_;
    time = file_time_2_utc(&now);
     
    if ((last_system_time_ == 0) || (last_time_ == 0))
    {
        last_system_time_ = system_time;
        last_time_ = time;
        return -1;
    }
     
    system_time_delta = system_time - last_system_time_;
    time_delta = time - last_time_;
     
    if (time_delta == 0)
        return -1;
     
    cpu = (int)((system_time_delta * 100 + time_delta / 2) / time_delta);
    last_system_time_ = system_time;
    last_time_ = time;
    return cpu;
}
//CPU占用率呈正弦实现
const double SPLIT = 0.01;
const int COUNT = 200;
const double PI = 3.14159265;
const int INTERVAL = 300;
UINT ThreadFunT()
{
    DWORD busySpan[COUNT];  //array of busy times
    DWORD idleSpan[COUNT];  //array of idle times
    int half = INTERVAL / 2;
    double radian = 0.0;
    for(int i = 0; i < COUNT; i++)
    {
        busySpan[i] = (DWORD)(half + (sin(PI * radian) * half));
        idleSpan[i] = INTERVAL - busySpan[i];
        radian += SPLIT;
    }
    DWORD startTime = 0;
    int j = 0;
    while (true)
    {
        j = j % COUNT;
        startTime = GetTickCount();
        while ((GetTickCount() - startTime) <= busySpan[j]) ;
        Sleep(idleSpan[j]);
        j++;
    }
    return 0;
}
 
int main(int argc, char* argv[])
{
    HANDLE m,c;
    DWORD ThreadID;
    int i=0;
    //让进程在指定处理器上运行
    SetProcessAffinityMask(
        GetCurrentProcess(),
        0x00000001          //cpu mask
         );
    m=GetCurrentProcess();
//  c=CreateThread(NULL,
//      0,
//      (LPTHREAD_START_ROUTINE)ThreadFunT,
//      NULL,
//      0,
//      &ThreadID);
    Sleep(300);
    c=CreateThread(NULL,
        0,
        (LPTHREAD_START_ROUTINE)ThreadFunT,
        NULL,
        0,
        &ThreadID);
    while (i<200)
    {
        Sleep(100);
        printf("CPU:%d%%  Thread:%d%%\n",get_cpu_usage(m),get_thread_cpu_usage(c));
        i++;
    }
    printf("Hello World!\n");
    return 0;
}

如果您觉得阅读本文对您有帮助，请点一下“推荐”按钮，您的“推荐”将是我最大的写作动力！欢迎各位转载，但是未经作者本人同意，转载文章之后必须在文章页面明显位置给出作者和原文连接，否则保留追究法律责任的权利。原文链接:https://www.cnblogs.com/lzpong/p/3956712.html