编写批处理文件以自动执行Windows框上的某些操作时，我需要将其执行暂停几秒钟（通常在测试/等待循环中，等待进程启动）。当时，我能找到的最佳解决方案是使用ping（我不告诉你）来达到预期的效果。我已经找到了更好的写了它在这里，它描述了一个可调用“wait.bat”，实现如下：

@ping 127.0.0.1 -n 2 -w 1000 > nul
@ping 127.0.0.1 -n %1% -w 1000> nul

然后，您可以在自己的批处理文件中包含对wait.bat的调用，传递进入睡眠的秒数。

显然Windows 2003 Resource Kit提供了一个类似Unix的sleep命令（最后！）。同时，对于仍然使用Windows XP，Windows 2000或（不幸的）Windows NT的我们来说，还有更好的方法吗？

我sleep.py在接受的答案中修改了脚本，以便如果在命令行上未传递任何参数，则默认为一秒钟：

import time, sys

time.sleep(float(sys.argv[1]) if len(sys.argv) > 1 else 1)

更新

该timeout命令，可以从Windows Vista和以后应在命令中使用，如在另一所描述的回答了这个问题。接下来是一个古老的答案。

旧答案

如果您安装了Python，或者不介意安装它（它也具有其他用途:)，只需创建以下sleep.py脚本并将其添加到PATH中的某个位置即可：

import time, sys

time.sleep(float(sys.argv[1]))

如果您有此需要，它将允许亚秒级的暂停（例如1.5秒，0.1等）。如果您希望将其称为sleep而不是sleep.py，则可以将.PY扩展名添加到PATHEXT环境变量中。在Windows XP上，您可以在以下位置进行编辑：

我的电脑→属性（菜单）→高级（选项卡）→环境变量（按钮）→系统变量（框架）

timeout从Windows Vista以后的版本中可以使用该命令：

c:\> timeout /?

TIMEOUT [/T] timeout [/NOBREAK]

Description:
    This utility accepts a timeout parameter to wait for the specified
    time period (in seconds) or until any key is pressed. It also
    accepts a parameter to ignore the key press.

Parameter List:
    /T        timeout       Specifies the number of seconds to wait.
                            Valid range is -1 to 99999 seconds.

    /NOBREAK                Ignore key presses and wait specified time.

    /?                      Displays this help message.

NOTE: A timeout value of -1 means to wait indefinitely for a key press.

Examples:
    TIMEOUT /?
    TIMEOUT /T 10
    TIMEOUT /T 300 /NOBREAK
    TIMEOUT /T -1

注意：它不适用于输入重定向-简单示例：

C:\>echo 1 | timeout /t 1 /nobreak
ERROR: Input redirection is not supported, exiting the process immediately.

ping当无法（或不想）添加更多可执行文件或安装任何其他软件时，如何使用概述的方法。

你应该查验的东西是不存在的，并使用-w标志，以便它的时间量之后出现故障，无法查验的东西，是有（如本地主机）-n倍。这使您可以处理不到一秒钟的时间，而且我认为它稍微更准确。

例如

（测试未采用1.1.1.1）

ECHO Waiting 15 seconds

PING 1.1.1.1 -n 1 -w 15000 > NUL
  or
PING -n 15 -w 1000 127.1 >NUL

SLEEP.exe包含在大多数资源工具包中，例如Windows Server 2003资源工具包，也可以安装在Windows XP上。

Usage:  sleep      time-to-sleep-in-seconds
        sleep [-m] time-to-sleep-in-milliseconds
        sleep [-c] commited-memory ratio (1%-100%)

我不同意我在这里找到的答案。

我完全基于Windows XP功能使用以下方法在批处理文件中进行延迟：

DELAY.BAT：

@ECHO OFF
REM DELAY seconds

REM GET ENDING SECOND
FOR /F "TOKENS=1-3 DELIMS=:." %%A IN ("%TIME%") DO SET /A H=%%A, M=1%%B%%100, S=1%%C%%100, ENDING=(H*60+M)*60+S+%1

