程序未响应的原因：
 
1、是因为这个程序在运行时向系统请求资源，但一直处在资源不足的状态下，久而久只，出现了饿死现象。
 
2、导致这个问题主要是该程序的进程优先级的原因，优先级太低，在多个程度进行资源调用时，该程序申请资源，但资源不足，请求未被批准，久而久之，就被饿死了。
 
3、病毒也是一样，某一项程序申请调用系统资源，但资源被病毒长时间霸占，甚至剥夺其他刚刚得到释放的资源，造成可用资源很少，或是病毒强行修改进程列表中各进程的优先级，造成资源调用申请长时间不被批准。
 
4、建议进程查杀病毒操作，并对系统进行优化，若配置较早可适当考虑升级或更换平台，如果仍然出现极个别的程序无响应的情况，可考虑在进程管理器中手动调整该进程的优先级。
 
总结一下，老是会现这种情况的原因就是因为资源不够用，你的电脑配置不错。硬件过热按你说可以排除，那就要在其它方面着手，是不是电脑中毒了，另外还要注意一下硬盘问题，可以下个软件测试一下，硬盘如果出现问题，刚开始就会表现出时常的假死，因为数据读取指向了出问题的存储区域，频繁使用GHOST安装操作系统对硬盘的损伤也会大。
 
为什么电脑经常会出现程序未响应啊
 
关于程序没有响应的问题主要有几方面的原因：1.网速太卡，2.内存空间不足，3.硬盘太小，4.缓冲内存。
 
计算机老是会出现程序没有响应的情况，原因无非就两个:内存可用空间小，不足以运行相应的程序，内存中有病毒或者木马在感染系统文件程序文件干扰它们的运行.解决方法就对症下药吧!对于内存可用空间小优先考虑的应该是增大内存-花钱买内存，在不想花钱的前提下，终止一切不需要的程序和进程就成为了必须，对win98来说，可以终止explorer之外的一切程序，对win2000和xp来说终止一切可以终止的进程和程序运行。对于病毒或者木马问题，只能是杀毒了!
 
无法响应这个东西最容易出现在你对文件或软件的爆发性应用的时候。
 
比较有经验的同志一般不会在同一时间段大量的文件夹或者运行过量的程序，更重要的是，计算机在运行不过来的时候，千万不要沉不住气的去频繁窗口的关闭或者最小化或者右键刷新菜单，按F5刷新就行，一定要习惯这个，更不要理所当然的去结束任务。
 
比较理智的做法是等待。windowsxp不是windows98那样脆弱，只是这个问题很多人还没有明白。windowsxp可能出现因为CPU耗尽而短暂的无法反应，但是经过一点点时间的等候，就会回复正常的工作状态，正在运行的数据也不会丢失。windowsxp在运行中出现真正的不可恢复的情况是很罕见的，除非你不会使用，或者有严重的硬件问题。
 
提醒您：你也可以通过修改注册表来试试，依次展开分支到：HKEY_CURRENT_USER＼ControlPanel＼Desktop，双击右侧对话框中的“AutoEndTasks”项，然后在弹出的对话框口中将其值修改为“1”。然后确定，重启。
 
为什么我的电脑打开软件后老是出现未响应
 
给分 这个方法被我找了好久才找到的 我也出现这个情况 联网的软件都未响应
 
打开控制面板--intelnet选项--“连接”选项卡--局域网设置--取消选中"自动检测设置"复选框(把勾去掉)
 
电脑经常卡死经常出现该程序未响应怎么办
 
重装系统一般可以解决，不过老电脑硬件老化也会造成这种现象，还有就是安装太多软件，比如百度全家桶，腾讯全家桶，360全家桶等等
 
电脑老是出现应用程序未响应，是怎么回事
 
1)如果与硬件有关系，一个是你的内存少加、CPU等硬件温度高清灰、硬盘有问题用软件修复，软件的方面，卸载出事前下载的东西，下载Win清理助手查杀木马，还原系统或重装，在有就是不要满负荷操作。
 
2)你的电脑卡屏或死机的时候，你在电脑干什么呢，能说说吗？我会跟据你说的较为准确的回答你。
 
请将你在卡屏或死机前电脑的表现，和你操作说的详细些，可能就是这些操作引起卡屏或死机的发生，有问题请我(我跟据你提供的信息重新回答你)。
 
一般卡屏或死机是自己不正确操作引起的，记住容易引起卡屏或死机的操作不做。电脑不要满负荷操作，就是在玩游戏、看视频时、下载时、看网页的同时在干别的操作最容易重启、死机、蓝屏，因此在玩游戏、看视频、下载时、看网页时不要在操作别的东西了。
 
不管你在干什么，只要一有卡的迹象时就赶紧停止手头的操作退出在试，如果还是这样就不要玩了或是不要看了。
 
硬件方面，如果内存条小就加内存条，CPU等硬件温度过高，硬盘坏道，在有就是加的硬件不合适引起的。
 
电脑老是出现程序未响应的情况怎么办
 
最好的办法是：什么也不做，等待一下电脑自动调整，一般等待一段时间就可以好，当然也有等待半天还没响应的，怎么办？新手往往想到按机箱的重新启动，其实要关闭程序不用那么麻烦可以直接使用电脑的任务管理器，无响应的时候我们仍然可以使用任务管理器，方法如下：
 
