精华内容
下载资源
问答
  • public interface KernelExtra extends StdCallLibrary {/*** Includes all heaps of the process specified in th32ProcessID in the snapshot. To enumerate the heaps, see* Heap32ListFirst.*/WinDef.DWORD TH32...

    public interface KernelExtra extends StdCallLibrary {

    /**

    * Includes all heaps of the process specified in th32ProcessID in the snapshot. To enumerate the heaps, see

    * Heap32ListFirst.

    */

    WinDef.DWORD TH32CS_SNAPHEAPLIST = new WinDef.DWORD(0x00000001);

    /**

    * Includes all processes in the system in the snapshot. To enumerate the processes, see Process32First.

    */

    WinDef.DWORD TH32CS_SNAPPROCESS  = new WinDef.DWORD(0x00000002);

    /**

    * Includes all threads in the system in the snapshot. To enumerate the threads, see Thread32First.

    */

    WinDef.DWORD TH32CS_SNAPTHREAD   = new WinDef.DWORD(0x00000004);

    /**

    * Includes all modules of the process specified in th32ProcessID in the snapshot. To enumerate the modules, see

    * Module32First. If the function fails with ERROR_BAD_LENGTH, retry the function until it succeeds.

    */

    WinDef.DWORD TH32CS_SNAPMODULE   = new WinDef.DWORD(0x00000008);

    /**

    * Includes all 32-bit modules of the process specified in th32ProcessID in the snapshot when called from a 64-bit

    * process. This flag can be combined with TH32CS_SNAPMODULE or TH32CS_SNAPALL. If the function fails with

    * ERROR_BAD_LENGTH, retry the function until it succeeds.

    */

    WinDef.DWORD TH32CS_SNAPMODULE32 = new WinDef.DWORD(0x00000010);

    /**

    * Includes all processes and threads in the system, plus the heaps and modules of the process specified in th32ProcessID.

    */

    WinDef.DWORD TH32CS_SNAPALL      = new WinDef.DWORD((TH32CS_SNAPHEAPLIST.intValue() |

    TH32CS_SNAPPROCESS.intValue() | TH32CS_SNAPTHREAD.intValue() | TH32CS_SNAPMODULE.intValue()));

    /**

    * Indicates that the snapshot handle is to be inheritable.

    */

    WinDef.DWORD TH32CS_INHERIT      = new WinDef.DWORD(0x80000000);

    /**

    * Describes an entry from a list of the processes residing in the system address space when a snapshot was taken.

    */

    public static class PROCESSENTRY32 extends Structure {

    public static class ByReference extends PROCESSENTRY32 implements Structure.ByReference {

    public ByReference() {

    }

    public ByReference(Pointer memory) {

    super(memory);

    }

    }

    public PROCESSENTRY32() {

    dwSize = new WinDef.DWORD(size());

    }

    public PROCESSENTRY32(Pointer memory) {

    useMemory(memory);

    read();

    }

    /**

    * The size of the structure, in bytes. Before calling the Process32First function, set this member to

    * sizeof(PROCESSENTRY32). If you do not initialize dwSize, Process32First fails.

    */

    public WinDef.DWORD dwSize;

    /**

    * This member is no longer used and is always set to zero.

    */

    public WinDef.DWORD cntUsage;

    /**

    * The process identifier.

    */

    public WinDef.DWORD th32ProcessID;

    /**

    * This member is no longer used and is always set to zero.

    */

    public BaseTSD.ULONG_PTR th32DefaultHeapID;

    /**

    * This member is no longer used and is always set to zero.

    */

    public WinDef.DWORD th32ModuleID;

    /**

    * The number of execution threads started by the process.

    */

    public WinDef.DWORD cntThreads;

    /**

    * The identifier of the process that created this process (its parent process).

    */

    public WinDef.DWORD th32ParentProcessID;

    /**

    * The base priority of any threads created by this process.

    */

    public WinDef.LONG pcPriClassBase;

    /**

    * This member is no longer used, and is always set to zero.

    */

    public WinDef.DWORD dwFlags;

    /**

    * The name of the executable file for the process. To retrieve the full path to the executable file, call the

    * Module32First function and check the szExePath member of the MODULEENTRY32 structure that is returned.

    * However, if the calling process is a 32-bit process, you must call the QueryFullProcessImageName function to

    * retrieve the full path of the executable file for a 64-bit process.

    */

    public char[] szExeFile = new char[WinDef.MAX_PATH];

    }

    // the following methods are in kernel32.dll, but not declared there in the current version of Kernel32:

    /**

    * Takes a snapshot of the specified processes, as well as the heaps, modules, and threads used by these processes.

    *

    * @param dwFlags

    *   The portions of the system to be included in the snapshot.

    *

    * @param th32ProcessID

    *   The process identifier of the process to be included in the snapshot. This parameter can be zero to indicate

    *   the current process. This parameter is used when the TH32CS_SNAPHEAPLIST, TH32CS_SNAPMODULE,

    *   TH32CS_SNAPMODULE32, or TH32CS_SNAPALL value is specified. Otherwise, it is ignored and all processes are

    *   included in the snapshot.

    *

    *   If the specified process is the Idle process or one of the CSRSS processes, this function fails and the last

    *   error code is ERROR_ACCESS_DENIED because their access restrictions prevent user-level code from opening them.

    *

    *   If the specified process is a 64-bit process and the caller is a 32-bit process, this function fails and the

    *   last error code is ERROR_PARTIAL_COPY (299).

    *

    * @return

    *   If the function succeeds, it returns an open handle to the specified snapshot.

    *

    *   If the function fails, it returns INVALID_HANDLE_VALUE. To get extended error information, call GetLastError.

    *   Possible error codes include ERROR_BAD_LENGTH.

    */

    public WinNT.HANDLE CreateToolhelp32Snapshot(WinDef.DWORD dwFlags, WinDef.DWORD th32ProcessID);

    /**

    * Retrieves information about the first process encountered in a system snapshot.

    *

    * @param hSnapshot A handle to the snapshot returned from a previous call to the CreateToolhelp32Snapshot function.

    * @param lppe A pointer to a PROCESSENTRY32 structure. It contains process information such as the name of the

    *   executable file, the process identifier, and the process identifier of the parent process.

    * @return

    *   Returns TRUE if the first entry of the process list has been copied to the buffer or FALSE otherwise. The

    *   ERROR_NO_MORE_FILES error value is returned by the GetLastError function if no processes exist or the snapshot

    *   does not contain process information.

    */

    public boolean Process32First(WinNT.HANDLE hSnapshot, KernelExtra.PROCESSENTRY32.ByReference lppe);

    /**

    * Retrieves information about the next process recorded in a system snapshot.

    *

    * @param hSnapshot A handle to the snapshot returned from a previous call to the CreateToolhelp32Snapshot function.

    * @param lppe A pointer to a PROCESSENTRY32 structure.

    * @return

    *   Returns TRUE if the next entry of the process list has been copied to the buffer or FALSE otherwise. The

    *   ERROR_NO_MORE_FILES error value is returned by the GetLastError function if no processes exist or the snapshot

    *   does not contain process information.

    */

    public boolean Process32Next(WinNT.HANDLE hSnapshot, KernelExtra.PROCESSENTRY32.ByReference lppe);

    }

    展开全文
  • Windows平台 C++进程树获取实现

    千次阅读 2018-03-23 13:47:55
    最近在写一个小项目,涉及到查找和结束进程树的功能实现,通过系统API能够获取到的信息有进程名,进程ID,父进程ID等,所以通过一个递归操作可以获取到一棵完整的进程树。但由于进程ID是系统随机给予的,并没有什么...

    最近在写一个小项目,涉及到查找和结束进程树的功能实现,通过系统API能够获取到的信息有进程名,进程ID,父进程ID等,所以通过一个递归操作可以获取到一棵完整的进程树。但由于进程ID是系统随机给予的,并没有什么规律,所有最理想的做法是从最祖父进程(孤儿进程)开始查找子进程,再查找孙子进程…… 这种思路。

    我的程序使用MFC对话框写的,具体效果如下图。


    首先是进程信息存放的结构体

    //进程结构体
    typedef struct TASKMGRDLL_API tagProcessItem
    {
    	DWORD dwProcessID;		//进程ID
    	DWORD dwModuleID;		//模块ID
    	HANDLE hProcess;		//进程句柄
    	DWORD dwcntThreads;		//线程数
    	DWORD dwParentProcessID;//父进程ID
    	string szExeFile;		//进程文件名
    	string szExeFilePath;	//进程文件全路径
    	BOOL bParentAvailableFlag;//父进程是否存在
    	int nProcTreeIndex;		//进程树子孙标记
    	//模块列表
    	vector <ModuleItemA> theModuleList;
    	
    	//拷贝函数
    	void CopyItemFrom(tagProcessItem &theItem)
    	{
    		this ->dwProcessID = theItem.dwProcessID;
    		this ->dwParentProcessID = theItem.dwParentProcessID;
    		this ->dwModuleID = theItem.dwModuleID;
    		this ->dwcntThreads = theItem.dwcntThreads;
    		this ->szExeFile = theItem.szExeFile;
    		this ->szExeFilePath = theItem.szExeFilePath;
    		this ->hProcess = theItem.hProcess;
    		this ->bParentAvailableFlag = theItem.bParentAvailableFlag;
    		this ->nProcTreeIndex = theItem.nProcTreeIndex;
    		this ->theModuleList = theItem.theModuleList;
    	}
    	void CopyItemTo(tagProcessItem &theItem)
    	{
    		theItem.dwProcessID = this ->dwProcessID;
    		theItem.dwParentProcessID = this ->dwParentProcessID;
    		theItem.dwModuleID = this ->dwModuleID;
    		theItem.dwcntThreads = this ->dwcntThreads;
    		theItem.szExeFile = this ->szExeFile;
    		theItem.szExeFilePath = this ->szExeFilePath;
    		theItem.hProcess = this ->hProcess;
    		theItem.bParentAvailableFlag = this ->bParentAvailableFlag;
    		theItem.nProcTreeIndex = this ->nProcTreeIndex;
    		theItem.theModuleList = this ->theModuleList;
    	}
    	bool operator < (const tagProcessItem &tmp) const
    	{
    		/*if(tmp.dwParentProcessID != dwParentProcessID)
    			return tmp.dwParentProcessID > dwParentProcessID;
    		else
    			return tmp.dwProcessID > dwProcessID;*/
    		if( tmp.bParentAvailableFlag != bParentAvailableFlag )
    			return tmp.bParentAvailableFlag > bParentAvailableFlag;
    		else if(tmp.dwParentProcessID != dwParentProcessID)
    			return tmp.dwProcessID > dwProcessID;
    		else
    			return tmp.dwParentProcessID > dwParentProcessID;
    	}
    }*pProcessItemA,ProcessItemA;

    因为要找孤儿进程,所以得用一个容器去标记某进程ID是否存在,这里我用的是map。(遍历获取进程的代码就不放了)

    这个放一个通过进程句柄获取进程文件的方法,因为系统API里没有能够直接获取全路径的方法。

    BOOL ProcessOpt::GetFilePathA( HANDLE hProcess, OUT string &pCurrentFilePath)
    {
    	BOOL bFlag = TRUE;
    	do 
    	{
    		pCurrentFilePath.clear ();
    		char FilePath[MAX_PATH];
    		FilePath[0] = '\0';
    		GetProcessImageFileNameA(hProcess,FilePath,sizeof(FilePath));
    
    		//获取Logic Drive String长度
    		UINT uiLen = GetLogicalDriveStrings(0,NULL);
    		if( 0 == uiLen )
    		{
    			bFlag = FALSE;
    			break;
    		}
    
    		LPSTR pLogicFilePath = new char[uiLen + 1];
    		ZeroMemory(pLogicFilePath,uiLen + 1);
    		uiLen = GetLogicalDriveStringsA(uiLen,pLogicFilePath);
    		if( 0 == uiLen )
    		{
    			delete []pLogicFilePath;
    			pLogicFilePath = NULL;
    			bFlag = FALSE;
    			break;
    		}
    
    		char szDrive[3] = " :";
    		LPSTR pDosDriveName = new char[MAX_PATH];
    		LPSTR pLogicIndex = pLogicFilePath;
    
    		//循环所有盘符
    		do 
    		{
    			szDrive[0] = *pLogicIndex;
    			uiLen = QueryDosDeviceA(szDrive,pDosDriveName,MAX_PATH);
    			if ( 0 == uiLen )
    			{
    				if ( ERROR_INSUFFICIENT_BUFFER != GetLastError () )
    				{
    					break;
    				}
    				delete[] pDosDriveName;
    				pDosDriveName = new char[uiLen + 1];
    				uiLen = QueryDosDeviceA (szDrive,pDosDriveName,uiLen + 1);
    				if ( 0 == uiLen )
    				{
    					break;
    				}
    			}
    			//匹配盘符
    			uiLen = strlen(pDosDriveName);
    			if ( 0 == strstr(FilePath,pDosDriveName) - FilePath)
    			{
    				//sprintf (pCurrentFilePath,"%s%s",szDrive,FilePath + uiLen);
    				pCurrentFilePath = szDrive;
    				pCurrentFilePath += FilePath + uiLen;
    				break;
    			}
    			while(*pLogicIndex ++);
    		} while (*pLogicIndex);
    
    		delete[]pLogicFilePath;
    		delete[]pDosDriveName;
    
    	} while (FALSE);
    	
    	return bFlag;
    }
    

    然后就是将获取到的进程列表进程父子关系的排序。

    PS:函数中的PrintError函数是我调试输出错误码的函数,可以忽略和注释掉。

    //初始化进程操作
    BOOL ProcessOpt::Init()
    {
    	BOOL bFlag = TRUE;
    	do 
    	{
    		theProcessList.clear ();
    		mpProcessIDFlag.clear ();
    		mpProcessItem.clear ();
    		//获取进程列表并保存到vector
    		if( !GetProcessList() )
    		{
    			PrintError ("GetProcessList ERR!");
    			bFlag = FALSE;
    			break;
    		}
    		PrintError ("GetProcessList Success!");
    		iProcessNoParentNum = 0;
    		//将列表排序
    		for ( vector <ProcessItem> ::iterator it = theProcessList.begin ();
    			it != theProcessList.end (); ++it )
    		{
    			//标记父进程是否存在
    			if( mpProcessIDFlag[it ->dwParentProcessID] == 1 )
    			{
    				it ->bParentAvailableFlag = TRUE;
    			}
    			else
    			{
    				it ->bParentAvailableFlag = FALSE;
    				iProcessNoParentNum ++;
    			}
    		}
    		sort( theProcessList.begin(), theProcessList.end(), less<ProcessItem>() );
    		//按照父子进程进行排序
    		SortProcList ();
    		PrintError ("SortProcList Success!");
    		for ( vector <ProcessItem> ::iterator it = theProcessList.begin ();
    			it != theProcessList.end (); ++it )
    		{
    			mpProcessItem[it ->dwProcessID] = it;
    		}
    		PrintError ("Process InIt OK!");
    	} while (FALSE);
    	return bFlag;
    }
    //对进程列表进行排序
    BOOL ProcessOpt::SortProcList()
    {
    	BOOL bFlag = TRUE;
    	vector <ProcessItem> newList;
    
    	DoSort (theProcessList.begin (),newList,0);
    	
    	theProcessList = newList;
    	newList.clear ();
    	
    	return bFlag;
    }	

    在这里我是将排序后的列表直接覆盖到旧的列表上的。

    下面是递归查找排序函数

    //排序函数,通过递归寻找子进程并按顺序添加到列表里
    void ProcessOpt::DoSort(vector <ProcessItem>::iterator it,
    						vector<ProcessItem> &newList,
    						int deep)
    {
    	if( it == theProcessList.end () )
    	{
    		return ;
    	}
    	//从父进程找子进程
    	if(it ->dwcntThreads != 123456)
    	{
    		it ->nProcTreeIndex = deep;
    		newList.push_back (*it);
    		it ->dwcntThreads = 123456;
    		//遍历非孤儿进程,跳过孤儿进程+系统进程0000
    		for ( vector <ProcessItem>::iterator tmpIt = theProcessList.begin () + iProcessNoParentNum; 
    				tmpIt != theProcessList.end (); ++ tmpIt)
    		{
    			if ( tmpIt ->dwcntThreads != 123456 && 
    			   ( it ->dwProcessID == tmpIt ->dwParentProcessID ))
    			{
    				DoSort ( tmpIt, newList,deep + 1);
    			}
    		}
    	}
    	//遍历孤儿进程
    	for ( vector <ProcessItem>::iterator tmpIt = it + 1; 
    			tmpIt != theProcessList.end (); ++ tmpIt)
    	{
    		if ( tmpIt ->dwcntThreads != 123456 && 
    		   ( mpProcessIDFlag[tmpIt ->dwParentProcessID] == 0 || 
    		     tmpIt ->dwProcessID == 0))
    			DoSort (tmpIt, newList,0);
    	}
    }	

    这里传的参数分别是旧列表的迭代器,新列表的引用,和深度。深度是用来标识进程所在族谱中的代数。

    这个需要注意的是系统进程0000的父进程就是本身,所以要进行特殊判断一下。

    我的列表容器和标记容器定义如下。

    vector <ProcessItem> theProcessList;	//进程列表
    map <int,DWORD> mpProcessIDFlag;		//进程ID标志,查看某ID是否存在

    下面是我在列表控件上进行进程树的输出。

    //初始化显示列表
    BOOL ProcessDlg::InitProcessList(void)
    {
    	int index = 0;
    	vector <ProcessItem> theList = m_theProcList.GetProcListInstance ();
    	CString tmp;
    	for ( vector <ProcessItem> ::iterator it = theList.begin ();
    		it != theList.end (); ++it, ++index)
    	{
    		tmp = it ->szExeFile.data ();
    		for (int i = 0;i < it ->nProcTreeIndex;i ++)
    		{
    			if( i == it ->nProcTreeIndex - 1)
    				tmp.Insert ((it ->nProcTreeIndex - 1)*2,TEXT(" |-"));
    			else
    				tmp.Insert (0,TEXT("  "));
    		}
    		m_cProcList.InsertItem (index, tmp);
    		tmp.Format (TEXT("%d"),it ->dwProcessID);
    		m_cProcList.SetItemText (index, PROCLIST_COL_MARK_PROCESSID, tmp);
    		tmp.Format (TEXT("%d"),it ->dwParentProcessID);
    		m_cProcList.SetItemText (index, PROCLIST_COL_MARK_PARENTPROCESSID, tmp);
    		tmp.Format (TEXT("%d"),it ->dwcntThreads);
    		m_cProcList.SetItemText (index, PROCLIST_COL_MARK_THREADCOUNT, tmp);
    		//tmp.Format (L"%d",it ->bParentAvailableFlag);
    		//m_cProcList.SetItemText (index, PROCLIST_COL_MARK_PROCESSFLAG, tmp);
    		m_cProcList.SetItemText (index, PROCLIST_COL_MARK_FILEPATH, it ->szExeFilePath.data ());
    	}
    	return theList.size ();
    }
    这里通过进程所在层数可以判断输出进程名前面的空格数,从而达到进程树的显示效果。(有点简陋,有能力的可以自绘一下,把树形控件和列表控件结合一下)。
    展开全文
  • 如何等待进程树结束

    千次阅读 2014-03-18 09:28:08
    我们通常使用的WaitForSingleObject只能等待一个进程结束,如果进程中间又发起了另外一个进程,我们如何知道那个进程结束?...这样,我们就可以通过Job来跟踪整个的进程树了。 示例代码: #include "stdafx.h
    我们通常使用的WaitForSingleObject只能等待一个进程结束,如果进程中间又发起了另外一个进程,我们如何知道那个进程结束?

    其实,Windows平台上有Job Objects,可以对进程进行分组管理。只要把一个进程指定给一个Job,其子进程也会自动归属该Job,除非主动脱离。这样,我们就可以通过Job来跟踪整个的进程树了。

    示例代码:
    #include "stdafx.h"
    #include <iostream>
    #include <Windows.h>
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    
     HANDLE job=CreateJobObject(NULL,NULL);
    
     STARTUPINFO si;
     PROCESS_INFORMATION pi;
     
     ZeroMemory( &si, sizeof(STARTUPINFO) );
     si.cb = sizeof(STARTUPINFO);
     ZeroMemory( &pi, sizeof(PROCESS_INFORMATION) );
    
     CreateProcess(L"C:/WINDOWS/system32/cmd.exe",NULL,NULL,NULL,FALSE,0,NULL,NULL,&si,&pi);
      
     AssignProcessToJobObject(job,pi.hProcess);
     
     while(true)
     {
      JOBOBJECT_BASIC_PROCESS_ID_LIST list;
      DWORD length;
      QueryInformationJobObject(job,JobObjectBasicProcessIdList,&list,sizeof(JOBOBJECT_BASIC_PROCESS_ID_LIST),&length);
     
      if(list.NumberOfProcessIdsInList<=0)
           break;
     
      Sleep(1000);
     }
       
         CloseHandle(job);
     
     std::cout<<"exit"<<std::endl;
     
     std::cin.get();
     
     return 0;
    }


    你可以在CMD窗口里启动任何的程序,比如notepad.exe,然后在open对话框里使用右键菜单打开其它文件,程序.....如此循环,上面的代码会等待所有程序退出才会结束。
    展开全文
  • 目录 Tasklist 简述 .../t 结束进程树 Tasklist 简述 1、"Tasklist"命令是一个用来显示运行在本地或远程计算机上的所有进程的命令行工具,带有多个执行参数。类似Linux系统的ps命令 2、显示...

    目录

    Tasklist 查看进程

    查看本机所有进程

    根据 pid 查询指定进程

    查看远程所有进程

    Taskkill 终止进程

    根据进程 PID 结束

    根据进程名结束进程

    /f 强制结束进程

    /t 结束进程树


    Tasklist 查看进程

    1、"Tasklist" 命令是一个用来显示运行在本地或远程计算机上的所有进程的命令行工具,带有多个执行参数。类似Linux系统的ps命令

    2、显示结果由五部分组成:映像名称(进程名)、PID、会话名、会话#、内存使用

    3、使用格式:

    tasklist [/s <Computer> [/u [<Domain>\]<UserName> [/p <Password>]]] [{/m <Module> | /svc | /v}] [/fo {table | list | csv}] [/nh] [/fi <Filter> [/fi <Filter> [ ... ]]]

    /S <computer> :指定连接到的计算机或IP地址,默认本机。
    /u [<Domain>\]<UserName>: 指定使用哪个用户执行这个命令。
    /P [password]: 为指定的用户指定密码。
    /M [module] :列出调用指定的DLL模块的所有进程。如果没有指定模块名,显示每个进程加载的所有模块。
    /SVC: 显示每个进程中的服务信息,当/fo参数设置为table时有效。
    /V: 显示详细信息。
    /FI filter: 显示一系列符合筛选器指定的进程。
    /FO format: 指定输出格式,有效值:TABLE、LIST、CSV。
    /NH :指定输出中不显示栏目标题。只对TABLE和CSV格式有效。

    查看本机所有进程

    1、查看本机进程,在“命令提示符”中输入Tasklist 命令即可显示本机的所有进程,本机的显示结果由5部分组成:图像名(进程名)、PID、会话名、会话#和内存使用。

    根据 pid 查询指定进程

    1、使用 "findstr" 做删选

    查看远程所有进程

    1、查看远程系统的进程:如在命令提示符下输入“Tasklist /s 218.22.123.26 /u admin /p 123456”(不包括引号)即可查看到IP地址为218.22.123.26的远程系统的进程。其中/s参数后的“218.22.123.26”指要查看的远程系统的IP地址,/u后的“admin”指Tasklist命令使用的用户账号,它必须是远程系统上的一个合法账号,/p后的“123456”指admin账号的密码。

    2、注意:使用 Tasklist 命令查看远程系统的进程时,需要远程机器的RPC服务的支持,否则,该命令不能正常使用。

    Taskkill 终止进程

    1、Taskill 命令顾名思义是用来关掉进程的。

    根据进程 PID 结束

    1、第一步查找出需要结束进程的 PID,可以使用 tasklist 命令查找,也可以直接从任务管理器中查找。

    2、第二步使用 “taskkill /PID xxx”结束进程,xxx 为进程PID的值,以上面的 SublimeText 为例是 18112

    根据进程名结束进程

    1、第一步查找出需要结束进程的图像名/进程名/映像名,可以使用 tasklist 命令查找,也可以直接从任务管理器中查找。

    2、第二步使用 “taskkill /IM xxx”结束进程,xxx 为进程名,以上面的 SublimeText 为例是 "Sublimetext.exe" ,注意:一定是全名,后面的后缀".exe"不能省略

    /f 强制结束进程

    1、使用"/f"参数即可,注意参数位置,/im之后紧邻着的只能跟进程名,同理 /pid 之后紧邻着的只能跟进程 pid 值

    2、通常结束一个进程后,如果下次打开时不会报错,又必须要强制杀死进程的,可以这么操作

    3、然而对于Office、WPS 此类软件在打开文件的情况下,如果采用强制杀死进程的方式,则下一次再打开文件时,就很可能会提示文件错误,这就是因为强杀进程导致的,所以此时则不再建议加上"/f"参数

    /t 结束进程树

    1、使用"/t"参数即可,注意参数位置,/im之后紧邻着的只能跟进程名,同理/pid之后紧邻着的只能跟进程pid值

    2、对于很多时候,一个程序开启之后,可能会出现不止一个进程,它还会有子进程,此时则可以采用结束进程树的方式,全部结束掉

     

    展开全文
  • 1.此工具是本人学习Windows内核的一个产物,界面层采用MFC编写,驱动层采用WDK7600编译。 2.此工具90%以上的功能都是在内核驱动中实现,Ring3层程序只做展示结果之用。虽然本人已经在诸多环境中做过严格的测试,但也...
  • 等待进程树结束需要用到windows 2000 的job objects内核对象,默认在delphi windows pas里是没有定义的,所以必须手动引用job相关的定义,下面我把jobs.pas 贴出来 unit Jobs; {Interface unit for Windows 2000...
  • 本文为看雪论坛优秀文章看雪论坛作者ID:jishuzhain前言Process Explorer是由SysInternals创建的用于Microsoft Windows的免费任务管理器和系统监视器,SysInternals已被Microsoft收购并重新命名为Windows ...
  • 进程和进程树

    千次阅读 2012-09-11 09:03:28
     结束进程树 比如,在Windows XP的“运行”对话框中输入“cmd”启动命令行控制台,然后在命令行中输入“notepad”启动记事本。现在,命令行控制台进程“cmd.exe”和记事本进程“notepad.exe”就组成了一个进程树,...
  • 我想要:从我的进程(myexe.exe arg0)启动一个新进程(myexe.exe arg1)检索这个新进程的PID(os windows)当我使用TaskManager Windows命令"结束进程树"杀死我的第一个实体(myexe.exe arg0)时,我需要新的(myexe.exe arg...
  • Windows系统中,我们可以很简单的通过任务管理器来查看进程并对进程进行管理,如结束等操作,那么如果是linux呢?相信一些初学者还不知道如何在linux中查看进程和管理,这里KK小编给大家准备了相关知识,有需要的...
  • 查了很久没有发现通过父进程实例获得子进程pid的方法,也没有发现可以结束进程树的win32api,求结束子进程的正确方法或者使打包后的程序只生成一个进程的方法。 大致代码如下: from multiprocessing import ...
  • Linux进程管理

    2019-12-16 23:18:37
    显示进程树:pstree 根据进程名搜索 :例如:pgrep mysql top:相当于Windows的任务管理器 jobs:查看后台任务(暂停,运行,结束) 命令 & :把进程(命令)放置到后台运行,不占用bash 运行进程 将...
  • 在大多数系统中进程都可以并发的执行,并且他们可以动态...这些进程中的每一个也可以创建其他的进程,这就形成了一个进程树。大多数的操作系统(包括UNIX,Linux和Windows)根据独一无二的进程标识符process identifil...
  • windowsxp系统桌面卡住了打不开程序如何解决 ...按“E”键快速找到“explorer.exe”右键“结束进程”或“结束进程树”; 3 选择“文件”—“新建任务(运行)”; 4 输入“explorer.exe”点击确定; 即可解决。 ...
  • 安转原版的win7 64bit系统,开机一段...这是Windows update的影响,比较简单的解决办法:先结束进程树,CPU温度随之降下来了,找到目录 C:\Windows\SoftwareDistribution\DataStore 下的一个文件DataStore.edb 会发现
  • 1、开始->运行->cmd,或者是window+R键。 2、查看被占用端口对应的 PID ...# netstat -aon|findstr "被占用的端口号",回车执行命令 ...找到对应的进程号PID,右击---选择结束进程树。 5、...
  • Windows端口命令

    2020-07-18 17:31:33
    netstat 显示协议统计信息和当前TCP/IP网络连接 netstat 查看当前哪些端口正在...taskkill /t 指定那个终止与父进程一起的所有子进程,常被认为是“终止” taskkill /im imageName 指定将被终止的过程的图像名称 ..
  • 整体思路:找到广告弹窗的具体进程,然后找到其触发具体路径,先杀掉进程,然后去具体路径,能卸载卸载,不能卸载就强力删除(对待任何一款流氓软件都不要...5.记住上面那个路径,直接打开,然后结束进程树 6.在具
  • 类说明CKillProcess---应用类,CKillProcessDlg---主对话框,CProcessTree---进程树 2.由于时间仓促,代码有些乱,但内容很简单。 3.进程技术用到了PSAPI(枚举进程),TOOLHELP32(枚举线程),远线程(释放模块)。本人...
  • 01_StartProcess 创建和结束进程。 02_RedirectStdio 用匿名管道获取控制台程序的输出。 03_CatchError 拦截并处理外部进程的错误。 04_SingleInstance 防止应用程序运行多个实例。 05_ProcessMsg 用...
  • 11.6.2 拼音字典存储结构—Trie 200 11.6.3 单字联想 205 11.7 实例:Windows二级文件系统 209 11.7.1 设计实例 209 11.7.2 具体实现 211 11.8 实例:手柄测试器 214 11.8.1 DirectInput手柄输入 214 11.8....
  • 11.6.2 拼音字典存储结构—Trie 200 11.6.3 单字联想 205 11.7 实例:Windows二级文件系统 209 11.7.1 设计实例 209 11.7.2 具体实现 211 11.8 实例:手柄测试器 214 11.8.1 DirectInput手柄输入 214 11.8....
  • //对于一棵由黑白点组成的二叉树,我们需要找到其中最长的单色简单路径,其中简单路径的定义是从上的某点开始沿边走不重复的点到上的 //另一点结束而形成的路径,而路 ...spring&plus;hibern...
  • killall:kill掉所有的同名进程(类似于windows中的结束进程树?) Nautilus:是gnome默认的文件管理器 gnome:一整套的桌面软件,Ubuntu系统的图形界面管理软件 GNOME、KDE、XFCE 叫做 DE 全称是 Desktop ...
  • Windows 命令提示符窗口输入:(例如80端口) netstat -ano | find "80" 输入如上命令,会出现一个列表,他们都是端口号中包含80字符的进程。...在任务管理器中详细信息中对应PID值找到应用程序,结束进程树。 ...
  • Tomcat端口占用

    2019-02-20 22:26:44
    如图所示:翻译过来就是端口被占用; 解决方法: cmd进入dos窗口,输入命令 netstat -ano;...在进程选项,找到pid为7236的进程,在上面用鼠标右击,选择结束进程树。然后再次启动tomcat就可以了。 ...
  • (2)任务管理器中结束explorer.exe进程(注意是结束进程,不是结束进程树),然后 再新建任务explorer.exe即可。 (3)双击 我的电脑--- 控制面板---声音和音频设备---将音量图标放入任务栏,勾选---应用 确定,...
  • 针对这种情况杀毒软件也无能为力,若两个都是非系统进程,我们可以通过"任务管理器/进程/结束进程树"的方式停掉该进程,杀掉病毒;也可以用工具IceSword(冰刃)中"文件/设置/禁止进线程创建",来停掉其中一个进程,...
  • 常用CMD指令

    2018-04-07 14:04:21
     kill -F 进程名 加-F参数后强制结束进程(为系统的附加工具,默认是没有安装的,在安装目录的Support/tools文件夹内)  del -F 文件名 加-F参数后就可删除只读文件,/AR、/AH、/AS、/AA分别表示删除只读、隐藏、...

空空如也

空空如也

1 2 3 4 5
收藏数 89
精华内容 35
关键字:

windows结束进程树