java的join方法

在某个线程中调用另一个线程的join方法,是将当前的cpu让给另一个线程,等到规定的时间到了或另一个线程执行结束后,自己再执行。

package test;

public class TestJoin1 {

	public static void main(String[] args) throws InterruptedException {

		TheOtherThread tot = new TheOtherThread();
		Thread t = new Thread(tot);
		t.start();
		//t.join();
		System.out.println("main");
	}

}

class TheOtherThread implements Runnable{

	@Override
	public void run() {
		try {
			for (int i = 0; i < 10; i++) {
				Thread.sleep(1000);
				System.out.println(i);
			}
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

}

上面的结果会是

main
0
1
2
3
4
5
6
7
8
9

将t.join()前面的注释去掉后结果会是

0
1
2
3
4
5
6
7
8
9
main

第二个例子

package test;

import java.util.Date;

public class TestJoin {

	public static void main(String[] args) {

		DateThreat dt1 = new DateThreat("a");
		DateThreat dt2 = new DateThreat("b");

		Thread t1 = new Thread(dt1);
		Thread t2 = new Thread(dt2);

		DateThreat dt3 = new DateThreat("c",t2);
		Thread t3 = new Thread(dt3);

		t1.start();
		t2.start();
		t3.start();

	}

}

class DateThreat implements Runnable{

	private String name ;

	private Thread t;

	public DateThreat(String name) {
		this.name = name;
	}

	public DateThreat(String name,Thread t) {
		this.name = name;
		this.t = t;
	}

	@Override
	public void run() {

		try {
			System.out.println(this.name + " begin : " + new Date());
			if(t != null){
				t.join();
			}
			for(int i =0;i<10;i++){
				Thread.sleep(1000);
				System.out.println(this.name + " : " + i);
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(this.name + " end : " + new Date());

	}

}

a,b,c三个线程几乎同时开始,但c永远是在b执行结束后才开始执行

结果会是:

c begin : Tue Aug 12 17:59:16 CST 2014
b begin : Tue Aug 12 17:59:16 CST 2014
a begin : Tue Aug 12 17:59:16 CST 2014
b : 0
a : 0
b : 1
a : 1
b : 2
a : 2
b : 3
a : 3
b : 4
a : 4
b : 5
a : 5
b : 6
a : 6
b : 7
a : 7
b : 8
a : 8
b : 9
b end : Tue Aug 12 17:59:26 CST 2014
a : 9
a end : Tue Aug 12 17:59:26 CST 2014
c : 0
c : 1
c : 2
c : 3
c : 4
c : 5
c : 6
c : 7
c : 8
c : 9
c end : Tue Aug 12 17:59:36 CST 2014

可以多运行几遍

java的join方法

时间: 2024-10-27 02:33:17

java的join方法的相关文章

[java] java 线程join方法详解

join方法的作用是使所属线程对象正常执行run方法,而对当前线程无限期阻塞,直到所属线程销毁后再执行当前线程的逻辑. 一.先看普通的无join方法NoJoin.java public class NoJoin extends Thread{ @Override public void run() { try { long count = (long)(Math.random()*100); System.out.println(count); Thread.sleep(count); } ca

Java多线程中的join方法

新建一个Thread,代码如下: 1 package com.thread.test; 2 3 public class MyThread extends Thread { 4 private String name; 5 public MyThread(String name) { 6 this.name = name; 7 } 8 @Override 9 public void run() { 10 for (int i = 0; i < 100; i++) { 11 System.out.

java多线程基本概述(七)——join()方法

在很多情况下,主线程创建并启动子线程,如果子线程中有大量的耗时运算,主线程将早于子线程结束,如果想让主线程等待子线程结束后再结束,那么我们可以使用join()方法.调用join()方法的意思是当前线程使调用了该方法的线程执行完成然后再执行自己本身.api文档如下: public final void join(long millis, int nanos) throws InterruptedException Waits at most millis milliseconds plus nan

模拟做饭系统(java+线程中的join方法)

(一)项目框架分析 妈妈要去做饭,发现没有酱油,让儿子去买酱油,然后回来做饭. 根据面向对象的思想,有两个对象,妈妈和儿子 主要有两个方法: (一)没有线程控制(即儿子没有买酱油回来妈妈就做好饭了)+(没有调用jion方法) (二)有线程控制(妈妈进程和儿子进程又先后影响)+(调用jion方法) 项目的结构图: (二)没有进程控制mintak Son.java主要是模拟儿子的行动,儿子买酱油的行动(与有进程控制的源程序相同) 代码如下: public class Son implements R

JAVA中sleep()、wait()、yield()、join()方法浅析

线程退出最好自己实现,在运行状态中一直检验一个状态,如果这个状态为真,就一直运行,如果外界更改了这个状态变量,那么线程就停止运行. 1.sleep()方法 在指定时间内让当前正在执行的线程暂停执行,但不会释放“锁标志”.不推荐使用. sleep()使当前线程进入阻塞状态,在指定时间内不会执行. 2.wait()方法 在其他线程调用对象的notify或notifyAll方法前,导致当前线程等待.线程会释放掉它所占有的“锁标志”,从而使别的线程有机会抢占该锁. 当前线程必须拥有当前对象锁.如果当前线

java join 方法的使用

在很多情况下,主线程创建并启动子线程,如果子线程中要进行大量的耗时运算,主线程往往将早于子线程结束之前结束.这时,如果主线程想等待子线程执行完成之后再结束,比如子线程处理一个数据,主线程要取得这个数据中的值,就要用到join()方法了,方法join()的作用是等待线程对象被销毁. 代码示例: package com.test; public class TestJoin extends Thread { @Override public void run() { try { int second

java线程Thread的join方法。

1,方法的作用: 父线程等待子线程的执行. 如果是join或者join(0),即等待时长是0,父线程就会一直等到子线程执行结束, 如果是join(time),即等待时长是time数值,那父线程等待时长视情况而定: 第一种:子线程执行时长不需要time时长,那么父线程就可能不会等待到time时长,为什么是可能呢?是不是要考虑其他线程(不包括父线程,和子线程以外的线程),他也可能让父线程等待的(没有获取到cpu时间片等原因), 第二种:子线程执行时长超过time时长,那么父线程的等待时长,至少是ti

java基础知识回顾之java Thread类学习(十一)--join方法的理解

以下面例子说明下面的源码:main 线程 和 A线程,A线程是main线程创建并且启动的,main线程优先级比较高,正在执行:这个时候main线程调用A.join()之后,main线程一直等待,直到A线程运行完毕,main线程才运行. join方法的源码: * Waits at most {@code millis} milliseconds for this thread to * die. A timeout of {@code 0} means to wait forever. * * <

JAVA中sleep()、wait()、yield()、join()方法

线程退出最好自己实现,在运行状态中一直检验一个状态,如果这个状态为真,就一直运行,如果外界更改了这个状态变量,那么线程就停止运行. 1.sleep()方法 在指定时间内让当前正在执行的线程暂停执行,但不会释放"锁标志".不推荐使用. sleep()使当前线程进入阻塞状态,在指定时间内不会执行. 2.wait()方法 在其他线程调用对象的notify或notifyAll方法前,导致当前线程等待.线程会释放掉它所占有的"锁标志",从而使别的线程有机会抢占该锁. 当前线程