并发编程（5）Thread类的使用(sleep/yield/join)

Thread类中的方法：

.1)sleep

     强制当前正在执行的线程休眠指定的时间（线程转到阻塞状态），让出CPU给其他线程，在此期间，sleep不会释放对象锁，当休眠时间到期，恢复到可运行状态。关于sleep不会释放对象锁，请看下面例子：

public class TestSleep2 {
private int i = 10;
private Object object = new Object();

public static void main(String[] args) throws IOException  {
TestSleep2 test = new TestSleep2();
MyThread thread1 = test.new MyThread();
MyThread thread2 = test.new MyThread();
thread1.start();
thread2.start();
}

class MyThread extends Thread{
@SuppressWarnings("static-access")
@Override
public void run() {
synchronized (object) {
i++;
System.out.println("i:"+i);
try {
System.out.println("线程"+Thread.currentThread().getName()+"进入睡眠状态");
Thread.currentThread().sleep(10000);
} catch (InterruptedException e) {
// TODO: handle exception
}
System.out.println("线程"+Thread.currentThread().getName()+"睡眠结束");
i++;
System.out.println("i:"+i);
}
}
}
}

i:11
线程Thread-0进入睡眠状态
线程Thread-0睡眠结束
i:12
i:13
线程Thread-1进入睡眠状态
线程Thread-1睡眠结束
i:14

从上面输出结果可以看出，当Thread-0进入睡眠状态之后，Thread-1并没有去执行具体的任务。只有当Thread-0执行完之后，此时Thread-0释放了对象锁，Thread-1才开始执行

.2)yield

调用yield方法会让当前线程交出CPU权限，让CPU去执行其他的线程。它跟sleep方法类似，同样不会释放锁。但是yield不能控制具体的交出CPU的时间，另外，yield方法只能让拥有相同优先级的线程(也包括当前线程)有获取CPU执行时间的机会。

注意:调用yield方法并不会让线程进入阻塞状态，而是让线程重回就绪状态，它只需要等待重新获取CPU执行时间，这一点是和sleep方法不一样的。

public class TestYield extends Thread{

@SuppressWarnings("static-access")
@Override
public void run() {
for (int i = 0; i < 3; i++) {
System.out.println("当前正在执行线程："+Thread.currentThread().getName()+",i="+i);
Thread.currentThread().yield();
}
}

public static void main(String[] args) {
TestYield t1=new TestYield();
TestYield t2=new TestYield();
TestYield t3=new TestYield();
t1.start();
t2.start();
t3.start();
}

输出结果：

当前正在执行线程：Thread-0,i=0
当前正在执行线程：Thread-2,i=0
当前正在执行线程：Thread-1,i=0
当前正在执行线程：Thread-2,i=1
当前正在执行线程：Thread-0,i=1
当前正在执行线程：Thread-2,i=2
当前正在执行线程：Thread-1,i=1
当前正在执行线程：Thread-1,i=2
当前正在执行线程：Thread-0,i=2

当然，每次执行结果可能不一样，从上面可以看出，当前线程调用yield（）方法之后，有可能执行其他线程，也有可能当前线程继续获取CPU权限。

.3)join
在一个线程里面调用另一个线程的join方法时，表示本线程阻塞直到另一个线程执行完毕。

主要用途：多个线程并行执行，如果某一个线程要用到一个或者多个线程的执行结果，或者某个线程必须等待一个或者多个线程执行完毕方能执行，可以采用join方法。

请看下面例子：

      

public class TestJoin {

private int count=0;

class Thread1 extends Thread{
@SuppressWarnings("static-access")
public void run(){
while(count<100){
count++;
if(count==10){
try {
Thread.currentThread().sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
System.out.println("now Count-size :"+count);
}
}

class Thread2 extends Thread{
public void run(){
System.out.println("count-size:"+count);
}
}

public static void main(String[] args) throws InterruptedException {
TestJoin t= new TestJoin();
Thread1 t1=t.new Thread1();
Thread2 t2=t.new Thread2();
t1.start();
//t1.join();
t2.start();
}

}

当注释掉t1.join();时，结果如下：

count-size:10
now Count-size :100

启用t1.join()时，结果如下：

now Count-size :100
count-size:100

可以看出没有调用t1.join（）方法时，t2在t1进入休眠时已经执行完毕，调用了该方法时，t2等待t1执行完才开始执行。

实际上 join（）方法调用的事wait方法，这个可以从源码得知，

public final synchronized void join(long millis)
throws InterruptedException {
long base = System.currentTimeMillis();
long now = 0;

if (millis < 0) {
throw new IllegalArgumentException("timeout value is negative");
}

if (millis == 0) {
while (isAlive()) {
wait(0);
}
} else {
while (isAlive()) {
long delay = millis - now;
if (delay <= 0) {
break;
}
wait(delay);
now = System.currentTimeMillis() - base;
}
}
}

wait方法会让线程进入阻塞状态，并且会释放线程占有的锁，并交出CPU执行权限。　　

由于wait方法会让线程释放对象锁，所以join方法同样会让线程释放对一个对象持有的锁。

参考资料：

              http://www.cnblogs.com/dolphin0520/p/3920357.html