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));
    }
}