REM WAIT FOR SUCH A SECOND
:WAIT
FOR /F "TOKENS=1-3 DELIMS=:." %%A IN ("%TIME%") DO SET /A H=%%A, M=1%%B%%100, S=1%%C%%100, CURRENT=(H*60+M)*60+S
IF %CURRENT% LSS %ENDING% GOTO WAIT

您也可以在计算中插入日期，这样，当延迟间隔超过午夜时，该方法也将起作用。

我遇到了类似的问题，但是我只是关闭了一个很短的C ++控制台应用程序来做同样的事情。只需运行MySleep.exe 1000，这可能比下载/安装整个资源工具包容易。

#include <tchar.h>
#include <stdio.h>
#include "Windows.h"

int _tmain(int argc, _TCHAR* argv[])
{
    if (argc == 2)
    {
        _tprintf(_T("Sleeping for %s ms\n"), argv[1]);
        Sleep(_tstoi(argv[1]));
    }
    else
    {
        _tprintf(_T("Wrong number of arguments.\n"));
    }
    return 0;
}

在服务器故障处，提出了类似的问题，解决方案是：

choice /d y /t 5 > nul

您可以使用Windows cscript WSH层和以下wait.js JavaScript文件：

if (WScript.Arguments.Count() == 1)
    WScript.Sleep(WScript.Arguments(0)*1000);
else
    WScript.Echo("Usage: cscript wait.js seconds");

根据您的兼容性需求，可以使用ping：

ping -n <numberofseconds+1> localhost >nul 2>&1

例如等待5秒钟，使用

ping -n 6 localhost >nul 2>&1

或在Windows 7或更高版本上使用timeout：

timeout 6 >nul

您可以使用ping：

ping 127.0.0.1 -n 11 -w 1000 >nul: 2>nul:

它将等待10秒钟。

您必须使用11的原因是因为第一次ping立即发出，而不是一秒钟后发出。该数字应始终比您要等待的秒数大一。

请记住，的目的-w不是等待一秒钟。这是确保您等待没有更多的一秒中有网络问题的事件。ping它自己每秒将发送一个ICMP数据包。本地主机可能不需要它，但是旧习惯很难解决。

使用ping有更好的睡眠方式。您将要ping通一个不存在的地址，因此可以指定毫秒精度的超时。幸运的是，这样的地址是在标准（RFC 3330）中定义的，并且是192.0.2.x。这不是伪造的，它实际上是一个不存在的唯一目的的地址（可能不清楚，但即使在本地网络中也适用）：

192.0.2.0/24-此块分配为“ TEST-NET”，用于文档和示例代码。它通常与供应商和协议文档中的域名example.com或example.net结合使用。此块内的地址不应出现在公共Internet上。

要睡眠123毫秒，请使用 ping 192.0.2.1 -n 1 -w 123 >nul

如果您的系统上装有PowerShell，则只需执行以下命令：

powershell -command "Start-Sleep -s 1"

编辑：从我对类似主题的回答中，人们提出了一个问题，即启动Powershell所需的时间与您要等待的时间相比是很重要的。如果等待时间的准确性很重要（即不接受一两个秒的额外延迟），则可以使用以下方法：

powershell -command "$sleepUntil = [DateTime]::Parse('%date% %time%').AddSeconds(5); $sleepDuration = $sleepUntil.Subtract((get-date)).TotalMilliseconds; start-sleep -m $sleepDuration"

这会花费执行Windows命令的时间，而powershell脚本会休眠直到该时间之后的5秒钟。因此，只要Powershell启动时间少于睡眠时间，这种方法就可以工作（在我的机器上大约为600ms）。

timeout /t <seconds> <options>

例如，要使脚本执行不间断的2秒等待：

timeout /t 2 /nobreak >NUL

这意味着脚本将等待2秒再继续。

默认情况下，按键会中断超时，因此/nobreak如果您不希望用户能够中断（取消）等待，请使用开关。此外，超时将提供每秒的通知，以通知用户还需等待多长时间；这可以通过管道将命令被去除NUL。

编辑：正如@martineau 在注释中指出的那样，该timeout命令仅在Windows 7及更高版本上可用。此外，该ping命令使用的处理器时间少于timeout。我仍然相信在timeout可能的地方使用它，因为它比ping“ hack” 更具可读性。在这里阅读更多。