同时按住 Ctrl + Alt + Del 键打开任务管理器 --- 然后在 “应用程序” 里找到无响应的程序 即可关掉无响应的程序了。
 
也可以通过修改注册表自动关闭不响应程序来试试，依次展开分支到：HKEY_CURRENT_USER＼ControlPanel＼Desktop，双击右侧对话框中的“AutoEndTasks”项，然后在弹出的对话框口中将其值修改为“1”。然后点击确定，重启。
 
电脑程序响应慢解决
 
主要分为两种情况
 
1.软件问题。系统本身有问题，需要换个光盘装系统。还有就是有病毒，需要杀毒
 
2.硬件问题。微机的内存有问题，重新插拔。主板有灰尘，需要清洁。CPU等硬件老化。
 
解决方法：
 
用优化大师优一下 、在安全模式下查毒杀毒。
 
电脑上应用程序很容易未响应，怎么办
 
程序未响应的原因：
 
1、是因为这个程序在运行时向系统请求资源，但一直处在资源不足的状态下，久而久只，出现了饿死现象。
 
2、导致这个问题主要是该程序的进程优先级的原因，优先级太低，在多个程度进行资源调用时，该程序申请资源，但资源不足，请求未被批准，久而久之，就被饿死了。
 
3、病毒也是一样，某一项程序申请调用系统资源，但资源被病毒长时间霸占，甚至剥夺其他刚刚得到释放的资源，造成可用资源很少，或是病毒强行修改进程列表中各进程的优先级，造成资源调用申请长时间不被批准。
 
4、建议进程查杀病毒操作，并对系统进行优化，若配置较早可适当考虑升级或更换平台，如果仍然出现极个别的程序无响应的情况，可考虑在进程管理器中手动调整该进程的优先级。
 
总结一下，老是会现这种情况的原因就是因为资源不够用，你的电脑配置不错。硬件过热按你说可以排除，那就要在其它方面着手，是不是电脑中毒了，另外还要注意一下硬盘问题，可以下个软件测试一下，硬盘如果出现问题，刚开始就会表现出时常的假死，因为数据读取指向了出问题的存储区域，频繁使用GHOST安装操作系统对硬盘的损伤也会大。
 
电脑软件老是出现未响应 什么原因弄成的新电脑
 
方案一：游戏加速
 
方案二：更新显卡驱动
 
1.打开360软件管家在搜索栏中输入驱动人生进行搜索，点击下载，完成后点击安装键，按照提示完成安装
 
2.运行驱动人生选择推荐驱动，在下面的列表中找到显卡将前面的框框打√，然后点击一键更新，驱动更新完成后按照提示点击立即重启，电脑重启后驱动更新完成。
 
方案三：调整显卡控制台
 
关闭显卡的垂直同步
 
1.如果您是英伟达显卡(N卡)，在桌面空白处点击右键，打开显卡控制面板设置选择管理3D设置，将右侧的垂直同步设置为强行关闭，应用后关闭即可。
 
2.如果您是ATI(AMD)显卡，在桌面空白处点击右键，打开显卡控制面板选择3D中的所有设置(all setting)将右侧等待垂直刷新(Wait
 
forvertiical refresh)调节到性能(Performance)位置应用即可。
 
3如果您是Intel(主板集成显卡)，桌面空白处点击鼠标右键，选择图形属性打开后是显卡控制面板，点击3D设置(旧显卡驱动没有该选项，如没有请更新最新显卡驱动)，找到异步翻转选项设置为关闭，点击确定即可。
 
方案四：更新Directx
 
打开“360安全卫士”，点击“360软件管家”，在搜索框中搜索“dx”下载“microsoft directx”按照提示安装即可。
 
方案五：安装360极速浏览器或者360游戏浏览器(对于网页游戏卡的用户)。可以直接从“360安全卫士”的“功能大全”中点击“360极速浏览器”即可自动安装。或者从360软件管家中搜索安装即可。(方法同方案四中的类似。)
 
方案六：降低硬件加速
 
在桌面空白处右键，选择“属性”，在弹出的界面中，点击“设置”，然后点击“高级”
 
2、在弹出的界面中，点击“疑难解答”，然后将硬件加速的选项调低些，可以拉到中间的位置，然后点击“确定”即可。
 
方案七：调整电源选项
 
将电源选项里面的性能调高。
 
游戏卡
 
方案一：游戏加速
 
方案二：更新显卡驱动
 
1.打开360软件管家在搜索栏中输入驱动人生进行搜索，点击下载，完成后点击安装键，按照提示完成安装
 
2.运行驱动人生选择推荐驱动，在下面的列表中找到显卡将前面的框框打√，然后点击一键更新，驱动更新完成后按照提示点击立即重启，电脑重启后驱动更新完成。
 
方案三：调整显卡控制台
 
关闭显卡的垂直同步
 
1.如果您是英伟达显卡(N卡)，在桌面空白处点击右键，打开显卡控制面板设置选择管理3D设置，将右侧的垂直同步设置为强行关闭，应用后关闭即可。
 
2.如果您是ATI(AMD)显卡，在桌面空白处点击右键，打开显卡控制面板选择3D中的所有设置(all setting)将右侧等待垂直刷新(Wait for vertiical refresh)调节到性能(Performance)位置应用即可。
 
3.如果您是Intel(主板集成显卡)，桌面空白处点击鼠标右键，选择图形属性打开后是显卡控制面板，点击3D设置(旧显卡驱动没有该选项，如没有请更新最新显卡驱动)，找到异步翻转选项设置为关闭，点击确定即可。
 
