Java多线程--wait和join

首先从公司一道笔试题开始

package test;

public class Test implements Runnable {

public int i = 0;

@Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
i = 10;
}

public static void main(String[] args) {
try {
Test t = new Test();
Thread th = new Thread(t);
th.start();
th.join();
System.out.println(t.i);
} catch (Exception ex) {

}

}
}

问23行代码怎么写，才能让24行打印出10？

不少笔试者会选t.wait()或者th.wait()!

面试的时候问他为什么，他具体也说不清楚，感觉就是见过这个wait方法，但是wait方法的含义确一知半解。

wait 是什么意思呢？我举例子啊，比如我想让本线程放弃当前对象锁，说直白点就是让别的对象进入同步块

package test;

public class Test implements Runnable {

public Object i = new Object();

@Override
public void run() {
synchronized (i) {
System.out.println(Thread.currentThread().getName()+"enter ");
//            i.notify();
try {
i.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"out ");
}
}

public static void main(String[] args) {
try {
Test t = new Test();
Thread th1 = new Thread(t);
Thread th2 = new Thread(t);
th1.start();
th2.start();

} catch (Exception ex) {

}

}
}

如上例，你会看到输出

Thread-0enter
Thread-1enter

不会看到

Thread-1out
Thread-0out

因为Thread-0 先获得了Object i 锁，然后运行到13行，释放了该锁,

这个时候Thread-1就获得了Object i 锁，进入了同步代码块，然后同样运行13行，也释放了该锁。

这个时候在有两个线程Thread-0和Thread-1等待获得Object i 锁，由于代码中没有调用i.notifyAll(),所以这个程序永远不会退出。

但是如果打开注释11行，那么你将会看到结果

Thread-0enter
Thread-1enter
Thread-0out

因为Thread-0 先获得了Object i 锁，然后运行到13行，释放了该锁,

这个时候Thread-1就获得了Object i 锁，进入了同步代码块，运行到11行，i.notify()，

那么这个意思就是说别的等待i锁的线程可以唤醒了，一旦我（Thread-1）释放锁（13行调用wait()），那么Thread-0就可以获得i锁继续执行了。

此程序中没有在Thread-1 释放i锁（wait（））之后notify，所以永远不会看到Thread-1out

再回到这个题目，我们的意思是让主线程等待所有子线程执行完毕 ，再执行。更何况笔试题中没有锁对象。更别提wait()了。

所以，此处应该用th.join(); Thread.join()方法会阻塞主线程继续向下执行。

public class TestThread extends Thread
{
private CountDownLatch countDownLatch;

public TestThread(CountDownLatch countDownLatch)
{
this.countDownLatch = countDownLatch;
}

public void run()
{
System.out.println(this.getName() + "子线程开始");
try
{
// 子线程休眠五秒
Thread.sleep(5000);
}
catch (InterruptedException e)
{
e.printStackTrace();
}

System.out.println(this.getName() + "子线程结束");

// 倒数器减1
countDownLatch.countDown();
}
}

public class Main
{
public static void main(String[] args)
{
long start = System.currentTimeMillis();

// 创建一个初始值为5的倒数计数器
CountDownLatch countDownLatch = new CountDownLatch(5);
for(int i = 0; i < 5; i++)
{
Thread thread = new TestThread(countDownLatch);
thread.start();
}

try
{
// 阻塞当前线程，直到倒数计数器倒数到0
countDownLatch.await();
}
catch (InterruptedException e)
{
e.printStackTrace();
}

long end = System.currentTimeMillis();
System.out.println("子线程执行时长：" + (end - start));
}
}