Java.lang.Thread的sleep()方法能使当前线程暂停运行一段时间(单位毫秒)。需要注意的是，sleep()方法的参数不能为负，否则会抛出IllegalArgumentException异常。
除此之外，还有另一个方法sleep(long millis, int nanos)，该方法可用于使当前线程暂停millis毫秒nanos纳秒。需要注意的是，参数nanos的取值范围为[0, 999999]。
下面的代码演示如何用Thread.sleep()方法令主线程暂停执行2秒。
ThreadSleep.java
package com.journaldev.threads;
public class ThreadSleep {
public static void main(String[] args) throws InterruptedException {
long start = System.currentTimeMillis();
Thread.sleep(2000);
System.out.println("Sleep time in ms = " + (System.currentTimeMillis()-start));
}
}
如果你运行上述程序，你会发现最后打印出来的结果会比2000略多一些，这取决于线程休眠是如何实现的，以及操作系统定义的线程调度机制。
线程休眠要点
1. 线程休眠总是暂停当前线程
2. 在被唤醒并开始执行前，线程休眠的实际时间取决于系统计时器和调度器。对比较清闲的系统来说，实际休眠的时间十分接近于指定的休眠时间，但对于繁忙的系统，两者之间的差距就较大。
3. 线程休眠并不会丢失当前线程已获取的任何监视器和锁。
4. 其他线程可以中断当前进程的休眠，但会抛出InterruptedException异常。
线程休眠的工作原理
Thread.sleep()与线程调度器交互，它将当前线程设置为等待一段时间的状态。一旦等待时间结束，线程状态就会被改为可运行(runnable)，并开始等待CPU来执行后续的任务。因此，当前线程的实际休眠时间取决于线程调度器，而线程调度器则是由操作系统来进行管理的。

