多线程 join方法的使用

        在很多情况下，主线程创建并启动子线程，如果子线程中要进行大量的耗时运算，主线程往往将早于子线程结束之前结束。这时，如果主线程想等待子线程执行完成之后在结束，比如子线程处理一个数据，主线程要取的这个数据中的值，就要用到join()方法。join()方法的作用是等待线程对象销毁。join()与 join(long) 方法 都有释放锁的特点。

1.join() 方法

线程代码

public class MyThread extends Thread{
	@Override
	public void run() {
		super.run();
		int sum = 0;
		for(int i = 0;i<100;i++){
			sum = sum + i +1;
		}
		System.out.println(sum + "    " +System.currentTimeMillis());
		System.currentTimeMillis();
		try {
			Thread.sleep(5000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

测试代码：

public class Run {

	public static void main(String[] args) {
		try {
			MyThread mythread = new MyThread();
			mythread.start();
			mythread.join();
			System.out.println("main    " + System.currentTimeMillis());
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

运行结果：
················

2.join(long) 方法

         方法join(long) 中的参数是设定等待时间，当时间超过long时间后释放锁。

3. join(long) 方法 可以释放锁的 验证

        通过与sleep(long) 方法进行对比，可以体现出join()方法的释放锁特性。因为sleep(long) 方法是不会释放当前对象的锁的。

ThreadB 线程的代码：

public class ThreadB extends Thread{
	@Override
	public void run() {
		super.run();
		System.out.println("进入 run方法    " + System.currentTimeMillis());
		try {
			Thread.sleep(5000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
	synchronized public void printString(){
		System.out.println("进入了 printString方法    " + System.currentTimeMillis());
	}
}

ThreadA 线程：（运行ThreadB中的run方法）

public class ThreadA extends Thread{
	private ThreadB threadb;
	public ThreadA(ThreadB threadb){
		this.threadb = threadb;
	}
	@Override
	public void run() {
		super.run();
		synchronized(threadb){
			threadb.start();
			try {
				// 有区别的地方
//				threadb.join(6000);
				Thread.sleep(6000);
				System.out.println("ThreadA 中" + System.currentTimeMillis());
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

ThreadC 线程 ：（运行ThreadB中的同步方法）

public class ThreadC extends Thread{
	private ThreadB threadb;
	public ThreadC(ThreadB threadb){
		this.threadb = threadb;
	}
	@Override
	public void run() {
		super.run();
		threadb.printString();
	}
}

运行代码：

public class Run {
	public static void main(String[] args){
		ThreadB b = new ThreadB();
		ThreadA a = new ThreadA(b);
		ThreadC c = new ThreadC(b);
		a.start();
		c.start();
	}
}

1）首先 我们将 threadb.join(6000);注释，将Thread.sleep(6000)打开。运行结果：

可以看到 ThreadB中的 加锁方法是同步运行的。
2）将 threadb.sleep(6000);注释，将Thread.join(6000)打开。运行结果：

ThreadB中的 加锁方法是异步运行的。
通过比较可以得到结论: join(long)方法是会释放对象锁的。