多线程——休眠(sleep)

先抛出一问题？

都说sleep与yield有哪些哪些的区别，那我问：

sleep(0)与yield()有什么区别呢？

相关的说明晚上发布，白天估计没时间写，工作要紧。

本来晚上来发布的，关键时候，电脑没带回来，哈哈，明天一定补上。

其实后面几点

sleep,yield,join,priority与daemon都比较简单，用几个例子说明一下就可以。打算一次性把例子全放上，再分析一下这些方法的作用，基本上就OK了。

 

只有到线程池才又是一重点。

 

更新开始:

 

先来回答上面的问题：

两者的区别在于，一个调用的是本地的native void sleep(millis)方法，一个是调用的是本地的native void yield()方法。

由于具体的代码看不到：

只能功能分析：

因为sleep方法调用后，不会释放锁，只是暂停执行而已；与yield()方法调用后是一样的。

别的功能基本上是一样的。所以本地方法中可能在sleep(millis)中系统计算时间，当millis到0时，再调用与yield一样的处理方式。

yield()方法不会释放锁，这点在API中没有说明，不过可以通过下面的例子进行测试：

package thread;

import java.util.concurrent.locks.ReentrantLock;

public class YieldSleepThread {
	public static void main(String[] args) {
		Long t_start = System.currentTimeMillis();

		User_lock u = new User_lock("张三", 0);
		Thread_lock t1 = new Thread_lock("线程A", u, 20);
		Thread_lock t2 = new Thread_lock("线程B", u, -30);
		Thread_lock t3 = new Thread_lock("线程C", u, -40);
		Thread_lock t4 = new Thread_lock("线程d", u, -50);
		Thread_lock t5 = new Thread_lock("线程e", u, -60);
		Thread_lock t6 = new Thread_lock("线程f", u, -70);
		Thread_lock t7 = new Thread_lock("线程g", u, -80);

		t1.start();
		t2.start();
		t3.start();
		t4.start();
		t5.start();
		t6.start();
		t7.start();

		/**
		 * 以下代码用于计算时间，当然，它本身的运行也会需要一点点时间，但与分析运行效率无影响
		 */
		boolean flag = true;
		while (flag) {
			if (Thread_lock.activeCount() == 1) {
				Long t_end = System.currentTimeMillis();
				System.out.println("当前时间：" + (t_end - t_start));
				flag = false;
			}
		}
	}
}

class Thread_lock extends Thread {
	private User_lock u;
	private int y = 0;

	Thread_lock(String name, User_lock u, int y) {
		super(name); // 线程的名称
		this.u = u;
		this.y = y;
	}

	public void run() {
		u.oper(y);
	}
}

class User_lock {
	private String code;
	private Integer cash;

	User_lock(String code, int cash) {
		this.code = code;
		this.cash = cash;
	}

	public String getCode() {
		return code;
	}

	public void setCode(String code) {
		this.code = code;
	}

	/**
	 * 业务方法
	 * 
	 * @param x
	 *            添加x万元
	 */
	public synchronized void oper(int x) {
//		try{
			System.out.println("Thread.currentThread().getName()"+Thread.currentThread().getName());
//			Thread.sleep(0);// 作用：增加运行时间
			for(long i=0;i<9999999;i++);
			Thread.yield();

			this.cash += x;
			System.out.println(Thread.currentThread().getName() + "  运行结束1，增加“"
					+ x + "”，当前用户信息：" + toString());
//		} catch (InterruptedException e) {
//			e.printStackTrace();
//		} 
	}

	@Override
	public String toString() {
		return "User{" + "code='" + code + '\'' + ", cash=" + cash + '}';
	}
}

 

  运行结果：

 

Thread.currentThread().getName()线程A
线程A 运行结束1，增加“20”，当前用户信息：User{code='张三', cash=20}
Thread.currentThread().getName()线程d
线程d 运行结束1，增加“-50”，当前用户信息：User{code='张三', cash=-30}
Thread.currentThread().getName()线程C
线程C 运行结束1，增加“-40”，当前用户信息：User{code='张三', cash=-70}
Thread.currentThread().getName()线程e
线程e 运行结束1，增加“-60”，当前用户信息：User{code='张三', cash=-130}
Thread.currentThread().getName()线程f
线程f 运行结束1，增加“-70”，当前用户信息：User{code='张三', cash=-200}
Thread.currentThread().getName()线程B
线程B 运行结束1，增加“-30”，当前用户信息：User{code='张三', cash=-230}
Thread.currentThread().getName()线程g
线程g 运行结束1，增加“-80”，当前用户信息：User{code='张三', cash=-310}
当前时间：547 

很明显的一点，就是我的机子比较慢，应该在200左右的比较正常。

 

从上面的例子可以看到，不会释放锁；可以把上例子中的synchronized关键字去掉，试试，输出不会是A->A的。

 

还是回到sleep方法上来。

sleep(long millis, int nanos)或sleep(long millis)

其实nanos这个参数没多大用可以看这句：

if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
     millis++;
 }

 

所以，加个50000以下的，系统根本不算。哎！这东西就是骗人用的。

 

再说一下，因为sleep()方法让当年线程暂停执行，那么别的线程都可能能获取CPU，这也就为相对于，线程优先级比较低的也可能获取。（sleep(0)就先不说了，还是用yield()代替吧。）而yield()方法只是停下，接着去抢CPU，所以优先级低的，还是很难与高的相抢。

 

还有一点要说明的是sleep()会抛异常？

 

什么时候会出现这种情况呢？比如还在sleep的过程中，你突然想interrupte一下，是的，这个时候就要也异常了，不过这种异常没关系，你只要过滤一下就OK了，但是记住，如果不加，就是报错了。（现在都用IDE写代码，这种问题会自报。）

 

先到这里了。

 

 

Java多线程及线程池专题http://ciding.iteye.com/blog/1300110

 

 

评论

2 楼 ciding 2011-12-29  

优先级这个，与线程机制有关。

上面这么说，主要是想区别一下sleep()与yield()。

线程的调度是比较复杂的，不只与优先级相关。（这点没在上面说明，现在说明一下，以免误会）

1 楼 javaeyehoney 2011-12-29  

，所以优先级低的，还是很难与高的相抢。