附加程序(见最后)在执行时产生以下输出：
..........
with sleep time of 0ms
times= [1, 1, 1, 0, 1, 1, 0, 1, 1, 0]
average= 0.7
..........
with sleep time of 2000ms
times= [2, 2, 2, 2, 2, 1, 2, 2, 2, 2]
average= 1.9
在这两种情况下,执行完全相同的代码,即从程序开始时实例化的Random对象重复获取下一个值.首先执行的预热方法应该在实际测试开始之前触发任何类型的JIT otimization.
任何人都可以解释这种差异的原因吗？到目前为止,我每次都能在我的机器上重复这个结果,这是在带有java 7的多核Windows系统上执行的.
一个有趣的事情是,如果执行测试的顺序是相反的,也就是说,如果我们在没有延迟的循环之前运行具有延迟的循环,那么时序更相似(没有延迟循环实际上需要更长的时间) )：
..........
with sleep time of 2000ms
times= [2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
average= 2.0
..........
with sleep time of 0ms
times= [2, 3, 3, 2, 3, 3, 2, 3, 2, 3]
average= 2.6
尽管我可以告诉,在操作方法中没有创建任何对象,并且当通过分析器运行它时,似乎不会触发垃圾收集.一个疯狂的猜测是,某些值被缓存在处理器本地缓存中,当线程进入休眠状态时会被刷新,然后当线程唤醒时需要从主内存中检索该值,但这并不是那么快.然而,这并不能解释为什么颠倒订单会产生影响……
我最初观察到这种行为的现实情况(这促使我编写这个示例测试类)是XML解组,我注意到,在快速连续中一个接一个地重复编组同一个文档所产生的时间比执行相同的更好的时间但是在调用unmarshal(通过睡眠或手动产生的延迟)之间有延迟.
这是代码：
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class Tester
{
public static void main(String[] args) throws InterruptedException
{
warmUp(10000);
int numRepetitions = 10;
runOperationInALoop(numRepetitions, 0);
runOperationInALoop(numRepetitions, 2000);
}
private static void runOperationInALoop(int numRepetitions, int sleepTime) throws InterruptedException
{
List times = new ArrayList(numRepetitions);
long totalDuration = 0;
for(int i=0; i
{
Thread.sleep(sleepTime);
long before = System.currentTimeMillis();
someOperation();
long duration = System.currentTimeMillis() - before;
times.add(duration);
totalDuration = totalDuration + duration;
System.out.print(".");
}
System.out.println();
double averageTimePerOperation = totalDuration/(double)numRepetitions;
System.out.println("with sleep time of " + sleepTime + "ms");
System.out.println("  times= " + times);
System.out.println("  average= " + averageTimePerOperation);
}
private static void warmUp(int warmUpRepetitions)
{
for(int i=0; i
{
someOperation();
}
}
public static int someInt;
public static Random random = new Random(123456789L);
private static void someOperation()
{
for(int j=0; j<50000; j++)
{
someInt = ((int)random.nextInt()*10) + 1;
}
}
}

1、简介sleep
sleep方法属于Thread类中方法，是静态方法，只能控制当在前运行的线程。表示让一个线程进入睡眠状态，等待一定的时间之后，自动醒来进入到可运行状态，不会马上进入运行状态，因为线程调度机制恢复线程的运行也需要时间，一个线程对象调用了sleep方法之后，并不会释放他所持有的所有对象锁，所以也就不会影响其他进程对象的运行。但在sleep的过程中过程中有可能被其他对象调用它的interrupt(),产生InterruptedException异常，如果你的程序不捕获这个异常，线程就会异常终止，进入TERMINATED状态，如果你的程序捕获了这个异常，那么程序就会继续执行catch语句块(可能还有 finally语句块)以及以后的代码。
sleep(long millis)
在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)
sleep(long millis, int nanos)
在指定的毫秒数加指定的纳秒数内让当前正在执行的线程休眠(暂停执行)
2、运用场景
执行其它任务的时候,想要每间隔多少秒执行一次给定任务,sleep就会用上。
3、代码事例
package com.xxx.util;
import java.util.Date;
/**
* Created with IntelliJ IDEA.
* Date: 15-3-27
* Time: 上午8:51
* To change this template use File | Settings | File Templates.
*/
public class ThreadSleep implements Runnable {
@Override
public void run() {
for(int i=0;i<15;i++){
System.out.printf("startTime：%s\n",new Date());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
//线程中断在此处理
System.out.println("The thread has bean interrupted");
}
}
}
}main类
package com.xxx.util;
import java.util.concurrent.TimeUnit;
/**
* Created with IntelliJ IDEA.
* Date: 15-3-27
* Time: 上午8:57
* To change this template use File | Settings | File Templates.
*/
public class ThreadSleepMain {
public static void main(String[] args){
ThreadSleep threadSleep = new ThreadSleep();
Thread thread = new Thread(threadSleep);
thread.start();
try {
TimeUnit.SECONDS.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
thread.interrupt();
System.out.printf("%s：已调用interrupt()方法\n",thread.getName());
System.out.printf("%s：主线程还在运行\n",Thread.currentThread().getName());
}
}运行结果：
4、结论
当调用sleep()方法后，线程会释放CPU并且不再继续执行任务，知道休眠时间过了才进入可运行状态。如果休眠中线程被中断，该方法会立即抛出InterruptedException异常，可进行异常处理，main线程还是继续运行不受影响。

在几个月前上线的一个采集项目，构架是基于java + selenium + chromedriver + chrome实现的采集。至于为哈不直接用jsoup或httpclient实现采集功能，是因为很多被采集页面都是通过js来渲染内容的，所以必须用webdriver+chrome来模拟真正的浏览器访问来采集。
每隔一段时间就会出采集失败问题，出现的时间没有规律，可能两天出现一次，可能一星期出现一次，可能一个月出现一次....
用linux top命令来查看服务器，会发现很多的chromedriver和chrome的进程
用ps命令查看服务器
ps -aux | grep chrome
存在状态为Sl和Z的休眠进程和僵尸进程，启动时间都不是当天，根据系统本身业务逻辑，进程不会存在运行那么长时间的情况。而java进程则全部都能正常关闭，但java进程启动的chromedriver和chrome进程不一定能同时关闭，目前出现这种问题的原因未找到。
最初想用命令把卡死的进程查出来批量杀掉
ps -A -o stat,ppid,pid,cmd | grep -e '^[Zz]' | awk '{print $2}' | xargs kill -9   //杀死僵尸进程
结果发现只能查杀Z状态的僵尸进程，Sl状态的进程，一部分是正常的，一部分是需要杀死的(启动时间为Nov07,Nov06的进程需要杀掉)，至于哪些需要杀死，需要通过人工判断启动时间来确定是否需要杀掉进程。
之前一直忙时，都是先通过ps命令把chromedriver和chrome相关进程查询出来，然后通过人工判断进程是否属于休眠状态，再手工kill杀掉进程。
最近有空了，本着能程序解决，就绝不要人工维护，把之前的手工杀休眠进程操作程序化。一开始想直接通过java的Runtime.getRuntime().exec()代码调用linux命令操作的，不过在java常用类库中(https://www.21doc.net/java/awesomejava#processes)，找到zt-exec库，可以简化命令行调用操作。
程序化的代替人工维护实现定时清理休眠进程代码如下：
import org.apache.log4j.Logger;
import org.apache.log4j.RollingFileAppender;
import org.zeroturnaround.exec.ProcessExecutor;
import org.zeroturnaround.exec.stream.LogOutputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class ProcessKill {
private static Logger log = Logger.getLogger(ProcessKill.class);
public ProcessKill(){
}
public void run(){
try{
List> list = new ArrayList>();
//          先通过ps aux | grep chrome命令，获取所有包含chrome文本内容的进程
new ProcessExecutor().command("/bin/sh","-c","ps aux | grep chrome")
.redirectOutput(new LogOutputStream() {
protected void processLine(String line) {
log.info("line========" + line);
List lines = split(line.trim());
//                          判断进程启动时间，确定是否为执行超时休眠的进程
String time = lines.get(8);
String format = "[0-5][0-9]:[0-5][0-9]";
Pattern p = Pattern.compile(format);
Matcher m = p.matcher(time);
boolean result = m.find();
if(result == true) {
log.info("time ========" + time + " " + result);
}
else{
log.info("time xxxxxxxx" + time + " " + result);
list.add(lines);
}
}
})
.execute();
log.info("list========size:" + list.size());
list.forEach(l->{
log.info("list line========" + l);
});
for(int i = 0; i < list.size(); i++){
List strs = list.get(i);
try{
String pid = strs.get(1);
String stat = strs.get(7);
String time = strs.get(8);
String cmd = strs.get(10);
log.info("pid========" + pid + ", " + stat + ", " + time + ", " + cmd);
// 通过命令“kill -9 pid”杀掉进程
String output = new ProcessExecutor().command("/bin/sh","-c","kill -9 " + pid)
.readOutput(true).execute()
.outputUTF8();
log.info("kill========" + pid + ", " + output);
}
catch(Exception ex){
ex.printStackTrace();
}
}
}
catch(Exception e){
e.printStackTrace();
}
}
public List split(String s){
//      ps aux | grep chrome 命令返回字段： USER,PID ,%CPU,%MEM,VSZ, RSS,TTY,STAT,START,TIME,COMMAND
List list = new ArrayList();
int blankCount = 0;
StringBuffer sff = new StringBuffer();
for(int i = 0; i < s.length(); i++){
char c = s.charAt(i);
if(list.size() < 10){
if(c != ' '){
sff.append(c);
blankCount = 0;
}
else if(c == ' '){
blankCount++;
}
if(blankCount == 1){
list.add(sff.toString());
sff = new StringBuffer();
}
}
else{
sff.append(c);
}
}
if(sff.length() > 0){
list.add(sff.toString());
}
return list;
}
public static void setLogFile(String name){
Logger rootLogger = Logger.getRootLogger();
Enumeration en = rootLogger.getAllAppenders();
while (en.hasMoreElements()){
Object obj = en.nextElement();
if(obj instanceof RollingFileAppender){
RollingFileAppender file = (RollingFileAppender)obj;
file.setFile(name + ".log");
file.activateOptions();
}
}
}
public static void main(String[] args){
setLogFile("log/" + ProcessKill.class.getSimpleName());
new ProcessKill().run();
}
}
文末记录下ps和grep命令用法。
ps 显示瞬间进程的状态
参数：
-A ：所有的进程均显示出来，与 -e 具有同样的效用；
-a ： 显示现行终端机下的所有进程，包括其他用户的进程；
-u ：以用户为主的进程状态 ；
x ：通常与 a 这个参数一起使用，可列出较完整信息。
ps aux
USER：该进程属于那个使用者账号。
PID ：该进程的进程ID号。
%CPU：该进程使用掉的 CPU 资源百分比；
%MEM：该进程所占用的物理内存百分比；
VSZ ：该进程使用掉的虚拟内存量 (Kbytes)
RSS ：该进程占用的固定的内存量 (Kbytes)
TTY ：该进程是在那个终端机上面运作，若与终端机无关，则显示。另外， tty1-tty6 是本机上面的登入者程序，若为 pts/0 等等的，则表示为由网络连接进主机的程序。
STAT：该程序目前的状态，主要的状态有：
R ：该程序目前正在运作，或者是可被运作；
S ：该程序目前正在睡眠当中，但可被某些讯号(signal) 唤醒。
T ：该程序目前正在侦测或者是停止了；
Z ：该程序应该已经终止，但是其父程序却无法正常的终止他，造成 zombie (疆尸) 程序的状态
START：该进程被触发启动的时间；
TIME ：该进程实际使用 CPU 运作的时间。
COMMAND：该程序的实际指令。
ps -ef |grep java
UID     ：程序被该 UID 所拥有
PID     ：就是这个程序的 ID
PPID    ：则是其上级父程序的ID
C       ：CPU使用的资源百分比
STIME   ：系统启动时间
TTY     ：登入者的终端机位置
TIME    ：使用掉的CPU时间。
CMD     ：所下达的是什么指令
grep命令的常用格式为：grep  [选项]  ”模式“  [文件]
常用选项：
-E ：开启扩展(Extend)的正则表达式。
-i ：忽略大小写(ignore case)。
-v ：反过来(invert)，只打印没有匹配的，而匹配的反而不打印。
-n ：显示行号
-w ：被匹配的文本只能是单词，而不能是单词中的某一部分，如文本中有liker，而我搜寻的只是like，就可以使用-w选项来避免匹配liker
-c ：显示总共有多少行被匹配到了，而不是显示被匹配到的内容，注意如果同时使用-cv选项是显示有多少行没有被匹配到。
-o ：只显示被模式匹配到的字符串。
--color :将匹配到的内容以颜色高亮显示。
-A  n：显示匹配到的字符串所在的行及其后n行，after
-B  n：显示匹配到的字符串所在的行及其前n行，before
-C  n：显示匹配到的字符串所在的行及其前后各n行，context
查看系统状态下的僵尸进程：
ps -ef | grep defunct  后面尖括号里是defunct的都是僵尸进程。
ps aux | grep -w 'Z' 其中状态为Z的代表僵尸进程。