方案四：更新Directx
 
打开“360安全卫士”，点击“360软件管家”，在搜索框中搜索“dx”下载“microsoft
 
directx”按照提示安装即可。
 
方案五：安装360极速浏览器或者360游戏浏览器(对于网页游戏卡的用户)。可以直接从“360安全卫士”的“功能大全”中点击“360极速浏览器”即可自动安装。或者从360软件管家中搜索安装即可。(方法同方案四中的类似。)

 
原标题：Mac程序无响应？六个方法教你如何退出无响应的程序
 
不知你是否遇到过，当你着急找一份文件的时候，打开Mac电脑的应用程序，却没有响应！打又打不开，关又关不掉，急死人了！今天macdown小编为大家带来了6种强制退出无响应的应用程序的办法。
 
小伙伴们，按需自取，不要客气！
 
Mac下载 
 
1、使用键盘快捷键强制退出处于活跃状态的Mac程序
 
快捷键：Command+Option+Shift+Esc
 
这样按住一两秒钟，就可以强制退出当前程序了，算是最方便的一种方法。
 
2、打开强制退出程序窗口
 
使用快捷键：Command+Option+Esc来打开“强制退出应用程序”的窗口，然后选中你需要退出的程序，再点右下方的“强制退出”即可。
 
Mac下载 
 
3、从Dock中强制退出程序
 
按住Option然后右键点击程序在Dock中的图标，可以看到“强制退出”的选项，选择即可。
 
Mac下载 
 
4、从左上角苹果菜单中强制退出程序
 
这个有些类似第二条，从左上角的菜单中选择“强制退出”，不过有些时候程序当机，点击菜单会出现没反应的情况。
 
Mac下载 
 
5、使用“活动监视器”强制退出程序
 
在 应用程序-实用工具 中找到“活动监视器”，找到程序的名字然后选择左上方红色按钮强制退出程序，这个就有些类似Windows中的任务管理器了。如果上面的方法都不奏效，那么可以尝试这个方法。
 
Mac下载 
 
6、使用终端命令强制退出程序
 
这个应该算是重启电脑之前的最后办法了，在终端中输入如下命令killall [程序名称]
 
比如说强制退出Safari，就输入 killall Safari 再回车即可，这样有关Safari的全部进程就都退出了；如果你想分的细一些，可以通过 ps 或者 ps aux 命令查找某些单独的进行，然后使用 kill -9 [pid] 来单独结束某个进程。
 
Mac下载 
 
往期精彩内容推荐：
 
责任编辑：

客户端程序无响应，卡死，卡顿了？抓个dump看下卡在哪里了。
 
原文链接
 
工具下载链接
 
为什么会无响应
 
windows的客户端程序一般都有一个主线程来处理消息，一般都在winmain函数中实现。主线程根据不同的消息做不同的任务，可以打开一个新的对话框，创建一个新线程等。用户的任何点击（鼠标），滚动（滚动条）操作，都会封装成一个消息，最终传给这个线程来处理。如果，这个线程在某个消息响应中，调用了一个阻塞或很耗时的函数，那么就没法及时获取并处理下一个消息了（因为还在那个函数里耗着呢），这个时候表现出来的就是无响应。
 
如果在程序无响应时，抓一个dump，用windbg打印出堆栈来，卡在哪里会一目了然。
 
然而，无响应通常时转瞬即逝的。测试同学在测试时，如果出现了无响应，会叫你过去，如果运气好的话，你可以用任务管理器或其他的抓dump的工具生成一个dump；运气不好时，你看到的是程序运行正常。这样的抓dump，抓到了，很麻烦；抓不到，很抓狂。
 
自己写一个自动检测并抓dump工具吧
 
取个名字：dumphungwindow.exe 
 想想，工具应满足下面几个条件：
 
好用，好上手
静静的等待无响应出现，抓dump
可以设定一个dump数量，抓够了就停止
 
有了上面的条件，工具如何工作基本就定下来了： 
 工具应该跑在一个无限循环中，每隔一段时间，就获取所有的top most window。遍历这些窗口，用 SendMessageTimeout 给窗口发一个消息，如果超时了（多久超时可以自己设置），就抓dump。如果dump数量够了，就退出循环，结束程序。
 
源代码
 
（原文里的代码，命令行的，自己可以写个带界面的，测试同学用起来比较方便）
 
/********************************************************************************************************************
Warranty Disclaimer
--------------------------
This sample code, utilities, and documentation are provided as is, without warranty of any kind. Microsoft further disclaims all
implied warranties including without limitation any implied warranties of merchantability or of fitness for a particular  purpose.
The entire risk arising out of the use or performance of the product and documentation remains with you.

In no event shall Microsoft be liable for any damages whatsoever  (including, without limitation, damages for loss of business
profits, business interruption, loss of business information, or other pecuniary loss) arising out of the use of or inability to
use the sample code, utilities, or documentation, even if  Microsoft has been advised of the possibility of such damages.
Because some states do not allow the exclusion or limitation of liability for consequential or incidental damages, the above
limitation may not apply to you.

********************************************************************************************************************/

#include <stdio.h>
#include <windows.h>
#include <dbghelp.h>
#include <psapi.h>

// don't warn about old school strcpy etc.
#pragma warning( disable : 4996 )

