黑马程序员技术交流社区

标题: 线程中join()函数的问题 [打印本页]
作者: ò壞尛孩    时间: 2014-4-12 14:41
标题: 线程中join()函数的问题
  1. class Demo
  2. {
  3. ...
  4. }
  5. class JoinDemo
  6. {
  7. public static void main(String[] args)
  8. {
  9. Demo d=new Demo();
  10. Thread t1=new Thread(d);
  11. Thread t2=new Thread(d);

  13. t1.start();
  14. t2.start();
  15. <b>t1.join();//这里执行的线程有三个t1,t2,main为什么t1线程join下后抢夺的是main线程的执行权，而不是t2或者是t2和main的执行权，</b>
复制代码
作者: _Water    时间: 2014-4-12 15:00
其实很简单：thread.Join把指定的线程加入到当前线程。
而线程t1是由主线程main生成并起动，主线程main才是线程t1的当前线程。
主线程main中调用了线程t1的Join()方法，直到线程t1执行完毕后，才会继续执行线程main
作者: 王峰峰    时间: 2014-4-12 15:37
首先要理解join()的作用，join()方法的作用就是让一个线程强制运行，线程运行期间，被抢夺线程是无法运行的，必须等待此线程完成后才可以继续执行。
修改测试代码如下：
  1. class Demo implements Runnable
  2. {

  4.         @Override
  5.         public void run() {
  6.                 for(int i=0; i<50; i++) {
  7.                         System.out.println(Thread.currentThread().getName() + " --> Demo" + i);
  8.                 }
  9.         }
  10.        
  11. }
  12. public class JoinDemo
  13. {
  14.         public static void main(String[] args)
  15.         {
  16.                 Demo d = new Demo() ;
  17.                 Thread t1=new Thread(d);
  18.                 t1.setName("t1");                 //设置线程名称
  19.                 Thread t2=new Thread(d);
  20.                 t2.setName("t2");                 //设置线程名称
  21.                
  22.                 t1.start();
  23.                 t2.start();
  24.                
  25.                 for(int i=0; i<50; i++) {
  26.                         if(i>10) {
  27.                                 try {
  28.                                         t1.join();                //线程t1强制执行
  29.                                 } catch (InterruptedException e) {
  30.                                         e.printStackTrace();
  31.                                 }
  32.                         }
  33.                         System.out.println("Main线程 --> " + i);
  34.                 }
  35.         }
  36. }
复制代码

运行结果截图：


从以上程序发现，它抢夺的当前线程。

作者: ò壞尛孩    时间: 2014-4-12 20:44
_Water 发表于 2014-4-12 15:00
其实很简单：thread.Join把指定的线程加入到当前线程。
而线程t1是由主线程main生成并起动，主线程main才是 ...

也就是说谁调用这个线程的，就暂停哪个线程的资源是吗？如果在t1线程里面调用t2.join()暂停的就是t1线程是吗？
作者: 四川男人    时间: 2014-4-13 00:09
join()的使用是抢夺当前线程的使用权，直到调用join()的线程结束，才执行其他线程。在main()方法中，主线程是main(),所以抢走的是main()的使用权，当t1线程结束后，才又main线程跟t2抢执行权
作者: 杨庆雷    时间: 2014-4-13 00:36
ò壞尛孩 发表于 2014-4-12 20:44
也就是说谁调用这个线程的，就暂停哪个线程的资源是吗？如果在t1线程里面调用t2.join()暂停的就是t1线程 ...

比如说在主线程 开启了 三个线程 t1  t2  t3 ,当我们调用t1.join()时，主线程被阻塞   但是 t2  t3 是正常运行的

t1  t2  t3 他们三个 继续争夺 执行权    t1.join()只会阻塞当前线程  对其他线程无影响
作者: 清风夜独醉    时间: 2014-4-13 00:53
首先你要知道join()这个方法的作用，它是把指定线程合并到当前线程中，并且指定线程执行完之后当前线程才能接着继续执行。
其次就要知道哪个指定线程，哪个是当前线程。调用join方法的就是指定线程，执行这条语句的线程就是当前线程，你的代码中t1.join(),显然t1是指定线程，而执行t1.join()这条语句的线程是main线程，所以t1线程抢夺下的是main的执行权
作者: 心?=忐§忑]    时间: 2014-4-13 07:46
main主方法其实也是一个线程，可以使用join（）方法让一个线程强制运行，线程强制运行期间，其他线程无法运行，在这里，main主方法是一个系统的默认线程，所以t1线程抢夺的是main线程的执行权！
作者: wangkerui    时间: 2014-4-13 09:39
join()是Thread类的一个方法。根据jdk文档的定义：
public final void join()throws InterruptedException: Waits for this thread to die.
join()方法的作用，是等待这个线程结束；但显然，这样的定义并不清晰。个人认为"Java 7 Concurrency Cookbook"的定义较为清晰：
join() method suspends the execution of the calling thread until the object called finishes its execution.
也就是说，t.join()方法阻塞调用此方法的线程(calling thread)，直到线程t完成，此线程再继续；通常用于在main()主线程内，等待其它线程完成再结束main()主线程。

  1. class Demo implements Runnable
  2. {

  4.         @Override
  5.         public void run() {
  6.                 for(int i=0; i<50; i++) {
  7.                         System.out.println(Thread.currentThread().getName() + " --> Demo" + i);
  8.                 }
  9.         }
  10.         
  11. }
  12. public class JoinDemo
  13. {
  14.         public static void main(String[] args)
  15.         {
  16.                 Demo d = new Demo() ;
  17.                 Thread t1=new Thread(d);
  18.                 t1.setName("t1");                 //设置线程名称
  19.                 Thread t2=new Thread(d);
  20.                 t2.setName("t2");                 //设置线程名称
  21.                
  22.                 t1.start();
  23.                 t2.start();
  24.                
  25.                 for(int i=0; i<50; i++) {
  26.                         if(i>10) {
  27.                                 try {
  28.                                         t1.join();                //线程t1强制执行
  29.                                 } catch (InterruptedException e) {
  30.                                         e.printStackTrace();
  31.                                 }
  32.                         }
  33.                         System.out.println("Main线程 --> " + i);
  34.                 }
  35.         }
  36. }
复制代码
可以看出，Join方法实现是通过wait（小提示：Object 提供的方法）。 当main线程调用t1.join时候，main线程会获得线程对象t1的锁（wait 意味着拿到该对象的锁),调用该对象的wait(等待时间)，直到该对象唤醒main线程 ，比如退出后。这就意味着main 线程调用t2.join时，必须能够拿到线程t2对象的锁。






欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2