精华内容
下载资源
问答
  • Windows进程

    万次阅读 2020-06-23 21:46:48
    进程的创建 BOOL CreateProcess( LPCTSTR lpApplicationName, // name of executable module LPTSTR lpCommandLine, // command line string 命令行参数 LPSECURITY_ATTRIBUTES ...

    一. 进程的创建

    BOOL CreateProcess(						
      LPCTSTR lpApplicationName,                 // name of executable module 					
      LPTSTR lpCommandLine,                      // command line string 命令行参数				
      LPSECURITY_ATTRIBUTES lpProcessAttributes, // SD 
      LPSECURITY_ATTRIBUTES lpThreadAttributes,  // SD
      BOOL bInheritHandles,                      // handle inheritance option						
      DWORD dwCreationFlags,                     // creation flags						
      LPVOID lpEnvironment,                      // new environment block						
      LPCTSTR lpCurrentDirectory,                // current directory name						
      LPSTARTUPINFO lpStartupInfo,               // startup information						
      LPPROCESS_INFORMATION lpProcessInformation // process information						
    );						
    

    第一个参数也可以只传入程序名称自动进行检索,但不推荐。第一个参数可以为常量。

    第二个参数不可以直接传字符串常量,因为系统可能会对第二个参数直接进行修改;可以通过第二个参数来创建进程,第一个赋值为NULL,这样可以直接打开一个网址;单独传参数的时候要在最前面留一个空格,否则不会识别此参数。

    第三个参数:此进程的进程句柄是否可以被继承。

    第四个参数:此线程的进程句柄是否可以被继承。

    第五个参数:是否可以继承父进程的句柄表(句柄表为1的句柄才可以执行)。

    第六个参数:传NULL使用父进程控制台;传CREATE_NEW_CONSOLE创建新的控制台;CREATE_SUSPENDED以挂起的方式创建进程。

    第八个参数:传NULL 在子进程中调用GetCurrentDirectory函数获取的是父进程的目录,如果创建时添加目录那么GetCurrentDirectory函数获取的就是给定的目录。

    第九个参数:
    1. 用来设定要创建的应用程序的属性,比如可以指定新创建的控制台程序的标题等待。
    2. STARTUPINFO si = { 0 };   si.cb = sizeof(si);是一个全零的结构,只需要给第一个字段赋值,就是这个结构的大小,这样可以考虑到可拓展,微软可以选择改变以下结构体。

    typedef struct _STARTUPINFO			
    {			
       DWORD cb;			
       PSTR lpReserved;			
       PSTR lpDesktop;			
       PSTR lpTitle;			
       DWORD dwX;			
       DWORD dwY;			
       DWORD dwXSize;			
       DWORD dwYSize;			
       DWORD dwXCountChars;			
       DWORD dwYCountChars;			
       DWORD dwFillAttribute;			
       DWORD dwFlags;			
       WORD wShowWindow;			
       WORD cbReserved2;			
       PBYTE lpReserved2;			
       HANDLE hStdInput;			
       HANDLE hStdOutput;			
       HANDLE hStdError;			
    } STARTUPINFO, *LPSTARTUPINFO;			
    

    第十个参数:Out类型参数,成功创建进程后,会返回以下结构。

    	typedef struct _PROCESS_INFORMATION				
    	{				
    	   HANDLE hProcess;				//进程句柄
    	   HANDLE hThread;				//主线程句柄
    	   DWORD dwProcessId;				//进程ID
    	   DWORD dwThreadId;				//线程ID
    	} PROCESS_INFORMATION;				
    

    创建一个进程: 

    int main(int argc, char* argv[])
    {
    	STARTUPINFO si = { 0 };
    	PROCESS_INFORMATION pi;
    
    	si.cb = sizeof(si);
    
    	TCHAR szApplicationName[] = TEXT(" https://www.baidu.com");
    
    	BOOL res = CreateProcess(
    		TEXT("C:\\Program Files\\Mozilla Firefox\\firefox.exe"),
    		szApplicationName,
    		NULL,
    		NULL,
    		FALSE,
    		CREATE_NEW_CONSOLE,
    		NULL,
    		NULL, &si, &pi);
    
    	cout << res << endl;
    	cout << pi.dwProcessId << endl << pi.dwThreadId << endl << pi.hProcess << endl << pi.hThread << endl;
    
    
    	system("pause");
    	return 0;
    }
    

    关于句柄和ID                
                    
    1、都是系统分配的一个编号,句柄是客户程序使用 ID主要是系统调度时使用。          
                    
    2、调用CloseHandle关闭进程或者线程句柄的时候,只是让内核计数器减少一个,并不是终止进程或者线程。进程或线程将继续运行,直到它自己终止运行。                
                    
    3、进程ID与线程ID 是不可能相同。但不要通过进程或者线程的ID来操作进程或者线程,因为,这个编号是会重复使用的,也就是说,当你通过ID=100这个编号去访问一个进程的时候,它已经结束了,而且系统将这个编号赋给了另外一个进程或者线程。 

     

     

    二. 终止进程

    终止进程的三种方式:                                                               

    1、VOID ExitProcess(UINT fuExitCode)                            //进程自己调用    

    2、BOOL TerminateProcess(HANDLE hProcess, UINT fuExitCode);                            //终止其他进程    

    3、ExitThread                            //终止进程中的所有线程,进程也会终止    
     

    获取进程的退出码:                              
    BOOL GetExitCodeProcess(HANDLE hProcess,PDWORD pdwExitCode);                
                       
    进程终止时相关操作:                
    1、进程中剩余的所有线程全部终止运行                
    2、进程指定的所有用户对象均被释放,所有内核对象均被关闭                
    3、进程内核对象的状态变成已通知的状态(不同的内核对象微软赋予状态意义不同,但是这里与线程相同)                
    4、进程内核对象的使用计数递减1                

     

    三. 进程的继承

    创建内核对象时需要设置为可继承,这样会在进程的句柄表中赋值为1,这是子进程可以继承父进程句柄表的前提。之后在子进程创建时将第五个参数设置为TRUE即可。

    另外,虽然子进程继承可句柄,但是无法直接使用,需要父进程传递才能使用,下面选择的是通过命令行参数传递事件句柄。

    父进程: 在SetEvent处下断点,单补观察。

    #define _CRT_SECURE_NO_WARNINGS
    #include <iostream>
    #include <locale.h>
    #include <Windows.h>
    using namespace std;
    #include <atlconv.h>
    
    int main(int argc, char* argv[])
    {
    	CHAR szBuffer[256] = { 0 };
    	CHAR szHandle[8] = { 0 };
    
    	SECURITY_ATTRIBUTES sa;
    	sa.nLength = sizeof(sa);
    	sa.lpSecurityDescriptor = NULL;
    	sa.bInheritHandle = TRUE;
    	HANDLE g_hEvent = CreateEvent(&sa, TRUE, FALSE, NULL);
    	if (g_hEvent == NULL) cout << "CreateEventError" << endl;
    	sprintf(szHandle, "%x", g_hEvent);
    	sprintf(szBuffer, "D:/ZZZ.exe %s", szHandle);
    
    	STARTUPINFO si = { 0 };
    	PROCESS_INFORMATION pi;
    	si.cb = sizeof(si);
    
    	USES_CONVERSION;
    	TCHAR *str = new TCHAR[256];
    	str = A2T(szBuffer);
    	BOOL res = CreateProcess(
    		NULL,
    		str,
    		NULL,
    		NULL,
    		TRUE,
    		CREATE_NEW_CONSOLE,
    		NULL,
    		NULL, &si, &pi);
    	if (res)
    		cout << "创建成功" << endl;
    	else
    		cout << "创建失败" << endl;
    
    	SetEvent(g_hEvent);
    	CloseHandle(g_hEvent);
    
    
    	system("pause");
    	return 0;
    }
    

    子进程:

    #define _CRT_SECURE_NO_WARNINGS
    #include <iostream>
    #include <locale.h>
    #include <Windows.h>
    using namespace std;
    
    int main(int argc, char* argv[])
    {
    	char szBuffer[256] = {0};				
    
    	memcpy(szBuffer,argv[1],8);				
    
    	DWORD dwHandle = 0;				
    
    	sscanf(szBuffer,"%x",&dwHandle);				
    
    	printf("%s\n",argv[0]);				
    
    	printf("%x\n",dwHandle);				
    
    	HANDLE g_hEvent = (HANDLE)dwHandle;				
    
    	printf("开始等待.....\n");				
    	//当事件变成已通知时 				
    	WaitForSingleObject(g_hEvent, INFINITE);				
    
    	DWORD dwCode = GetLastError();				
    
    	printf("等到消息.....%x\n",dwCode);				
    
    	getchar();				
    	system("pause");
    	return 0;
    }
    

     

    四. 挂起方式创建进程——进程创建的第三第四个参数

    一. 创建并挂起进程

    main.cpp:进程创建的第三第四个参数表示此进程的进程句柄和线程句柄是否可以被子进程继承。内核对象都有此类安全参数,用来设置是否可以被继承句柄。如下代码创建一个父进程(随意一个软件),子进程继承其句柄设置父进程挂起,软件一般会显示未响应。但测试了Firefox,挂起后仍能进行操作。

    #define _CRT_SECURE_NO_WARNINGS
    #include <iostream>
    #include <locale.h>
    #include <Windows.h>
    using namespace std;
    #include <atlconv.h>
    
    int main(int argc, char* argv[])
    {
    	char szBuffer[256] = { 0 };
    	char szHandle[8] = { 0 };
    
    	SECURITY_ATTRIBUTES ie_sa_p;
    	ie_sa_p.nLength = sizeof(ie_sa_p);
    	ie_sa_p.lpSecurityDescriptor = NULL;
    	ie_sa_p.bInheritHandle = TRUE;
    
    	SECURITY_ATTRIBUTES ie_sa_t;
    	ie_sa_t.nLength = sizeof(ie_sa_t);
    	ie_sa_t.lpSecurityDescriptor = NULL;
    	ie_sa_t.bInheritHandle = TRUE;
    	//创建一个可以被继承的内核对象,此处是个进程						
    	STARTUPINFO ie_si = { 0 };
    	PROCESS_INFORMATION ie_pi;
    	ie_si.cb = sizeof(ie_si);
    
    	TCHAR szCmdline[] = TEXT("C:\\Users\\lenovo\\Desktop\\DTDebug\\DTDebug.exe");
    	CreateProcess(
    		NULL,
    		szCmdline,
    		&ie_sa_p,
    		&ie_sa_t,
    		FALSE,
    		CREATE_NEW_CONSOLE,
    		NULL,
    		NULL, &ie_si, &ie_pi);
    
    	//组织命令行参数						
    	sprintf(szHandle, "%x %x", ie_pi.hProcess, ie_pi.hThread);
    	sprintf(szBuffer, "D:/aaa.exe %s", szHandle);
    
    	//定义创建进程需要用的结构体						
    	STARTUPINFO si = { 0 };
    	PROCESS_INFORMATION pi;
    	si.cb = sizeof(si);
    
    	USES_CONVERSION;
    	TCHAR *str = new TCHAR[256];
    	str = A2T(szBuffer);
    
    	//创建子进程						
    	BOOL res = CreateProcess(
    		NULL,
    		str,
    		NULL,
    		NULL,
    		TRUE,
    		CREATE_NEW_CONSOLE,
    		NULL,
    		NULL, &si, &pi);
    	if (res)
    		cout << "B创建成功" << endl;
    	else
    		cout << "B创建失败" << endl;
    
    
    	system("pause");
    	return 0;
    }
    

    aaa.cpp:

    #define _CRT_SECURE_NO_WARNINGS
    #include <iostream>
    #include <locale.h>
    #include <Windows.h>
    using namespace std;
    
    
    int main(int argc, char *argv[])
    {
    	DWORD dwProcessHandle = -1;
    	DWORD dwThreadHandle = -1;
    	char szBuffer[256] = { 0 };
    
    
    	memcpy(szBuffer, argv[1], 8);
    	sscanf(szBuffer, "%x", &dwProcessHandle);
    
    	memset(szBuffer, 0, 256);
    	memcpy(szBuffer, argv[2], 8);
    	sscanf(szBuffer, "%x", &dwThreadHandle);
    
    	printf("获取IE进程、主线程句柄\n");
    	Sleep(1000);
    	//挂起主线程						
    	printf("挂起主线程\n");
    	::SuspendThread((HANDLE)dwThreadHandle);
    
    	Sleep(30000);
    
    	//恢复主线程						
    	::ResumeThread((HANDLE)dwThreadHandle);
    	printf("恢复主线程\n");
    
    	Sleep(5000);
    
    	//关闭ID进程						
    	::TerminateProcess((HANDLE)dwProcessHandle, 1);
    	::WaitForSingleObject((HANDLE)dwProcessHandle, INFINITE);
    
    	printf("ID进程已经关闭.....\n");
    
    
    
    	system("pause");
    	return 0;
    }
    
    

    二. 以挂起的方式创建进程

    int main(int argc, char* argv[])
    {
    	STARTUPINFO ie_si = { 0 };
    	PROCESS_INFORMATION ie_pi;
    	ie_si.cb = sizeof(ie_si);
    
    	//以挂起的方式创建进程								
    	TCHAR szBuffer[256] = TEXT("C:\\Users\\lenovo\\Desktop\\DTDebug\\DTDebug.exe");
    	CreateProcess(
    		NULL,                    // name of executable module							
    		szBuffer,                // command line string							
    		NULL, 					 // SD		
    		NULL,  		             // SD					
    		FALSE,                   // handle inheritance option							
    		CREATE_SUSPENDED,     	 // creation flags  						
    		NULL,                    // new environment block							
    		NULL,                    // current directory name							
    		&ie_si,                  // startup information							
    		&ie_pi                   // process information							
    	);
    
    
    	CONTEXT contx;
    	contx.ContextFlags = CONTEXT_FULL;
    	GetThreadContext(ie_pi.hThread, &contx);
    
    	//获取入口点								
    	DWORD dwEntryPoint = contx.Eax;
    	printf("%x\n", dwEntryPoint);
    
    	//获取ImageBase								
    	char* baseAddress = (CHAR *)contx.Ebx + 8;
    
    	memset(szBuffer, 0, 256);
    
    	ReadProcessMemory(ie_pi.hProcess, baseAddress, szBuffer, 4, NULL);
    	printf("%p\n", szBuffer);
    
    	ResumeThread(ie_pi.hThread);
    
    
    
    	system("pause");
    	return 0;
    }
    

     

     

     

     

     

     

     

     

     

     

     


    展开全文
  • Windows进程管理

    千次阅读 2018-05-30 22:59:16
    (2)通过创建进程、观察正在运行的进程和终止进程的程序设计和调试操作,进一步熟悉操作系统的进程概念,理解 Windows 进程的“一生”。 (3)通过阅读和分析实验程序,学习创建进程、观察进程、终止进程以及父子...

    一、实验目的

    (1)学会使用 VC 编写基本的 Win32 Consol Application(控制台应用程序)。

    (2)通过创建进程、观察正在运行的进程和终止进程的程序设计和调试操作,进一步熟悉操作系统的进程概念,理解 Windows 进程的“一生”。

    (3)通过阅读和分析实验程序,学习创建进程、观察进程、终止进程以及父子进程同步的基本程序设计方法。

    二、总体设计

       2.1背景知识

    Windows 所创建的每个进程都从调用 CreateProcess() API 函数开始,该函数的任务是在对象管理器子系统内初始化进程对象。每一进程都以调用 ExitProcess() 或 TerminateProcess() API 函数终止。通常应用程序的框架负责调用 ExitProcess() 函数。对于 C++ 运行库来说,这一调用发生在应用程序的 main() 函数返回之后。

     

         (1)创建进程
         CreateProcess() 调用的核心参数是可执行文件运行时的文件名及其命令行。表 1-1 详细地列出了每个参数的类型和名称。

    表 1-1 CreateProcess() 函数的参数

    参数名称

    使用目的

    LPCTSTR lpApplivationName

    全部或部分地指明包括可执行代码的 EXE 文件的文件名

    LPCTSTR lpCommandLine

    向可执行文件发送的参数

    LPSECURIITY_ATTRIBUTES
    lpProcessAttributes

    返回进程句柄的安全属性。主要指明这一句柄是否应该由其他
    子进程所继承

    LPSECURIITY_ATTRIBUTES
    lpThreadAttributes

    返回进程的主线程的句柄的安全属性

    BOOL bInheritHandle

    一种标志,告诉系统允许新进程继承创建者进程的句柄

    DWORD dwCreationFlage

    特殊的创建标志 (CREATE_SUSPENDED) 的位标记

    LPVOID lpEnvironment

    向新进程发送的一套环境变量;如为 null 值则发送调用者环境

    LPCTSTR lpCurrentDirectory

    新进程的启动目录

    STARTUPINFO lpStartupInfo

    STARTUPINFO 结构,包括新进程的输入和输出配置的详情

    LPPROCESS_INFORMATION
    lpProcessInformation

    调用的结果块;发送新应用程序的进程和主线程的句柄和 ID

     

        可以指定第一个参数,即应用程序的名称,其中包括相对于当前进程的当前目录的全路径或者利用搜索方法找到的路径; lpCommandLine 参数允许调用者向新应用程序发送数据;接下来的三个参数与进程和它的主线程以及返回的指向该对象的句柄的安全性有关。

    然后是标志参数,用以在 dwCreationFlags 参数中指明系统应该给予新进程什么行为。经常使用的标志是 CREATE_SUSPNDED,告诉主线程立刻暂停。当准备好时,应该使用 ResumeThread() API来启动进程。另一个常用的标志是 CREATE_NEW_CONSOLE,告诉新进程启动自己的控制台窗口,而不是利用父窗口。这一参数还允许设置进程的优先级,用以向系统指明,相对于系统中所有其他
    的活动进程来说,给此进程多少 CPU 时间。
        接着是 CreateProcess() 函数调用所需要的三个通常使用缺省值的参数。第一个参数是lpEnvironment 参数,指明为新进程提供的环境;第二个参数是 lpCurrentDirectory,可用于向主创进程发送与缺省目录不同的新进程使用的特殊的当前目录;第三个参数是 STARTUPINFO 数据结构所必需的,用于在必要时指    

    明新应用程序的主窗口的外观。
        CreateProcess() 的最后一个参数是用于新进程对象及其主线程的句柄和 ID 的返回值缓冲区。以 PROCESS_INFORMATION 结构中返回的句柄调用 CloseHandle() API 函数是重要的,因为如果不将这些句柄关闭的话,有可能危及主创进程终止之前的任何未释放的资源。

     

    (2) 正在运行的进程
        如果一个进程拥有至少一个执行线程,则为正在系统中运行的进程。通常,这种进程使用主线程来指示它的存在。当主线程结束时,调用 ExitProcess() API 函数,通知系统终止它所拥有的所有正在运行、准备运行或正在挂起的其他线程。当进程正在运行时,可以查看它的许多特性,其中少数特性也允许加以修改。
        首先可查看的进程特性是系统进程标识符 (PID) ,可利用 GetCurrentProcessId() API 函数来查看,与 GetCurrentProcess() 相似,对该函数的调用不能失败,但返回的 PID 在整个系统中都可使用。其他的可显示当前进程信息的 API 函数还有 GetStartupInfo()和 GetProcessShutdownParameters() ,可给出进程存活期内的配置详情。

    通常,一个进程需要它的运行期环境的信息。例如 API 函数 GetModuleFileName() 和GetCommandLine() ,可以给出用在 CreateProcess() 中的参数以启动应用程序。在创建应用程序时可使用的另一个 API 函数是 IsDebuggerPresent() 。
        可利用 API 函数 GetGuiResources() 来查看进程的 GUI 资源。此函数既可返回指定进程中的打开的 GUI 对象的数目,也可返回指定进程中打开的 USER 对象的数目。进程的其他性能信息可通过GetProcessIoCounters()、GetProcessPriorityBoost() 、GetProcessTimes() 和 GetProcessWorkingSetSize()
    API 得到。以上这几个 API 函数都只需要具有 PROCESS_QUERY_INFORMATION 访问权限的指向所感兴趣进程的句柄。
        另一个可用于进程信息查询的 API 函数是 GetProcessVersion() 。此函数只需感兴趣进程的 PID(进程标识号) 。这一 API 函数与 GetVersionEx() 的共同作用,可确定运行进程的系统的版本号。


        (3) 终止进程
        所有进程都是以调用 ExitProcess() 或者 TerminateProcess() 函数结束的。但最好使用前者而不要使用后者,因为进程是在完成了它的所有的关闭“职责”之后以正常的终止方式来调用前者的。而外部进程通常调用后者即突然终止进程的进行,由于关闭时的途径不太正常,有可能引起错误的行为。
        TerminateProcess() API 函数只要打开带有 PROCESS_TERMINATE 访问权的进程对象,就可以终止进程,并向系统返回指定的代码。这是一种“野蛮”的终止进程的方式,但是有时却是需要的。如果开发人员确实有机会来设计“谋杀” (终止别的进程的进程) 和“受害”进程 (被终止的进程) 时,应该创建一个进程间通讯的内核对象——如一个互斥程序——这样一来,“受害”进程只在等待或周期性地测试它是否应该终止。


        (4)进程同步
        Windows 提供的常用对象可分成三类:核心应用服务、线程同步和线程间通讯。其中,开发人员可以使用线程同步对象来协调线程和进程的工作,以使其共享信息并执行任务。此类对象包括互锁数据、临界段、事件、互斥体和信号等。
        多线程编程中关键的一步是保护所有的共享资源,工具主要有互锁函数、临界段和互斥体等;另一个实质性部分是协调线程使其完成应用程序的任务,为此,可利用内核中的事件对象和信号。
        在进程内或进程间实现线程同步的最方便的方法是使用事件对象,这一组内核对象允许一个线程对其受信状态进行直接控制 (见表 1-2) 。
        而互斥体则是另一个可命名且安全的内核对象,其主要目的是引导对共享资源的访问。拥有单一访问资源的线程创建互斥体,所有想要访问该资源的线程应该在实际执行操作之前获得互斥体,而在访问结束时立即释放互斥体,以允许下一个等待线程获得互斥体,然后接着进行下去。
        与事件对象类似,互斥体容易创建、打开、使用并清除。利用 CreateMutex() API 可创建互斥体,创建时还可以指定一个初始的拥有权标志,通过使用这个标志,只有当线程完成了资源的所有的初始化工作时,才允许创建线程释放互斥体。

    表 1-2 用于管理事件对象的 API

    API 名称

    描述

    CreateEvent()

    在内核中创建一个新的事件对象。此函数允许有安全性设置、手工还是
    自动重置的标志以及初始时已接受还是未接受信号状态的标志

    OpenEvent()

    创建对已经存在的事件对象的引用。此 API 函数需要名称、继承标志和
    所需的访问级别

    SetEvent()

    将手工重置事件转化为已接受信号状态

    ResetEvent()

    将手工重置事件转化为非接受信号状态

    PulseEvent()

    将自动重置事件对象转化为已接受信号状态。当系统释放所有的等待它
    的线程时此种转化立即发生

     

    为了获得互斥体,首先,想要访问调用的线程可使用 OpenMutex() API 来获得指向对象的句柄;然后,线程将这个句柄提供给一个等待函数。当内核将互斥体对象发送给等待线程时,就表明该线程获得了互斥体的拥有权。当线程获得拥有权时,线程控制了对共享资源的访问——必须设法尽快地放弃互斥体。放弃共享资源时需要在该对象上调用 ReleaseMute() API。然后系统负责将互斥体拥有权传递给下一个等待着的线程 (由到达时间决定顺序) 。

     

    2.2 设计步骤

        (1)编写基本的 Win32 Consol Application
        步骤 1:登录进入 Windows 系统,启动 VC++ 6.0。
        步骤 2:在“FILE”菜单中单击“NEW”子菜单,在“projects”选项卡中选择“Win32 ConsolApplication”,然后在“Project name”处输入工程名,在“Location” 处输入工程目录。创建一个新的控制台应用程序工程。
        步骤 3:在“FILE”菜单中单击“NEW”子菜单,在“Files”选项卡中选择“C++ Source File”,然后在“File” 处输入 C/C++源程序的文件名。
        步骤 4:将清单 1-1 所示的程序清单复制到新创建的 C/C++源程序中。编译成可执行文件。
        步骤 5:在“开始”菜单中单击“程序”-“附件”-“命令提示符”命令,进入 Windows“命令提示符”窗口,然后进入工程目录中的 debug 子目录,执行编译好的可执行程序,列出运行结果(如果运行不成功,则可能的原因是什么?)
        (2) 创建进程
         本实验显示了创建子进程的基本框架。该程序只是再一次地启动自身,显示它的系统进程 ID和它在进程列表中的位置。
        步骤 1:创建一个“Win32 Consol Application”工程,然后拷贝清单 1-2 中的程序,编译成可执行文件。
        步骤 2:在“命令提示符”窗口运行步骤 1 中生成的可执行文件,列出运行结果。按下ctrl+alt+del,调用 windows 的任务管理器,记录进程相关的行为属性。
        步骤 3:在“命令提示符”窗口加入参数重新运行生成的可执行文件,列出运行结果。按下ctrl+alt+del,调用 windows 的任务管理器,记录进程相关的行为属性。
        步骤 4:修改清单 1-2 中的程序,将nClone的定义和初始化方法按程序注释中的修改方法进行修改,编译成可执行文件(执行前请先保存已经完成的工作)。再按步骤 2 中的方式运行,看看结果会有什么不一样。列出行结果。从中你可以得出什么结论?说明nClone的作用。 变量的定义和初始化方法(位置)对程序的执行结果有影响吗?为什么?
       (3) 父子进程的简单通信及终止进程
        步骤 1:创建一个“Win32 Consol Application”工程,然后拷贝清单 1-3 中的程序,编译成可执行文件。
        步骤 2:在 VC 的工具栏单击“Execute Program” (执行程序) 按钮,或者按 Ctrl + F5 键,或者在“命令提示符”窗口运行步骤 1 中生成的可执行文件,列出运行结果。
        步骤 3:按源程序中注释中的提示,修改源程序 1-3,编译执行(执行前请先保存已经完成的工作),列出运行结果。在程序中加入跟踪语句,或调试运行程序,同时参考 MSDN 中的帮助文件CreateProcess()的使用方法,理解父子进程如何传递参数。给出程序执行过程的大概描述。
        步骤 4:按源程序中注释中的提示,修改源程序 1-3,编译执行,列出运行结果。
        步骤 5:参 考 MSDN 中 的 帮 助 文 件 CreateMutex() 、 OpenMutex() 、 ReleaseMutex() 和WaitForSingleObject()的使用方法,理解父子进程如何利用互斥体进行同步的。给出父子进程同步过程的一个大概描述。

     

    三、详细设计

     

    清单 1-1

    // hello 项目
    # include <iostream>
    void main()
    {
    std::cout << "Hello, Win32 Consol Application" << std :: endl ;
    }

    清单 1-2

    #include <windows.h>
    #include <iostream>
    #include <stdio.h>
    // 创建传递过来的进程的克隆过程并赋于其 ID 值
    void StartClone(int nCloneID)
    {
    // 提取用于当前可执行文件的文件名
    TCHAR szFilename[MAX_PATH] ;
    GetModuleFileName(NULL, szFilename, MAX_PATH) ;
    // 格式化用于子进程的命令行并通知其 EXE 文件名和克隆 ID
    TCHAR szCmdLine[MAX_PATH];
    sprintf(szCmdLine,"\"%s\" %d",szFilename,nCloneID);
    // 用于子进程的 STARTUPINFO 结构
    STARTUPINFO si;
    ZeroMemory(&si , sizeof(si) ) ;
    si.cb = sizeof(si) ; // 必须是本结构的大小
    // 返回的用于子进程的进程信息
    PROCESS_INFORMATION pi;
    // 利用同样的可执行文件和命令行创建进程,并赋于其子进程的性质
    BOOL bCreateOK=::CreateProcess(
    szFilename, // 产生这个 EXE 的应用程序的名称
    szCmdLine, // 告诉其行为像一个子进程的标志
    NULL, // 缺省的进程安全性
    NULL, // 缺省的线程安全性
    FALSE, // 不继承句柄
    CREATE_NEW_CONSOLE, // 使用新的控制台
    NULL, // 新的环境
    NULL, // 当前目录
    &si, // 启动信息
    &pi) ; // 返回的进程信息
    // 对子进程释放引用
    if (bCreateOK)
    {
    CloseHandle(pi.hProcess) ;
    CloseHandle(pi.hThread) ;
    }
    }
    int main(int argc, char* argv[] )
    {
    // 确定派生出几个进程,及派生进程在进程列表中的位置
    int nClone=0;
    //修改语句: int nClone;
    //第一次修改: nClone=0;
    nClone=0;
    if (argc > 1)
    {
    // 从第二个参数中提取克隆 ID
    :: sscanf(argv[1] , "%d" , &nClone) ;
    }
    //第二次修改: nClone=0;
    // 显示进程位置
    std :: cout << "Process ID:" << :: GetCurrentProcessId()
    << ", Clone ID:" << nClone
    << std :: endl;
    // 检查是否有创建子进程的需要
    const int c_nCloneMax=5;
    if (nClone < c_nCloneMax)
    {
    // 发送新进程的命令行和克隆号
    StartClone(++nClone) ;
    }
    // 等待响应键盘输入结束进程
    getchar();
    return 0;
    }

    清单 1-3

    // procterm 项目
    # include <windows.h>
    # include <iostream>
    # include <stdio.h>
    static LPCTSTR g_szMutexName = "w2kdg.ProcTerm.mutex.Suicide" ;
    // 创建当前进程的克隆进程的简单方法
    void StartClone()
    {
    // 提取当前可执行文件的文件名
    TCHAR szFilename[MAX_PATH] ;
    GetModuleFileName(NULL, szFilename, MAX_PATH) ;
    // 格式化用于子进程的命令行,字符串“ child”将作为形参传递给子进程的 main 函数
    TCHAR szCmdLine[MAX_PATH] ;
    //实验 1-3 步骤 3:将下句中的字符串 child 改为别的字符串,重新编译执行,执行前请先保存已经完成的工作
    sprintf(szCmdLine, "\"%s\"child" , szFilename) ;
    // 子进程的启动信息结构
    STARTUPINFO si;
    ZeroMemory(&si,sizeof(si)) ;
    si.cb = sizeof(si) ; // 应当是此结构的大小
    // 返回的用于子进程的进程信息
    PROCESS_INFORMATION pi;
    // 用同样的可执行文件名和命令行创建进程,并指明它是一个子进程
    BOOL bCreateOK=CreateProcess(
    szFilename, // 产生的应用程序的名称 (本 EXE 文件)
    szCmdLine, // 告诉我们这是一个子进程的标志
    NULL, // 用于进程的缺省的安全性
    NULL, // 用于线程的缺省安全性
    FALSE, // 不继承句柄
    CREATE_NEW_CONSOLE, //创建新窗口
    NULL, // 新环境
    NULL, // 当前目录
    &si, // 启动信息结构
    &pi ) ; // 返回的进程信息
    // 释放指向子进程的引用
    if (bCreateOK)
    {
    CloseHandle(pi.hProcess) ;
    CloseHandle(pi.hThread) ;
    }
    }
    void Parent()
    {
    	//当等待仍在挂起状态时,句柄被关闭,那么函数行为是未定义的。该句柄必须具有 SYNCHRONIZE 访问权限。
    // 创建“自杀”互斥程序体
    HANDLE hMutexSuicide=CreateMutex(
    NULL, // 缺省的安全性
    TRUE, // 最初拥有的
    g_szMutexName) ; // 互斥体名称
    if (hMutexSuicide != NULL)
    {
    // 创建子进程
    std :: cout << "Creating the child process." << std :: endl;
    StartClone() ;
    // 指令子进程“杀”掉自身
    std :: cout << "Telling the child process to quit. "<< std :: endl;
    //等待父进程的键盘响应
    getchar() ;
    //释放互斥体的所有权,这个信号会发送给子进程的 WaitForSingleObject 过程
    ReleaseMutex(hMutexSuicide) ;
    // 消除句柄
    CloseHandle(hMutexSuicide) ;
    }
    }
    void Child()
    {
    // 打开“自杀”互斥体
    HANDLE hMutexSuicide = OpenMutex(
    SYNCHRONIZE, // 打开用于同步
    FALSE, // 不需要向下传递
    g_szMutexName) ; // 名称
    if (hMutexSuicide != NULL)
    {
    // 报告我们正在等待指令
    std :: cout <<"Child waiting for suicide instructions. " << std :: endl;
    //子进程进入阻塞状态,等待父进程通过互斥体发来的信号
    WaitForSingleObject(hMutexSuicide, INFINITE) ;
    //实验 1-3 步骤 4:将上句改为 WaitForSingleObject(hMutexSuicide, 0) ,重新编译执行
    //dwMilliseconds[in]定时时间间隔,单位为milliseconds(毫秒).如果指定一个非零值,函数处于等待状态直到hHandle标记的对象被触发,或者时间到了。如果dwMilliseconds为0,对象没有被触发信号,函数不会进入一个等待状态,它总是立即返回。如果dwMilliseconds为INFINITE,对象被触发信号后,函数才会返回。
    
    // 准备好终止,清除句柄
    std :: cout << "Child quiting." << std :: endl;
    CloseHandle(hMutexSuicide) ;
    }
    }
    int main(int argc, char* argv[] )
    {
    // 决定其行为是父进程还是子进程
    if (argc>1 && :: strcmp(argv[1] , "child" )== 0)
    {
    Child() ;
    }
    else
    {
    Parent() ;
    }
    return 0;
    }

    四、实验结果与分析

       (1)编写基本的 Win32 Consol Application

    运行结果:

     

       (2) 创建进程

    步骤二运行结果:

     

    进程相关属性:

     

     

    步骤三运行结果:加入参数n(n<=5),nClone ID n~5的6-n个进程

     

    Windows的任务管理器显示此6-n个进程。

     

     

    步骤四运行结果:程序进入死循环,无限创建进程。结论:nClone的值控制着创建的进程数。变量的定义和初始化对程序的执行结果有影响,因为如果初始化在判定语句内,程序会受其影响!

     

       (3) 父子进程的简单通信及终止进程

    步骤二运行结果:运行父子两个进程,在父进程中输入字符关闭子进程,形成父子进程的简单通信。

     

    步骤三运行结果:由于传入的参数与child不同,所以一直执行Parent();函数,一直创建子进程。创建子进程时,格式化用于子进程的命令行,字符串“ child”将作为形参传递给子进程的 main 函数(sprintf(szCmdLine, "\"%s\"child" , szFilename) ;)。

     

    步骤四运行结果:子进程一闪而过。/dwMilliseconds[in]定时时间间隔,单位为milliseconds(毫秒).如果指定一个非零值,函数处于等待状态直到hHandle标记的对象被触发,或者时间到了。如果dwMilliseconds为0,对象没有被触发信号,函数不会进入一个等待状态,它总是立即返回。如果dwMilliseconds为INFINITE,对象被触发信号后,函数才会返回。

     

     

    步骤五:

     

    CreateMutex()使用方法:

     

    HANDLE CreateMutex(

    LPSECURITY_ATTRIBUTESlpMutexAttributes, // 指向安全属性的指针

    BOOLbInitialOwner, // 初始化互斥对象的所有者

    LPCTSTRlpName // 指向互斥对象名的指针

    );

    创建一个互斥体(MUTEX)

    返回值:

    Long,如执行成功,就返回互斥体对象的句柄;零表示出错。会设置GetLastError。如果返回的是一个有效句柄,但指定的名字已经存在,GetLastError也会设为ERROR_ALREADY_EXISTS,bInitialOwner的值将会被忽略。如果调用者限制了权限,GetLastError将会返回ERROR_ACCESS_DENIED,这个时候应该使用OpenMutex函数。

    参数类型及说明:

    lpMutexAttributes SECURITY_ATTRIBUTES,指定一个SECURITY_ATTRIBUTES结构,或传递零值(将参数声明为ByVal As Long,并传递零值),表示使用不允许继承的默认描述符

    bInitialOwner BOOL,如创建进程希望立即拥有互斥体,则设为TRUE。一个互斥体同时只能由一个线程拥有

    lpName String,指定互斥体对象的名字。用vbNullString创建一个未命名的互斥体对象。如已经存在拥有这个名字的一个事件,则打开现有的已命名互斥体。这个名字可能不与现有的事件、信号机、可等待计时器或文件映射相符

     

     

    OpenMutex()使用方法:

     

    OpenMutex函数为现有的一个已命名互斥体对象创建一个新句柄。

    函数功能:

    函数原型: HANDLE OpenMutex(

    DWORD dwDesiredAccess// access

    BOOL bInheritHandle// inheritance option

    LPCTSTR lpName // object name

    );

    参数:

    dwDesiredAccess:

    MUTEX_ALL_ACCESS 请求对互斥体的完全访问

    MUTEX_MODIFY_STATE 允许使用 ReleaseMutex 函数

    SYNCHRONIZE 允许互斥体对象同步使用

    bInheritHandle : 如希望子进程能够继承句柄,则为TRUE

    lpName :要打开对象的名字

    返回值:

    如执行成功,返回对象的句柄;零表示失败。若想获得更多错误信息,请调用GetLastError函数。

     

     

    ReleaseMutex()使用方法:

     

     

    ReleaseMutex函数的功能是释放互斥对象的控制权

    函数原型:

    BOOL WINAPI ReleaseMutex(

    HANDLE hMutex

     

    );

    返回值:

     

    BOOL,TRUE表示成功,FALSE表示失败。

    参数表:

    hMutex:HANDLE,制定一个互斥体的句柄。

     

    WaitForSingleObject()使用方法:

     

    等待函数可使线程自愿进入等待状态,直到一个特定的内核对象变为已通知状态为止。

    WaitForSingleObject 函数

    DWORD WaitForSingleObject(

    HANDLE hObject,

              DWORD dwMilliseconds

    );

    第一个参数:hObject标识一个能够支持被通知/未通知的内核对象(前面列出的任何一种对象都适用)。

    第二个参数:dwMilliseconds允许该线程指明,为了等待该对象变为已通知状态,它将等待多长时间。(INFINITE为无限时间量,INFINITE已经定义为0xFFFFFFFF(或-1))

    传递INFINITE有些危险如果对象永远不变为已通知状态,那么调用线程永远不会被唤醒,它将永远处于死锁状态,不过,它不会浪费宝贵的C P U时间。

    父子进程同步过程的一个大概描述:父进程创建“自杀”互斥程序体,参数值为TRUE,最初拥有,函数最后父进程释放互斥体所有权。子进程OpenMutex();打开互斥体获得句柄,WaitForSingleObject(hMutexSuicide, INFINITE) ;等待对象信号,如果dwMilliseconds为INFINITE,对象被触发信号后,函数才会返回。终止时,CloseHandle(hMutexSuicide) ;消除句柄

    五、小结与心得体会

    通过本实验,我学会使用 VC 的 Win32 Consol Application(控制台应用程序)创建进程并且观察正在运行的进程和终止进程的程序设计和调试操作,进一步熟悉操作系统的进程概念,理解 Windows 进程的“一生”。通过阅读和分析实验程序,我学会了创建进程、观察进程、终止进程以及父子进程同步的基本程序设计方法。

     

     

     

    展开全文
  • Windows进程查找

    千次阅读 2019-09-04 20:23:05
    Windows下根据名称查找进程 使用vs调试C++程序时,有时由于强制退出,会出现 ***.exe无法写入 的错误,重启vs甚至都无法解决。 原因 由于调试强制结束,导致***.exe进程还在后台运行。 解决办法 打开命令提示符,...

    Windows下根据名称查找进程

    使用vs调试C++程序时,有时由于强制退出,会出现 ***.exe无法写入 的错误,重启vs甚至都无法解决。

    原因

    由于调试强制结束,导致***.exe进程还在后台运行。

    解决办法

    打开命令提示符,强制结束该后台进程:
    1.Ctrl + R ,输入cmd 打开命令提示符;
    2.查找进程, ***.exe 表示自己要查找的进程名称:

    tasklist | find "*.exe"
    

    显示如下:

    testServer.exe               16984 Console                    1         76 K
    

    其中16984就是要找的进程的PID。
    3.强制关闭进程:

    taskkill -PID 16984 -F
    

    重新启动调试,成功!!!

    展开全文
  • windows进程打开的最大句柄数目

    千次阅读 2013-02-20 15:21:20
    最近一个服务程序在长时间运行中句柄不断上涨,最高达到了40000多个,停止服务后也不会下降...1:一个windows进程最多有1600万个句柄,这是理论上的; 2:句柄表是从系统的换页内存池中分配的,所以在未达到1600万的数


    最近一个服务程序在长时间运行中句柄不断上涨,最高达到了40000多个,停止服务后也不会下降,所以造成泄漏的可能性很大;

    虽然尚未造成程序使用问题,还是需要解决;

    通过debug diagnose可以大概定位了具体位置

    下面是关于进程句柄的一些细节。


    1:一个windows进程最多有1600万个句柄,这是理论上的;

    2:句柄表是从系统的换页内存池中分配的,所以在未达到1600万的数量前,很可能系统换页内存池耗尽了

    3:可以通过 sysinternals Testlimit 的工具来检测当前系统最大的句柄数目。


    摘自"Windows Internals Fifth Edition "

    An object handle is an index into a process-specific handle table, pointed to by the executive
    process (EPROCESS) block (described in Chapter 5). The first handle index is 4, the second
    8, and so on. A process’s handle table contains pointers to all the objects that the process
    has opened a handle to. Handle tables are implemented as a three-level scheme, similar
    to the way that the x86 memory management unit implements virtual-to-physical address
    152 Windows Internals, Fifth Edition
    translation, giving a maximum of more than 16,000,000 handles per process


    The test program Testlimit from Sysinternals has an option to open handles to an object
    until it cannot open any more handles. You can use this to see how many handles can
    be created in a single process on your system. Because handle tables are allocated from
    paged pool, you might run out of paged pool before you hit the maximum number of
    handles that can be created in a single process. To see how many handles you can create
    on your system, follow these steps:
    1. Download the Testlimit .zip file from www.microsoft.com/technet/ sysinternals, and
    unzip it into a directory.
    Run Process Explorer, and then click View and then System Information. Notice
    the current and maximum size of paged pool. (To display the maximum pool size
    values, Process Explorer must be configured properly to access the symbols for
    the kernel image, Ntoskrnl.exe.) Leave this system information display running so
    that you can see pool utilization when you run the Testlimit program.
    3. Open a command prompt.
    4. Run the Testlimit program with the -h switch (do this by typing testlimit –h).
    When Testlimit fails to open a new handle, it will display the total number of
    handles it was able to create. If the number is less than approximately 16 million,
    you are probably running out of paged pool before hitting the theoretical perprocess
    handle limit.
    5. Close the Command Prompt window; doing this will kill the Testlimit process, thus
    closing all the open handles.
    展开全文
  • 在linux系统中,进程打开的文件句柄数量的限制,可用ulimit命令来查看和修改,或者修改/etc/security/limits.conf也可以修改。但在windows中,目前没有找到方便的方法查看这个值。 下面这段代码可以用来查看该值,...
  • Windows进程控制

    千次阅读 2016-07-14 19:30:39
    Windows系统中,应用程序都以进程的形式存在于内存中。当运行一个程序的时候,操作系统就会将这个程序装入内存,并分配各种运行程序所需的资源,为进程创建主线程。 系统也提供了任务管理器,可供我们使用。管理...
  • Windows进程详解(完整版)

    千次阅读 2019-03-27 15:47:17
    Windows进程详解(完整版)
  • windows服务中打开窗口进程

    千次阅读 2006-11-09 14:46:00
    IVR地方业务中有一个DBA_BJLDNW工具要在服务器上运行着.一旦断开业务即中止.需要写一个守护程序监视它,一旦发现关闭了即重新...问题是windows服务不是窗口进程,在这个进程中调用ShellExecute打开的应用程序也是在后台
  • windows进程间通信

    千次阅读 2014-10-18 08:32:03
    摘 要: 随着人们对应用程序的要求越来越高,单进程应用在许多场合已不能满足人们的要求。编写多进程/多线程程序成为现代程序设计的一个重要特点,在多进程程序设计中,进程间的通信是不可避免的。Microsoft Win32...
  • windows进程详解

    千次阅读 2011-11-18 08:14:35
    xp系统进程信息 系统进程 [system process] alg.exe csrss.exe ddhelp.exe dllhost.exe explorer.exe inetinfo.exe internat.exe kernel32.dll lsass.exe mdm.exe mmtask.tsk mprexe.exe msgsrv32.exe ...
  • windows进程创建跟踪

    千次阅读 2014-06-14 23:02:00
    点击打开链接
  • Windows进程的创建

    千次阅读 2009-12-08 23:11:00
    创建Windows进程控制块EPROCESS及相应的句柄 3.创建该进程的第一个线程,包括其堆栈、上下文,及线程控制块ETHREAD 4.将新创进程通知Windows子系统(csrss.exe) 5.启动初始线程运行 5.在新创进程和线程的上下文中...
  • windows进程句柄表

    千次阅读 2012-06-13 02:49:16
    一.介绍 1.什么是句柄 ...“当一个进程根据名称来创建或者打开一个对象时,他收到一个句柄,然后通过此举并来访问该对象。”(深入解析windows操作系统,P135)。这里HANDLE类型的作用已经很清楚
  • Windows进程间通信

    万次阅读 2013-01-16 12:43:15
    因为Windows中每个进程都有自己的虚拟地址空间,所以一个进程无法访问到别一个进程的地址空间,因此相对来说进程间的通信要复杂一些。Windows操作系统为应用程序之间的进程间通信,数据共享提供了很多机制,称为...
  • 利用 bat 脚本强制杀死 Windows 进程

    千次阅读 2020-03-24 16:52:10
    @echo off  :start taskkill /im a.exe /f taskkill /im b.exe /f goto start 保存为 clear.bat 文件,打开后将一直无限循环...不断杀死 Windows 进程中的 a.exe b.exe 等进程,可以用来强制清理广告弹窗的进程 ...
  • Windows 进程的句柄表

    千次阅读 2015-03-12 14:49:32
    本文源自《Windows内核原理与实现》第3章Windows 进程和线程 3.4.1 Windows 进程的句柄表(1) 上一章介绍了Windows 内核中的对象管理器,Windows 执行体实现了一套对象机制来管理各种资源或实体。每种...
  • 通过Windows进程ID获取窗口句柄

    万次阅读 2016-11-01 11:33:27
    通过Windows进程ID获取窗口句柄的2种方法
  • windows系统环境下 ,通过进程名称查看该进程是否存在,存在的话 taskkill结束进程。 public class ProcessUtil { private static final Log logger = LogFactory.getLog(ProcessUtil.class); ...
  • 自制Window监控工具第一步:获取系统进程
  • Windows进程小结

    千次阅读 2009-05-01 22:48:00
    lsass.exe 进程名称: Local Security Authority Service 进程名称: lsass.exe是一个系统进程,用于微软Windows系统的安全机制。它用于本地安全和登陆策略。注意:lsass.exe也有可能是Windang.worm、irc.ratsou.b...
  • Windows提升进程权限

    千次阅读 2015-01-03 15:00:47
    Windows提升进程权限 文章一: 在枚举/结束系统进程或操作系统服务时,会出现权限不足而失败的情况,这时就需要提升自己进程到系统权限,其实提升权限的代码很简单的,看过的最经典的应该是《WINDOWS核心编程》第...
  • 查看本机所有进程 根据pid查询指定进程 查看远程所有进程 Taskkill 简述 根据进程PID结束 根据进程图像名结束 /f 强制结束进程 /t 结束进程树 Tasklist 简述 1、"Tasklist"命令是一个用来显示运行在本地或...
  • Windows进程间通信的各种方法

    千次阅读 2016-08-05 11:46:22
    1 Windows进程间通信的各种方法 进程是装入内存并准备执行的程序,每个进程都有私有的虚拟地址空间,由代码、数据以及它可利用的系统资源(如文件、管道等)组成。 多进程/多线程是Windows操作系统的一个基本...
  • Windows下查看进程及结束进程命令

    千次阅读 2017-12-28 22:59:34
    1.首先windows+R,打开运行界面2.输入cmd,点击确定进入命令行模式;3.查看占用8080端口的进程号 netstat –aon | findstr “8080” 可知,进程号为7444的进程占用了8080端口4.使用命令 tasklist | findstr “7444...
  • 强行终止windows进程

    千次阅读 2005-08-11 17:32:00
    1,根据进程名终止这种方法是通过winxp系统下的taskkill命令来实现的,在使用该方法之前,首先得打开任务管理器,找到你想终止的进程,然后在"运行"对话框中执行"cmd",再在DOS命令符中执行"taskkill /im xxx" ,其中xxx为...
  • Windows进程间互斥锁

    万次阅读 2014-06-10 17:12:33
    Windows的互斥锁Mutex是可以在进程间使用的。  CreateMutex时可以指定一个mutex名称,此名称可以被其他进程或线程使用。CreateMutex的第二个参数BOOL bInitialOwner表示在创建后是不是立刻获取此锁,相当于立即...
  • 强制关闭Windows进程

    千次阅读 2016-12-24 15:08:09
    最近笔记本不知怎么搞的,软件...打开cmd,输入命令taskkill /im 692a6af.exe /f 其中692a6af.exe是进程名称,打开任务管理器可以看到进程名称,其实也可以根据PID杀死,但是这个进程PID一直在变。/f是强制杀死命令,如

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 271,797
精华内容 108,718
关键字:

windows进程怎么打开