int iMaxDump=5;
int iDumpsTaken=0;
int iHangTime=5000;
int iDumpPause=1;
int iScanRate=5000;
HANDLE hEventLog;
char * szDumpLocation;
int FindHungWindows(void);
char * szDumpFileName = 0;
char * szEventInfo = 0;
char * szDumpFinalTarget = 0;
char * szModName = 0;
char * szAppname = 0;
DWORD dwExecOnHang = 0;

#define MAXDUMPFILENAME 1000
#define MAXEVENTINFO 5000
#define MAXDUMPFINALTARGET 2000
#define MAXDUMPLOCATION 1000
#define MAXAPPPATH 1000
#define MAXMODFILENAME 500
#define HMODSIZE 255

int main(int argc, char * argv[])
{
      int i;
      int z;
      size_t j;
      char scan;

      // check to make sure we have dbghelp.dll on the machine.
      if(!LoadLibrary("dbghelp.dll"))
      {
            printf("dbghelp.dll not found please install the debugger tools and place this tool in \r\nthe debugging tools directory or a copy of dbghelp.dll in this tools directory\r\n");
            return 0;
      }

      // Allocate a buffer for our dump location
      szDumpLocation = (char *)malloc(MAXDUMPLOCATION);
      {
            if(!szDumpLocation)
            {
            printf("Failed to alloc buffer for szdumplocation %d",GetLastError());
            return 0;
            }
      }

      szAppname = (char *)malloc(MAXAPPPATH);
      {
            if(!szAppname)
            {
            printf("Failed to alloc buffer for szAppname  %d",GetLastError());
            return 0;
            }
      }

      // We use temp path because if we are running under terminal server sessions we want the dump to go to each
      // users secure location, ie. there private temp dir. 
      GetTempPath(MAXDUMPLOCATION, szDumpLocation );

      for (z=0;z<argc;z++)
      {
            switch(argv[z][1])
            {
            case '?':
                  {
                  printf("\n This sample application shows you how to use the debugger \r\n help api to dump an application if it stop responding.\r\n\r\n");
                  printf("\n This tool depends on dbghelp.dll, this comes with the Microsoft debugger tools on www.microsoft.com");
                  printf("\n Please make sure you have the debugger tools installed before running this tool.");
                  printf("\n This tool is based on sample source code and is provided as is without warranty.");
                  printf("\n feel free to contact jeffda@microsoft.com to provide feedback on this sample application\r\n\r\n");
                  printf(" /m[Number] Default is 5 dumps\r\n The max number of dumps to take of hung windows before exiting.\r\n\r\n");
                  printf(" /t[Seconds]  Default is 5 seconds\r\n The number of seconds a window must hang before dumping it. \r\n\r\n");
                  printf(" /p[Seconds] Default is 0 seconds\r\n The number of seconds to pause when dumping before continuing scan. \r\n\r\n");
                  printf(" /s[Seconds] Default is 5 seconds.\r\n The scan interval in seconds to wait before rescanning all windows.\r\n\r\n");
                  printf(" /d[DUMP_FILE_PATH] The default is the SystemRoot folder\r\n The path or location to place the dump files.  \r\n\r\n");
                  printf(" /e[EXECUTABLE NAME] This allows you to start another program if an application hangs\r\n\r\n");

                  return 0;
                  }
            case 'm':
            case 'M':
                  {
                        iMaxDump = atoi(&argv[z][2]);
                        break;
                  }
            case 't':
            case 'T':
                  {
                        iHangTime= atoi(&argv[z][2]);
                        iHangTime*=1000;
                        break;
                  }
            case 'p':
            case 'P':
                  {
                        iDumpPause= atoi(&argv[z][2]);
                        iDumpPause*=1000;
                        break;           
                  }
            case 's':
            case 'S':
                  {
                        iScanRate = atoi(&argv[z][2]);
                        iScanRate*=1000;             
                        break;
                  }
            case 'd':
            case 'D':
                  { // Dump file directory path
                        strcpy(szDumpLocation,&argv[z][2]);
                        j = strlen(szDumpLocation);

                        if (szDumpLocation[j-1]!='\\')
                        {
                              szDumpLocation[j]='\\';
                              szDumpLocation[j+1]=NULL;
                        }
                        break;
                  }
            case 'e':
            case 'E':
                  { // applicaiton path to exec if hang happens
                        strcpy(szAppname,&argv[z][2]);
                        dwExecOnHang = 1;
                        break;
                  }
            }
      }


      printf("Dumps will be saved in %s\r\n",szDumpLocation);
      puts("scanning for hung windows\n");

      hEventLog = OpenEventLog(NULL, "HungWindowDump");

      i=0;
      scan='*';
      while(1)
      {
            if(i>20)
            {
                  if ('*'==scan)
                  {
                  scan='.';
            }
                  else
                  {
                  scan='*';
            }
                  printf("\r");
            i=0;
            }
            i++;
            putchar(scan);
            if(!FindHungWindows())
            {
                  return 0;
            }
            if (iMaxDump == iDumpsTaken)
            {
                  printf("\r\n%d Dumps taken, exiting\r\n",iDumpsTaken);
                  return 0;
            }
            Sleep(iScanRate);
      }

      free(szDumpLocation);
      return 0;
}