只需将其放在您要等待的批处理文件中即可。

@ping 127.0.0.1 -n 11 -w 1000 > null

在记事本中，输入：

@echo off
set /a WAITTIME=%1+1
PING 127.0.0.1 -n %WAITTIME% > nul
goto:eof

现在，将另存为wait.bat保存在文件夹C：\ WINDOWS \ System32中，然后每当要等待时，请使用：

CALL WAIT.bat <whole number of seconds without quotes>

该资源工具包，始终包含着这一点。至少从Windows 2000开始。

另外，Cygwin软件包sleep在路径中包含一个-plop，并包含cygwin.dll（或任何它所称的）名称和方法！

我喜欢阿卡尼的回应。我添加了它来处理日期，还使它能够处理厘秒（%TIME%输出H:MM:SS.CC）：

:delay
SET DELAYINPUT=%1
SET /A DAYS=DELAYINPUT/8640000
SET /A DELAYINPUT=DELAYINPUT-(DAYS*864000)

::Get ending centisecond (10 milliseconds)
FOR /F "tokens=1-4 delims=:." %%A IN ("%TIME%") DO SET /A H=%%A, M=1%%B%%100, S=1%%C%%100, X=1%%D%%100, ENDING=((H*60+M)*60+S)*100+X+DELAYINPUT
SET /A DAYS=DAYS+ENDING/8640000
SET /A ENDING=ENDING-(DAYS*864000)

::Wait for such a centisecond
:delay_wait
FOR /F "tokens=1-4 delims=:." %%A IN ("%TIME%") DO SET /A H=%%A, M=1%%B%%100, S=1%%C%%100, X=1%%D%%100, CURRENT=((H*60+M)*60+S)*100+X
IF DEFINED LASTCURRENT IF %CURRENT% LSS %LASTCURRENT% SET /A DAYS=DAYS-1
SET LASTCURRENT=%CURRENT%
IF %CURRENT% LSS %ENDING% GOTO delay_wait
IF %DAYS% GTR 0 GOTO delay_wait
GOTO :EOF

我一直在使用此C＃睡眠程序。如果C＃是您的首选语言，对您来说可能更方便：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace sleep
{
    class Program
    {
        static void Main(string[] args)
        {
            if (args.Length == 1)
            {
                double time = Double.Parse(args[0]);
                Thread.Sleep((int)(time*1000));
            }
            else
            {
                Console.WriteLine("Usage: sleep <seconds>\nExample: sleep 10");
            }
        }
    }
}

Perl一线式甚至比Python解决方案轻巧。

要睡眠七秒钟，请将其放在BAT脚本中：

perl -e "sleep 7"

该解决方案仅提供一秒钟的分辨率。

如果需要更高的分辨率，请使用CPAN中的Time :: HiRes模块。它提供了usleep()哪些睡眠时间（以微秒为单位）和nanosleep()哪些睡眠时间（以纳秒为单位）（两个函数都仅接受整数参数）。请参阅“堆栈溢出”问题。如何在Perl中睡眠一毫秒？有关更多详细信息。

我已经使用ActivePerl多年了。这很容易安装。

或以命令行Python为例，例如6秒半：

python -c "import time;time.sleep(6.5)"

ping的用法很好，只要您只想“稍等”即可。这是因为您依赖于下面的其他功能，例如您的网络正常工作以及127.0.0.1上没有任何应答的事实。;-)也许它不太可能失败，但并非不可能...

如果要确保正好在指定的时间等待，则应使用该sleep功能（该功能还具有不使用CPU电源或等待网络就绪的优势）。

查找已经制作好的可执行文件以进行睡眠是最方便的方法。只需将其放入Windows文件夹或标准路径的任何其他部分，它便始终可用。

否则，如果您具有编译环境，则可以轻松地自己制作一个。该Sleep功能在中可用kernel32.dll，因此您只需要使用该功能即可。:-)对于VB / VBA，请在源代码的开头声明以下内容以声明睡眠功能：

