Java（74）
TimeUnit是java.util.concurrent包下面的一个类，TimeUnit提供了可读性更好的线程暂停操作，通常用来替换Thread.sleep()，在很长一段时间里Thread的sleep()方法作为暂停线程的标准方式，几乎所有Java程序员都熟悉它，事实上sleep方法本身也很常用而且出现在很多面试中。如果你已经使用过Thread.sleep()，当然我确信你这样做过，那么你一定熟知它是一个静态方法，暂停线程时它不会释放锁，该方法会抛出InterrupttedException异常（如果有线程中断了当前线程）。但是我们很多人并没有注意的一个潜在的问题就是它的可读性。Thread.sleep()是一个重载方法，可以接收长整型毫秒和长整型的纳秒参数，这样对程序员造成的一个问题就是很难知道到底当前线程是睡眠了多少秒、分、小时或者天。看看下面这个Thread.sleep()方法：
Thread.sleep（2400000）
粗略一看，你能计算出当前线程是等待多长时间吗？可能有些人可以，但是对于大多数程序员来说这种写法的可读性还是很差的，你需要把毫秒转换成秒和分，让我们来看看另外一个例子，这个例子比前面那个例子可读性稍微好一点：
Thread.sleep(4*60*1000);
这比前面那个例子已经好多了，但是仍然不是最好的，你注意到睡眠时间用毫秒，不容易猜出当前线程将等待4分钟。TimeUnit类解决了这个问题，通过指定DAYS、HOURS、MINUTES,SECONDS、MILLISECONDS和NANOSECONDS。java.utils.concurrent .TimeUnit 是Java枚举应用场景中最好的例子之一，所有TimeUnit都是枚举实例，让我们来看看线程睡眠4分钟用TimeUnit是如何使用的。
TimeUnit.MINUTES.sleep(4);
// sleeping for 4 minutes
类似你可以采用秒、分、小时级别来暂停当前线程。你可以看到这比Thread的sleep方法的可读的好多了。记住TimeUnit.sleep()内部调用的Thread.sleep()也会抛出InterruptException。你也可以查看JDK源代码去验证一下。下面是一个简单例子，它展示如果使用TimeUnit.sleep()方法。
* Java program to demonstrate how to use TimeUnit.sleep() method in Java.
* TimeUnit is a new way of introducing pause in Java program.
public class TimeUnitTest {
public static void main(String args[]) throws InterruptedException {
System.out.println("Sleeping for 4 minutes using Thread.sleep()");
Thread.sleep(4 * 60 * 1000);
System.out.println("Sleeping for 4 minutes using TimeUnit sleep()");
TimeUnit.SECONDS.sleep(4);
TimeUnit.MINUTES.sleep(4);
TimeUnit.HOURS.sleep(1);
TimeUnit.DAYS.sleep(1);
除了sleep的功能外，TimeUnit还提供了便捷方法用于把时间转换成不同单位，例如，如果你想把秒转换成毫秒，你可以使用下面代码：
TimeUnit.SECONDS.toMillis(44)
它将返回44,000
目前我们讨论使用TimeUnit的好处是提高了可读性，但是有时候觉得其他方法更好，因为Thread.sleep()伴随java很早就出现了，几乎所有程序员都知道Thread.sleep()，都知道是将当前线程暂停，而对TimeUnit并不太熟悉。两个原因：一是对比起Thread.sleep()，TimeUnit不是很常用，第二是在它不在Thread类中，就像wait和notify同样不是在Thread中，反正这些需要一段时间才能被采用,并成为一个标准的方式。
总结来说在你想用Thread.sleep()方法的地方你最好使用TimeUnit.sleep()方法来代替。它不尽可以提高代码的可读性而且能更加熟悉java.util.concurrent包，因为TimeUnit在并发编程中也是一个关键API。
原文地址：
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：54109次
积分：1938
积分：1938
排名：第14161名
原创：107篇
转载：32篇
译文：22篇
评论：21条
IT图书创作中，博客暂时暂停更新，请谅解~
请勿发站内信，邮件联系我~
联系方式：
阅读：2748
文章：12篇
阅读：5687
阅读：4234
文章：11篇
阅读：4659
文章：12篇
阅读：98031）休眠 sleep
& & & & & &sleep()可以使任务中止执行一段时间（这段时间是指定的）。但是要注意的是对sleep（）的调用可以抛出InterruptedException异常，并且这个异常在run（）方法中就得捕获，进行处理，这是因为异常不能跨线程传播，所以我们必须在本地处理所有任务内部产生的异常。
& & & &在旧版本中，sleep的用法是这样的，Thread.sleep(1000);
& & & & 但是在Java SE5 之后引入了更加显示的sleep()版本，作为TimeUnit类的一部分。 TimeUtil.MILLISECONDS.sleep(100);
& &注意下面这个程序：
Class Sleeper extends Thread {
private int sleepT
public Sleeper(String name,int sleepTime) {
super(name);
this.sleepTime = sleepT
public void run() {
sleep(sleepTime);
} catch(InterruptedException e) {
System.out.println(this.isInterrupted());//竟然是false,当一个线程在该线程上调用interrrupt()时，就会给该线程设定一个标记。表明这个线程已经被中断，然而，在当异常比捕获时，会清楚这个标记。所以在catch子句中，这个标记是false.
& & & &这个比较简单，就不多说了，记住的是JDK有10个优先级，但是与多数操作系统都不能映射的很好。因此，在我们平时的操作中，一般情况下，只使用MAX_PRIORITY、NORM_PRIORITY和MIN_PRIORITY三种级别。
3）让步 yield
& & & 当调用yield()时，即在建议具有相同优先级的其他线程可以运行了，但是注意的是，仅仅是建议，没有任何机制保证你这个建议会被采纳。一般情况下，对于任何重要的控制或者调用应用时，都不能依赖于yield()。这个方法经常被误用。
4）后台线程
& & & 所谓后台线程（daemon），是指在程序运行的时候在后台提供一种通用服务的线程，并且这种线程并不属于程序中不可或缺的部分，当所有的非后台线程结束时，程序也就终止了，同时会杀死进程中所有的后台线程。
& & &必须在线程启动之前调用setDaemon()方法，才能把它设置为后台线程。-
& & &如果一个线程是一个后台线程那么它创建的任何线程都将自动设置为后台线程。
& & & 我们应该意识到后台线程可以在没有执行finally子句的情况下，终止其run()方法，看下面这个例子
import java.util.concurrent.TimeU
public class ADaemonTest {
public class ADaemon implements Runnable {
public void run() {
System.out.println("Starting Daemon");
TimeUnit.MILLISECONDS.sleep(100);
} catch (InterruptedException e) {
System.out.println("exiting via InterruptedException");
} finally {
System.out.println("This should always run?");
static void main(String[] args) {
ADaemonTest test = new ADaemonTest();
Thread t = new Thread(test.new ADaemon());
t.setDaemon(true);
t.start();
上面的执行结果是：
Starting Daemon
如果我们把
t.setDaemon(true);
& & 注释掉，则运行结果为
Starting Daemon
This should always run?
如果我们把
TimeUnit.MILLISECONDS.sleep(100); 改为
TimeUnit.MILLISECONDS.sleep(1);
则运行结果为
Starting Daemon
This should always run?
上面的三种执行情况及其记过说明两点：
& & 1）非后台线程是会执行finally的
& & 2. 后台线程可能会执行，也有可能不会执行finally子句，这说明finally子句不一定就会执行。
& & &一个线程可以再其他线程上调用join()方法，其效果是等待一段时间直到第二个线程结束，才继续执行。
& & &也可以再调用join()时带上一个超时参数（单位可以是毫秒，或者秒等），这样如果目标线程在这段时间到期时还没有结束，join()方法总能返回。
& &PS:我们可以在一个普通的方法中创建一个线程。当我们准备好运行线程时，就可以调用这个方法。而在线程开始之后（注意是start()之后，而非run（）方法执行结束），该方法将返回。
阅读(...) 评论()11482人阅读
j2se（35）
sleep：在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。该线程不丢失任何监视器的所属权。
通过调用sleep使任务进入休眠状态，在这种情况下，任务在指定的时间内不会运行。
调用sleep的时候锁并没有被释放。
Java SE5引入了更加显示的sleep()版本作为TimeUnit类的一部分，这个方法允许你指定sleep()延迟的时间单元，因此可以提供更好的可阅读性。TimeUnit还可以被用来执行转换，就想稍后你会在本书中看到的那样。
wait：调用wait使线程挂起，知道线程得到了notify或notifyAll消息，线程才会进入就绪状态。
使你可以等待某个条件发生变化，而改变这个条件超出了当前方法的控制能力。
线程的执行被挂起，对象上的锁被释放。意味着另一个任务可以获得这个锁。因此在改对象中的其他synchronized方法可以在wait期间被调用。
就意味着生命“我已经刚刚做完能做的所有事情，因此我要在这里等待，但是我希望其他synchronized操作在条件适合的情况下才能够执行”
yield：如果知道已经完成了在run()方法的循环的一次迭代过程中所需要的工作，就可以给线程调度一个机制暗示：我的工作已经做的差不多了，可以让给别的线程使用CPU了。通过调用yield()来实现。
当调用yield时，你也是在建议具有相同优先级的其他线程可以运行。
对于任何重要的控制或在调整应用时，都不恩那个依赖于yield。实际上，yield经常被误用。
（yield并不意味着退出和暂停，只是，告诉线程调度如果有人需要，可以先拿去，我过会再执行，没人需要，我继续执行）
调用yield的时候锁并没有被释放。
interrupt：中断线程。
Thread.interrupt()或者新类库里面通过Executor的submit()来获得Future&?&返回值，这个Future提供cancel()以停止这个线程。
Thread类包含interrupt()方法，因此你可以终于被阻塞的任务，这个方法将设置线程的中断状态。如果一个线程已经被阻塞，或者视图执行一个阻塞操作，那么设置这个线程的终端状态将抛出InterruptedException。当抛出该异常或者该任何调用Thread.interrupted()时，中断状态将复位。
你在Executor上调用shutdownNow()，那么它将发送一个interrupt()调用给他启动的所有线程。
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：572898次
积分：7645
积分：7645
排名：第1783名
原创：182篇
转载：60篇
评论：114条
(1)(2)(1)(3)(4)(6)(5)(3)(7)(1)(5)(2)(4)(21)(11)(13)(7)(23)(26)(28)(17)(2)(2)(11)(2)(1)(3)(4)(1)(1)(2)(1)(2)(4)(2)(1)(13)9970人阅读
我们可能经常会用到 Thread.Sleep 函数来使线程挂起一段时间。那么你有没有正确的理解这个函数的用法呢？思考下面这两个问题：
假设现在是
12:00:00.000，如果我调用一下 Thread.Sleep(1000) ，在
12:00:01.000 的时候，这个线程会 不会被唤醒？
某人的代码中用了一句看似莫明其妙的话：Thread.Sleep(0) 。既然是 Sleep 0 毫秒，那么他跟去掉这句代码相比，有啥区别么？
我们先回顾一下操作系统原理。
操作系统中，CPU竞争有很多种策略。Unix系统使用的是时间片算法，而Windows则属于抢占式的。
在时间片算法中，所有的进程排成一个队列。操作系统按照他们的顺序，给每个进程分配一段时间，即该进程允许运行的时间。如果在 时间片结束时进程还在运行，则CPU将被剥夺并分配给另一个进程。如果进程在时间片结束前阻塞或结束，则CPU当即进行切换。调度程 序所要做的就是维护一张就绪进程列表，，当进程用完它的时间片后，它被移到队列的末尾。
所谓抢占式操作系统，就是说如果一个进程得到了 CPU 时间，除非它自己放弃使用 CPU ，否则将完全霸占 CPU 。因此可以看出，在抢 占式操作系统中，操作系统假设所有的进程都是“人品很好”的，会主动退出 CPU 。
在抢占式操作系统中，假设有若干进程，操作系统会根据他们的优先级、饥饿时间（已经多长时间没有使用过 CPU 了），给他们算出一 个总的优先级来。操作系统就会把 CPU 交给总优先级最高的这个进程。当进程执行完毕或者自己主动挂起后，操作系统就会重新计算一 次所有进程的总优先级，然后再挑一个优先级最高的把 CPU 控制权交给他。
我们用分蛋糕的场景来描述这两种算法。假设有源源不断的蛋糕（源源不断的时间），一副刀叉（一个CPU），10个等待吃蛋糕的人（10 个进程）。
如果是 Unix操作系统来负责分蛋糕，那么他会这样定规矩：每个人上来吃 1 分钟，时间到了换下一个。最后一个人吃完了就再从头开始。于是，不管这10个人是不是优先级不同、饥饿程度不同、饭量不同，每个人上来的时候都可以吃 1 分钟。当然，如果有人本来不太饿，或者饭量小，吃了30秒钟之后就吃饱了，那么他可以跟操作系统说：我已经吃饱了（挂起）。于是操作系统就会让下一个人接着来。
如果是 Windows 操作系统来负责分蛋糕的，那么场面就很有意思了。他会这样定规矩：我会根据你们的优先级、饥饿程度去给你们每个人计算一个优先级。优先级最高的那个人，可以上来吃蛋糕——吃到你不想吃为止。等这个人吃完了，我再重新根据优先级、饥饿程度来计算每个人的优先级，然后再分给优先级最高的那个人。
这样看来，这个场面就有意思了——可能有些人是PPMM，因此具有高优先级，于是她就可以经常来吃蛋糕。可能另外一个人是个丑男，而去很ws，所以优先级特别低，于是好半天了才轮到他一次（因为随着时间的推移，他会越来越饥饿，因此算出来的总优先级就会越来越高，因此总有一天会轮到他的）。而且，如果一不小心让一个大胖子得到了刀叉，因为他饭量大，可能他会霸占着蛋糕连续吃很久很久，导致旁边的人在那里咽口水。。。
而且，还可能会有这种情况出现：操作系统现在计算出来的结果，5号PPMM总优先级最高，而且高出别人一大截。因此就叫5号来吃蛋糕。5号吃了一小会儿，觉得没那么饿了，于是说“我不吃了”（挂起）。因此操作系统就会重新计算所有人的优先级。因为5号刚刚吃过，因此她的饥饿程度变小了，于是总优先级变小了；而其他人因为多等了一会儿，饥饿程度都变大了，所以总优先级也变大了。不过这时候仍然有可能5号的优先级比别的都高，只不过现在只比其他的高一点点——但她仍然是总优先级最高的啊。因此操作系统就会说：5号mm上来吃蛋糕……（5号mm心里郁闷，这不刚吃过嘛……人家要减肥……谁叫你长那么漂亮，获得了那么高的优先级）。
那么，Thread.Sleep 函数是干吗的呢？还用刚才的分蛋糕的场景来描述。上面的场景里面，5号MM在吃了一次蛋糕之后，觉得已经有8分饱了，她觉得在未来的半个小时之内都不想再来吃蛋糕了，那么她就会跟操作系统说：在未来的半个小时之内不要再叫我上来吃蛋糕了。这样，操作系统在随后的半个小时里面重新计算所有人总优先级的时候，就会忽略5号mm。Sleep函数就是干这事的，他告诉操作系统“在未来的多少毫秒内我不参与CPU竞争”。
看完了 Thread.Sleep 的作用，我们再来想想文章开头的两个问题。
对于第一个问题，答案是：不一定。因为你只是告诉操作系统：在未来的1000毫秒内我不想再参与到CPU竞争。那么1000毫秒过去之后，这时候也许另外一个线程正在使用CPU，那么这时候操作系统是不会重新分配CPU的，直到那个线程挂起或结束；况且，即使这个时候恰巧轮到操作系统进行CPU 分配，那么当前线程也不一定就是总优先级最高的那个，CPU还是可能被其他线程抢占去。
与此相似的，Thread有个Resume函数，是用来唤醒挂起的线程的。好像上面所说的一样，这个函数只是“告诉操作系统我从现在起开始参与CPU竞争了”，这个函数的调用并不能马上使得这个线程获得CPU控制权。
对于第二个问题，答案是：有，而且区别很明显。假设我们刚才的分蛋糕场景里面，有另外一个PPMM 7号，她的优先级也非常非常高（因为非常非常漂亮），所以操作系统总是会叫道她来吃蛋糕。而且，7号也非常喜欢吃蛋糕，而且饭量也很大。不过，7号人品很好，她很善良，她没吃几口就会想：如果现在有别人比我更需要吃蛋糕，那么我就让给他。因此，她可以每吃几口就跟操作系统说：我们来重新计算一下所有人的总优先级吧。不过，操作系统不接受这个建议——因为操作系统不提供这个接口。于是7号mm就换了个说法：“在未来的0毫秒之内不要再叫我上来吃蛋糕了”。这个指令操作系统是接受的，于是此时操作系统就会重新计算大家的总优先级——注意这个时候是连7号一起计算的，因为“0毫秒已经过去了”嘛。因此如果没有比7号更需要吃蛋糕的人出现，那么下一次7号还是会被叫上来吃蛋糕。
因此，Thread.Sleep(0)的作用，就是“触发操作系统立刻重新进行一次CPU竞争”。竞争的结果也许是当前线程仍然获得CPU控制权，也许会换成别的线程获得CPU控制权。这也是我们在大循环里面经常会写一句Thread.Sleep(0) ，因为这样就给了其他线程比如Paint线程获得CPU控制权的权力，这样界面就不会假死在那里。
另外，虽然上面提到说“除非它自己放弃使用 CPU ，否则将完全霸占 CPU”，但这个行为仍然是受到制约的——操作系统会监控你霸占CPU的情况，如果发现某个线程长时间霸占CPU，会强制使这个线程挂起，因此在实际上不会出现“一个线程一直霸占着 CPU 不放”的情况。至于我们的大循环造成程序假死，并不是因为这个线程一直在霸占着CPU。实际上在这段时间操作系统已经进行过多次CPU竞争了，只不过其他线程在获得CPU控制权之后很短时间内马上就退出了，于是就又轮到了这个线程继续执行循环，于是就又用了很久才被操作系统强制挂起。。。因此反应到界面上，看起来就好像这个线程一直在霸占着CPU一样。
末了再说明一下，文中线程、进程有点混乱，其实在Windows原理层面，CPU竞争都是线程级的，本文中把这里的进程、线程看成同一个东西就好了。
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：97369次
积分：1465
积分：1465
排名：第19569名
原创：45篇
评论：46条
(1)(1)(1)(6)(2)(1)(2)(1)(1)(1)(4)(3)(2)(4)(3)(6)(10)java（21）
LiftOff类实现了Runnable。import java.util.concurrent.TimeU
public class LiftOff implements Runnable {
protected int countDown = 10;
private static int taskCount = 0;
// define with &final& here that thread
private final int id = taskCount++;
public LiftOff(int countDown) {
this.countDown = countD
public LiftOff() {
public void run() {
while (countDown-- & 0) {
System.out.println(status());
Thread.yield();
TimeUnit.MILLISECONDS.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
public String status() {
return &#& + id + &(& + (countDown & 0 ? countDown : &Liftoff!&) + &),&;
主方法的类
import java.util.concurrent.ExecutorS
import java.util.concurrent.E
public class MailThread {
* @param args
public static void main(String[] args) {
// LiftOff lauch =new LiftOff();
// lauch.run();
for(int i =0 ;i&5;i++)
new Thread(new LiftOff()).start();
System.out.println(&waiting for LiftOff&);
ExecutorService exec = Executors.newCachedThreadPool();
ExecutorService exec = Executors.newFixedThreadPool(5);
ExecutorService exec = Executors.newSingleThreadExecutor();
for (int i = 0; i & 5; i++)
exec.execute(new LiftOff());
exec.shutdown();
线程中使用sleep和yield 产生了两种不一样的效果
使用sleep打印结果如下
waiting for LiftOff
waiting for LiftOff
waiting for LiftOff
waiting for LiftOff
waiting for LiftOff
#3(Liftoff!),
#2(Liftoff!),
#0(Liftoff!),
#1(Liftoff!),
#4(Liftoff!),
而使用yield 产生的结果如下
waiting for LiftOff
waiting for LiftOff
waiting for LiftOff
waiting for LiftOff
waiting for LiftOff
#0(Liftoff!),
#2(Liftoff!),
#4(Liftoff!),
#1(Liftoff!),
#3(Liftoff!),
1)&&&& sleep()使当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会执行；yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。
2)&&&& sleep()可使优先级低的线程得到执行的机会，当然也可以让同优先级和高优先级的线程有执行的机会；yield()只能使同优先级的线程有执行的机会。
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：100049次
积分：1479
积分：1479
排名：第19374名
原创：37篇
转载：28篇
评论：15条
(1)(1)(7)(3)(2)(4)(1)(1)(7)(14)(10)(7)(12)}