int FindHungWindows(void)
{
DWORD dwResult = 0;
DWORD ProcessId = 0;
DWORD tid = 0;
DWORD dwEventInfoSize = 0;

// Handles
HWND hwnd = 0;
HANDLE hDumpFile = 0;
HANDLE hProcess = 0;
HRESULT hdDump = 0;

SYSTEMTIME SystemTime;
MINIDUMP_TYPE dumptype = (MINIDUMP_TYPE) (MiniDumpWithFullMemory | MiniDumpWithHandleData | MiniDumpWithUnloadedModules | MiniDumpWithProcessThreadData);

// These buffers are presistant.

// security stuff to report the SID of the dumper to the event log.
PTOKEN_USER pInstTokenUser;
HANDLE ProcessToken;
TOKEN_INFORMATION_CLASS TokenInformationClass = TokenUser;
DWORD ReturnLength =0;

// This allows us to get the first window in the chain of top windows.
hwnd = GetTopWindow(NULL);
if(!hwnd)
{
      printf("Could not GetTopWindow\r\n");
      return 0;
}

// We will iterate through all windows until we get to the end of the list.
while(hwnd)
{
      // Get the process ID for the current window   
      tid = GetWindowThreadProcessId(hwnd, &ProcessId);

      // Sent a message to this window with our timeout. 
      // If it times out we consider the window hung
      if (!SendMessageTimeout(hwnd, WM_NULL, 0, 0, SMTO_BLOCK, iHangTime, &dwResult))
      {
            // SentMessageTimeout can fail for other reasons, 
            // if it's not a timeout we exit try again later
            if(ERROR_TIMEOUT != GetLastError())
            {
                  printf("SendMessageTimeout has failed with error %d\r\n",GetLastError());
                  return 1;
            }
                  // Iint our static buffers points.
                  // On our first trip through if we have not
                  // malloced memory for our buffers do so now.
                  if(!szModName)
                  {
                        szModName = (char *)malloc(MAXMODFILENAME);
                        {
                              if(!szModName)
                              {
                              printf("Failed to alloc buffer for szModName %d",GetLastError());
                              return 0;
                              }
                        }
                  }
                  if(!szDumpFileName)// first time through malloc a buffer.
                  {
                        szDumpFileName = (char *)malloc(MAXDUMPFINALTARGET);
                        {
                              if(!szDumpFileName)
                              {
                                    printf("Failed to alloc buffer for dumpfilename %d",GetLastError());
                                    return 0;
                              }
                        }
                  }
                  if(!szDumpFinalTarget)// first time through malloc a buffer.
                  {
                        szDumpFinalTarget= (char *)malloc(MAXDUMPFINALTARGET);
                        {
                              if(!szDumpFinalTarget)
                              {
                              printf("Failed to alloc buffer for dumpfiledirectory %d",GetLastError());
                              return 0;
                              }
                        }
                  }
                  if(!szEventInfo)
                  {
                        szEventInfo= (char *)malloc(MAXEVENTINFO);
                        {
                              if(!szEventInfo)
                              {
                              printf("Failed to alloc buffer for szEventInfo %d",GetLastError());
                              return 0;
                              }
                        }
                  }
                  // End of initial buffer allocations.

            GetLocalTime (&SystemTime);

            // Using the process id we open the process for various tasks.
            hProcess = OpenProcess(PROCESS_ALL_ACCESS,NULL,ProcessId);
            if(!hProcess )
            {
                  printf("Open process of hung window failed with error %d\r\n",GetLastError());
                  return 1;
            }
            // What is the name of the executable?
            GetModuleBaseName( hProcess, NULL, szModName,MAXMODFILENAME);

            printf("\r\n\r\nHung Window found dumping process (%d) %s\n",ProcessId,szModName);

            // Here we build the dump file name time, date, pid and binary name
            sprintf(szDumpFileName,"HWNDDump_Day%d_%d_%d_Time%d_%d_%d_Pid%d_%s.dmp",SystemTime.wMonth,SystemTime.wDay,SystemTime.wYear,SystemTime.wHour,SystemTime.wMinute,SystemTime.wSecond,ProcessId,szModName);
            strcpy(szDumpFinalTarget,szDumpLocation);
            strcat(szDumpFinalTarget,szDumpFileName);

            // We have to create the file and then pass it's handle to the dump api
            hDumpFile = CreateFile(szDumpFinalTarget,FILE_ALL_ACCESS,0,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
            if(!hDumpFile)
            {
                  printf("CreateFile failed to open dump file at location %s, with error %d\r\n",szDumpLocation,GetLastError());
                  return 0;
            }

            printf("Dumping unresponsive process\r\n%s",szDumpFinalTarget);

            // This dump api will halt the target process while it writes it's
            // image to disk in the form a dump file.
            // this can be opened later by windbg or cdb for debugging.
            if(!MiniDumpWriteDump(hProcess,ProcessId,hDumpFile,dumptype ,NULL,NULL,NULL))
            {
                  // We do this on failure
                  hdDump = HRESULT_FROM_WIN32(GetLastError());
                  printf("MiniDumpWriteDump failed with a hresult of %d last error %d\r\n",hdDump,GetLastError());
                  CloseHandle (hDumpFile);
                  return 0;
            }
            else
            {
                  // If we are here the dump worked.  Now we need to notify the machine admin by putting a event in
                  // the application event log so someone knows a dump was taken and where it is stored.
                  sprintf(szEventInfo,"An application hang was caught by findhungwind.exe, the process was dumped to %s",szDumpFinalTarget);

                  // We need to get the process token so we can get the user sit so ReportEvent will have the
                  // User name / account in the event log.
                  if (OpenProcessToken(hProcess,      TOKEN_QUERY,&ProcessToken ) )
                  {
                        // Make the firt call to findout how big the sid needs to be.    
                        GetTokenInformation(ProcessToken,TokenInformationClass, NULL,NULL,&ReturnLength);
                        pInstTokenUser = (PTOKEN_USER) malloc(ReturnLength);
                        if(!pInstTokenUser)
                        {
                              printf("Failed to malloc buffer for InstTokenUser exiting error %d\r\n",GetLastError());
                              return 0;
                        }
                        if(!GetTokenInformation(ProcessToken,TokenInformationClass, (VOID *)pInstTokenUser,ReturnLength,&ReturnLength))
                        {
                              printf("GetTokenInformation failed with error %d\r\n",GetLastError());
                              return 0;
                        }
                  }
                  // write the application event log message. 
                  // This will show up as source DumpHungWindow
                  dwEventInfoSize=(DWORD)strlen(szEventInfo);

                  ReportEvent(hEventLog,EVENTLOG_WARNING_TYPE,1,1,pInstTokenUser->User.Sid,NULL,dwEventInfoSize,NULL,szEventInfo);

                  // Free to token buffer, we don't want to leak anything.
                  free(pInstTokenUser);

                  // In additon to leaking a handle if you don't close the handle
                  // you may not get the dump to flush to the hard drive.
                  CloseHandle (hDumpFile);
                  printf("\r\nDump complete");

                  // This allows you to execute something if you get a hang like crash.exe
                  if (dwExecOnHang)
                  {
                        system(szAppname);
                  }

                  //  The Sleep is here so in the event you want to wait N seconds
                  //  before collecting another dump
                  //  you can pause.  This is helpful if you want to see if any
                  //  forward progress is happening over time

                  Sleep(iDumpPause);
            }
            // Once we are at our threadshold for max dumps
            // we exit so we do not fill up the hard drive.
            iDumpsTaken++;
            if (iMaxDump == iDumpsTaken)
            {
                  return 0;
            }
        }
        // This is where we traverse to the next window.
            hwnd = GetNextWindow(hwnd, GW_HWNDNEXT);
      }
      return 1;
}

Windows应用程序设计的特点 
 
一、事件驱动的程序设计
 
 1/传统的MS-DOS程序主要采用顺序的、关联的、过程驱动的程序设计方法。一个程序是一系列预先定义好的操作序列的组合，它具有一定的开头、中间过程和结束。程序直接控制程序事件和过程的顺序。这样的程序设计方法是面向程序而不是面向用户的，交互性差，用户界面不够友好，因为它强迫用户按照某种不可更改的模式进行工作。
 
 
 
    2/事件驱动程序设计是一种全新的程序设计方法，它不是由事件的顺序来控制，而是由事件的发生来控制，而这种事件的发生是随机的、不确定的，并没有预定的顺序，这样就允许程序的的用户用各种合理的顺序来安排程序的流程。
 对于需要用户交互的应用程序来说，事件驱动的程序设计有着过程驱动方法无法替代的优点。
 它是一种面向用户的程序设计方法，它在程序设计过程中除了完成所需功能之外，更多的考虑了用户可能的各种输入，并针对性的设计相应的处理程序。
 它是一种“被动”式程序设计方法，程序开始运行时，处于等待用户输入事件状态，然后取得事件并作出相应反应，处理完毕又返回并处于等待事件状态。
 
     二、 消息循环与输入
 
 事件驱动围绕着消息的产生与处理展开，一条消息是关于发生的事件的消息。
 事件驱动是靠消息循环机制来实现的。
 消息是一种报告有关事件发生的通知。
 
 消息类似于DOS下的用户输入，但比DOS的输入来源要广，Windows应用程序的消息来源有以下四种：
    （1）输入消息：包括键盘和鼠标的输入。----------这一类消息首先放在系统消息队列中，然后由Windows将它们送入应用程序消息队列中，由应用程序来处理消息。
    （2）控制消息：用来与Windows的控制对象，如列表框、按钮、检查框等进行双向通信。当用户在列表框中改动当前选择或改变了检查框的状态时发出此类消息。这类消息一般不经过应用程序消息队列，而是直接发送到控制对象上去。
    （3）系统消息：对程序化的事件或系统时钟中断作出反应。一些系统消息，象DDE消息（动态数据交换消息）要通过Windows的系统消息队列，而有的则不通过系统消息队列而直接送入应用程序的消息队列，如创建窗口消息。
    （4）用户消息：这是程序员自己定义并在应用程序中主动发出的，一般由应用程序的某一部分内部处理。
 
 Windows操作系统包括三个内核基本元件：GDI, KERNEL ,USER。
 
 其中GDI(图形设备接口)负责在屏幕上绘制像素、打印硬拷贝输出，绘制用户界面包括窗口、菜单、对话框等。
 系统内核KERNEL支持与操作系统密切相关的功能：如进程加载，文本切换、文件I/O，以及内存管理、线程管理等。
 USER为所有的用户界面对象提供支持，它用于接收和管理所有输入消息、系统消息并把它们发给相应的窗口的消息队列。消息队列是一个系统定义的内存块，用于临时存储消息；或是把消息直接发给窗口过程。每个窗口维护自己的消息队列，并从中取出消息，利用窗口函数进行处理。
 
 三、图形输出
 
 Windows程序不仅在输入上与DOS程序不同，而且在程序输出上也与DOS有着很大不同，主要表现为：
 1.DOS程序独占整个显示屏幕，其他程序在后台等待。
 2.Windows程序的所有输出都是图形。
 3.Windows下的输出是设备无关的。-------Windows下的应用程序使用图形设备接口（GDI）来进行图形输出。GDI屏蔽了不同设备的差异，提供了设备无关的图形输出能力，Windows应用程序只要发出设备无关的GDI请求（如调用Rectangle画一个矩形），由GDI去完成实际的图形输出操作。对于一台具有打印矩形功能的PostScript打印机来说，GDI可能只需要将矩形数据传给驱动程序就可以了，然后由驱动程序产生PostScript命令绘制出相应的矩形；而对于一台没有矩形输出功能的点阵打印机来说，GDI可能需要将矩形转化为四条线，然后向驱动程序发出画线的指令，在打印机上输出矩形。
 

 四、GDI（图形设备接口）介绍：
 
 GDI提供两种基本服务：创建图形输出和存储图象。
 GDI提供了大量用于图形输出的函数，这些函数接收应用程序发出来的绘图请求、处理绘图数据并根据当前使用设备调用相应的设备驱动程序产生绘图输出。这些绘图函数分为三类：一是文字输出，二是矢量图形函数，用于画线、圆等几何图形，三是光栅（位图）图形函数，用于绘制位图。
 GDI识别四种类型的设备：显示屏幕、硬拷贝设备（打印机、绘图机）、位图和图元文件。
  前两者是物理设备，后两者是伪设备。
  一个伪设备提供了一种在RAM里或磁盘里存储图象的方法。
  位图存放的是图形的点位信息，占用较多的内存，但速度很快；图元文件保存的是GDI函数的调用和调用参数，占用内存较少，但依赖于GDI，因此不可能用某个设备来创建图元文件，而且速度比位图要慢。
 GDI的图形输出是面向窗口的，面向窗口包含两层含义：
    （1）每个窗口作为一个独立的绘图接口来处理，有它自己的绘图坐标。当程序在一个窗口中绘图时，首先建立缺省的绘图坐标，原点（0，0）位于窗口用户区的左上角。每个窗口必须独立的维护自己的输出。
    （2）绘图仅对于本窗口有效，图形在窗口边界会被自动裁剪，也就是说窗口中的每一个图形都不会越出边界。即使想越出边界，也是不可能的，窗口会自动的防止其他窗口传过来的任何像素。这样，你在窗口内绘图时，就不必担心会偶然覆盖其他程序的窗口，从而保证了Windows下同时运行多个任务时各个窗口的独立性。
 
 五、资源共享
  对于DOS程序来说，它运行时独占系统的全部资源，包括显示器、内存等，在程序结束时才释放资源。而Windows是一个多任务的操作系统，各个应用程序共享系统提供的资源，常见的资源包括：设备上下文，画刷，画笔，字体，对话框控制，对话框，图标，定时器，插入符号，通信端口，电话线等。
    Windows要求应用程序必须以一种能允许它共享Windows资源的方式进行设计，它的基本模式是这样的：
1.向Windows系统请求资源；
2.使用该资源；
3.释放该资源给Windows以供别的程序使用。
    即使最有经验的Windows程序员也常常会忽略第三步。如果忽略了这一步，轻则当时不出错，但过一会儿出现程序运行出现异常情况，或干扰别的程序正常运行；重则立即死机，比如设备上下文没有释放时。
    在Windows应用程序设计中，CPU也是一种非常重要的资源，因此应用程序应当避免长时间的占用CPU资源（如一个特别长的循环）；如果确实需要这样做，也应当采取一些措施，以让程序能够响应用户的输入。主存也是一个共享资源，要防止同时运行的多个应用程序因协调不好而耗尽内存资源。
    
 应用程序一般不要直接访问内存或其他硬件设备，如键盘、鼠标、计数器、屏幕或串口、并口等。Windows系统要求绝对控制这些资源，以保证向所有的应用程序提供公平的不中断的运行。如果确实要访问串并口，应当使用通过Windows提供的函数来安全的访问。
 
 六、Windows程序的组成
 编写一个典型的Windows应用程序，一般需要：
    1.C,CPP源程序文件：源程序文件包含了应用程序的数据、类、功能逻辑模块（包括事件处理、用户界面对象初始化以及一些辅助例程）的定义。
    2.H,HPP头文件：头文件包含了CPP、C源文件中所有数据、模块、类的声明。当一个CPP、C源文件要调用另一个CPP、C中所定义的模块功能时，需要包含那个CPP、C文件对应的头文件。
    3.资源文件：包含了应用程序所使用的全部资源定义，通常以.RC为后缀名。这里的资源是应用程序所能够使用的一类预定义工具中的一个对象，包括：字符串资源、加速键表、对话框、菜单、位图、光标、工具条、图标、版本信息和用户自定义资源等。
在DOS程序设计过程中，所有的界面设计工作都在源程序中完成。而在Windows程序设计过程中，象菜单、对话框、位图等可视的对象被单独分离出来加以定义，并存放在资源源文件中，然后由资源编译程序编译为应用程序所能使用的对象的映象。资源编译使应用程序可以读取对象的二进制映象和具体数据结构，这样可以减轻为创建复杂对象所需要得程序设计工作。
程序员在资源文件中定义应用程序所需使用的资源，资源编译程序编译这些资源并将它们存储于应用程序的可执行文件或动态连接库中。
 
 七、程序中引用资源的好处：
1.降低内存需求：当应用程序运行时，资源并不随应用程序一起装入内存，而是在应用程序实际用到这些资源时才装入内存。在资源装入内存时，它们拥有自己的数据段，而不驻留于应用程序数据段中；当内存紧张时，可以废弃这些资源，使其占用的内存空间供他用，而当应用程序用到这些资源时才自动装入，这种方式降低了应用程序的内存需求，使一次可运行更多的程序，这也是Windows内存管理的优点之一。
    2.便于统一管理和重复利用：将位图、图标、字符串等按资源文件方式组织便于统一管理和重用。比如，将所有的错误信息放到资源文件里，利用一个函数就可以负责错误提示输出，非常方便。如果在应用程序中要多次用到一个代表公司的徽标位图，就可以将它存放在资源文件中，每次用到时再从资源文件中装入。这种方式比将位图放在一个外部文件更加简单有效。
    3.应用程序与界面有一定的独立性，有利于软件的国际化：由于资源文件独立于应用程序设计，使得在修改资源文件时（如调整对话框大小、对话框控制位置），可以不修改源程序，从而简化了用户界面的设计。另外，目前所提供的资源设计工具一般都是采用“所见即所得”方式，这样就可以更加直观、可视的设计应用程序界面。由于资源文件的独立性，软件国际化工作也非常容易。比如，现在开发了一个英文版的应用程序，要想把它汉化，只需要修改资源文件，将其中的对话框、菜单、字符串资源等汉化即可，而无需直接修改源程序。
 但是，应用程序资源只是定义了资源的外观和组织，而不是其功能特性。例如，编辑一个对话框资源，可以改变对话框的安排和外观，但是却没有也不可能改变应用程序响应对话框控制的方式。外观的改变可以通过编辑资源来实现，而功能的改变却只能通过改变应用程序的源代码，然后重新编译来实现。
 
C、CPP编译器将C源程序编译成目标程序，然后使用连接程序将所有的目标程序（包括各种库）连接在一起，生成可执行程序。在制作Windows应用程序时，编译器还要为引出函数生成正确的入口和出口代码。
    连接程序生成的可执行文件还不能在Windows环境下运行，必须使用资源编译器对其进行处理。资源编译器对可执行文件的处理是这样的：如果该程序有资源描述文件，它就把已编译为二进制数据的资源加入到可执行文件中；否则，仅对该可执行文件进行相容性标识。应用程序必需经过资源编译器处理才可以在Windows环境下运行。
 
 八、结构化程序设计和面向对象的程序设计
 面向对象技术是目前流行的系统设计开发技术，它包括面向对象分析和面向对象程序设计。面向对象程序设计技术的提出，主要是为了解决传统程序设计方法——结构化程序设计所不能解决的代码重用问题。
 
　　结构化程序设计从系统的功能入手，按照工程的标准和严格的规范将系统分解为若干功能模块，系统是"实现模块功能的函数和过程"的集合。由于用户的需求和软、硬件技术的不断发展变化，按照功能划分设计的系统模块必然是易变的和不稳定的。这样开发出来的模块可重用性不高。
 
　　面向对象程序设计从所处理的数据入手，以数据为中心而不是以服务（功能）为中心来描述系统。它把编程问题视为一个数据集合，数据相对于功能而言，具有更强的稳定性。
 
　　面向对象程序设计同结构化程序设计相比最大的区别就在于：前者首先关心的是所要处理的数据，而后者首先关心的是功能。
 
面向对象程序设计是一种围绕真实世界的概念来组织模型的程序设计方法，它采用对象来描述问题空间的实体。一般的认为，对象是包含现实世界物体特征的抽象实体，它反映了系统为之保存信息和（或）与它交互的能力。它是一些属性及服务的一个封装体，在程序设计领域，可以用“对象=数据+作用于这些数据上的操作”这一公式来表达。
 
 "类"是具有相同操作功能和相同的数据格式（属性）的对象的集合。
 类可以看作抽象数据类型的具体实现。
 数据类型是指数据的集合和作用于其上的操作的集合，而抽象数据类型不关心操作实现的细节。
 从外部看，类型的行为可以用新定义的操作加以规定。
 类为对象集合的抽象，它规定了这些对象的公共属性和方法；对象为类的一个实例。苹果是一个类，而放在桌上的那个苹果则是一个对象。
对象和类的关系相当于一般的程序设计语言中变量和变量类型的关系。
 
　　消息是向某"对象"请求服务的一种表达方式。对象内有方法和数据，外部的用户或对象对该对象提出的服务请求，可以称为向该对象发送消息。
    "合作"是指两个对象之间共同承担责任和分工。
 
　在Windows中，程序的基本单位不是过程和函数，而是窗口。一个窗口是一组数据的集合和处理这些数据的方法和窗口函数。从面向对象的角度来看，窗口本身就是一个对象。Windows程序的执行过程本身就是窗口和其他对象的创建、处理和消亡过程。Windows中的消息的发送可以理解为一个窗口对象向别的窗口对象请求对象的服务过程。因此，用面向对象方法来进行Windows程序的设计与开发是极其方便的和自然的。