private Declare Sub Sleep Lib "kernel32" Alias "Sleep" (byval dwMilliseconds as Long)

对于C＃：

[DllImport("kernel32.dll")]
static extern void Sleep(uint dwMilliseconds);

您可以在睡眠功能（MSDN）中找到有关此功能（从Windows 2000开始可用）的更多信息。

在标准C中，sleep()包含在标准库中，并且在Microsoft的Visual Studio C中，该函数名为Sleep()，如果内存为我服务。;-)这两个参数以秒为单位，而不是前两个声明以毫秒为单位。

适用于Windows 2000之后的所有Windows版本的最佳解决方案是：

timeout numbersofseconds /nobreak > nul

pathping.exe可以睡少于一秒钟。

@echo off
setlocal EnableDelayedExpansion 
echo !TIME! & pathping localhost -n -q 1 -p %~1 2>&1 > nul & echo !TIME!

。

> sleep 10
17:01:33,57
17:01:33,60

> sleep 20
17:03:56,54
17:03:56,58

> sleep 50
17:04:30,80
17:04:30,87

> sleep 100
17:07:06,12
17:07:06,25

> sleep 200
17:07:08,42
17:07:08,64

> sleep 500
17:07:11,05
17:07:11,57

> sleep 800
17:07:18,98
17:07:19,81

> sleep 1000
17:07:22,61
17:07:23,62

> sleep 1500
17:07:27,55
17:07:29,06

我对此印象深刻：

http://www.computerhope.com/batch.htm#02

choice /n /c y /d y /t 5 > NUL

从技术上讲，您是在告诉choice命令仅接受y。它的默认值为y，在5秒钟内这样做，不绘制提示，并将它说的任何内容转储给NUL（例如Linux上的null终端）。

您还可以使用.vbs文件执行特定的超时：

下面的代码创建.vbs文件。将其放在您的rbatch代码顶部附近：

echo WScript.sleep WScript.Arguments(0) >"%cd%\sleeper.vbs"

然后，下面的代码打开.vbs并指定等待时间：

start /WAIT "" "%cd%\sleeper.vbs" "1000"

在上面的代码中，“ 1000”是要发送到.vbs文件的时间延迟值，以毫秒为单位，例如1000 ms = 1 s。您可以将这部分更改为任意长。

完成后，下面的代码将删除.vbs文件。将其放在批处理文件的末尾：

del /f /q "%cd%\sleeper.vbs"

这是所有代码，因此很容易复制：

echo WScript.sleep WScript.Arguments(0) >"%cd%\sleeper.vbs"
start /WAIT "" "%cd%\sleeper.vbs" "1000"
del /f /q "%cd%\sleeper.vbs"

在Windows Vista上，您具有TIMEOUT和SLEEP命令，但是要在Windows XP或Windows Server 2003上使用它们，则需要Windows Server 2003资源工具包。

在这里，您可以很好地了解其他睡眠方式（ping方法是最受欢迎的方法，因为它可以在每台Windows机器上使用），但是（至少）没有提到（至少）一种使用W32TM（时间服务）命令的睡眠方法：

w32tm /stripchart /computer:localhost /period:1 /dataonly /samples:N  >nul 2>&1

在此处应将N替换为要暂停的秒数。此外，它无需任何先决条件即可在每个Windows系统上运行。

也可以使用Typeperf：

typeperf "\System\Processor Queue Length" -si N -sc 1 >nul

使用mshta和javascript（可在一秒钟内用于睡眠）：

start "" /wait /min /realtime mshta "javascript:setTimeout(function(){close();},5000)"

这应该更加精确（等待一秒钟）-自编译可执行文件依赖于.net：

@if (@X)==(@Y) @end /* JScript comment
@echo off
setlocal
::del %~n0.exe /q /f
::
:: For precision better call this like
:: call waitMS 500
:: in order to skip compilation in case there's already built .exe
:: as without pointed extension first the .exe will be called due to the ordering in PATEXT variable
::
::
for /f "tokens=* delims=" %%v in ('dir /b /s /a:-d  /o:-n "%SystemRoot%\Microsoft.NET\Framework\*jsc.exe"') do (
   set "jsc=%%v"
)

if not exist "%~n0.exe" (
    "%jsc%" /nologo /w:0 /out:"%~n0.exe" "%~dpsfnx0"
)


%~n0.exe %*

endlocal & exit /b %errorlevel%


*/


