多线程中join(long mills)和sleep(long mills)的区别

join()方法是等待这个线程执行完之后，外部线程才继续执行，但是有了参数之后，就是只暂停一段时间，过后就直接继续执行。看起来和sleep(long mills)方法类似，但是也有区别
join(1000)和sleep(1000)都是让当前线程停止运行1000ms，但是 join(1000)底层是使用wait来实现的，所以join(1000)的时候，其他的线程能够得到锁，而sleep()就不会释放锁。

示例：

public class ThreadA extends Thread {

    private ThreadB b;

    public ThreadA(ThreadB b) {
        this.b = b;
    }
    @Override
    public void run() {
        synchronized (b){
            try {
                b.start();
//                b.join();
                Thread.sleep(6000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        super.run();
    }
}

public class ThreadB extends Thread {

    @Override
    public void run() {
        try {
            System.out.println("b  开始运行");
            Thread.sleep(5000);
            System.out.println("b 结束运行");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        super.run();
    }
    synchronized public void bService(){
        System.out.println("bservice正在执行");
    }
}

public class ThreadC extends Thread {

    private ThreadB threadB;

    public ThreadC(ThreadB threadB) {
        this.threadB = threadB;
    }

    @Override
    public void run() {
        threadB.bService();
        super.run();
    }
}

还有Run类：

public class Run {
    public static void main(String[] args) {
        try {
            ThreadB b=new ThreadB();
            ThreadA a=new ThreadA(b);
            a.start();
            Thread.sleep(1000);
            ThreadC c=new ThreadC(b);
            c.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

因为线程A执行的方法和线程C执行的方法都需要 this锁，所以观察运行结果，如果是异步那么说明锁是立即释放，如果同步了，那锁是不释放的。
使用sleep(long mills)的运行结果：

而使用 join(long mills)的运行结果：

可以发现，一个是等待b执行结束之后才执行，一个没有则没有等，说明join(long mills )是采用释放锁的方式