import System;
import System.Threading;

var arguments:String[] = Environment.GetCommandLineArgs();
function printHelp(){
    Console.WriteLine(arguments[0]+" N");
    Console.WriteLine(" N - milliseconds to wait");
    Environment.Exit(0);    
}

if(arguments.length<2){
    printHelp();
}

try{
    var wait:Int32=Int32.Parse(arguments[1]);
    System.Threading.Thread.Sleep(wait);
}catch(err){
    Console.WriteLine('Invalid Number passed');
    Environment.Exit(1);
}

有多种方法可以在cmd / batch中完成“ sleep ”：

我最喜欢的一个：

TIMEOUT /NOBREAK 5 >NUL 2>NUL

这将使控制台停止5秒钟，没有任何输出。

最常被使用：

ping localhost -n 5 >NUL 2>NUL

这将尝试建立localhost5次连接。由于它是托管在您的计算机上的，因此它将始终可以访问该主机，因此，它每秒将尝试新的主机。该-n标志指示脚本将尝试连接多少次。在这种情况下为5，因此它将持续5秒。

最后一个的变体：

ping 1.1.1.1 -n 5 >nul

在此脚本中，与最后一个脚本进行比较存在一些差异。这不会尝试致电localhost。相反，它将尝试连接到1.1.1.1一个非常快速的网站。仅当您具有活动的Internet连接时，此操作才会持续5秒钟。否则，它将持续约15分钟才能完成操作。我不建议使用此方法。

ping 127.0.0.1 -n 5 >nul

这与示例2（使用最多）完全相同。另外，您还可以使用：

ping [::1] -n 5 >nul

而是使用IPv6的localhost版本。

有很多方法可以执行此操作。但是，对于Windows Vista和更高版本，我更喜欢方法1，对于较早版本的OS，我更喜欢最常用的方法（方法2）。

您可以通过将PAUSE消息放在标题栏中来实现幻想：

@ECHO off
SET TITLETEXT=Sleep
TITLE %TITLETEXT%
CALL :sleep 5
GOTO :END
:: Function Section
:sleep ARG
ECHO Pausing...
FOR /l %%a in (%~1,-1,1) DO (TITLE Script %TITLETEXT% -- time left^
 %%as&PING.exe -n 2 -w 1000 127.1>NUL)
EXIT /B 0
:: End of script
:END
pause
::this is EOF

这已在Windows XP SP3和Windows 7上进行了测试，并使用CScript。我采取了一些安全措施，以免出现del“”提示。（/q很危险）

等待一秒钟：

sleepOrDelayExecution 1000

等待500毫秒，然后在执行以下操作：

sleepOrDelayExecution 500 dir \ /s

sleepOrDelayExecution.bat：

@echo off
if "%1" == "" goto end
if NOT %1 GTR 0 goto end
setlocal
set sleepfn="%temp%\sleep%random%.vbs"
echo WScript.Sleep(%1) >%sleepfn%
if NOT %sleepfn% == "" if NOT EXIST %sleepfn% goto end
cscript %sleepfn% >nul
if NOT %sleepfn% == "" if EXIST %sleepfn% del %sleepfn%
for /f "usebackq tokens=1*" %%i in (`echo %*`) DO @ set params=%%j
%params%
:end

由于其他人建议使用第三方程序（Python，Perl，自定义应用程序等），因此，另一个可供选择的选择是Windows的GNU CoreUtils，网址为http://gnuwin32.sourceforge.net/packages/coreutils.htm。

2个部署选项：

1. 安装完整的软件包（将包括完整的CoreUtils，依赖项，文档等）。
2. 仅安装“ sleep.exe”二进制文件和必要的依赖项（使用depends.exe获取依赖项）。

部署CoreUtils的一个好处是，您还将获得许多其他有助于编写脚本的程序（Windows批处理还有很多不足之处）。