新的起点 新的开始

快乐生活 !

深入浅出Java多线程(1)-方法 join

    对于Java开发人员,多线程应该是必须熟练应用的知识点,特别是开发基于Java语言的产品。本文将深入浅出的表述Java多线程的知识点,在后续的系列里将侧重于Java5由Doug Lea教授提供的Concurrent并行包的设计思想以及具体实现与应用。
    如何才能深入浅出呢,我的理解是带着问题,而不是泛泛的看。所以该系列基本以解决问题为主,当然我也非常希望读者能够提出更好的解决问题的方案以及提出更多的问题。由于水平有限,如果有什么错误之处,请大家提出,共同讨论,总之,我希望通过该系列我们能够深入理解Java多线程来解决我们实际开发的问题。
    作为开发人员,我想没有必要讨论多线程的基础知识,比如什么是线程? 如何创建等 ,这些知识点是可以通过书本和Google获得的。本系列主要是如何理深入解多线程来帮助我们平时的开发,比如线程池如何实现? 如何应用锁等。 

(1)方法Join是干啥用的? 简单回答,同步,如何同步? 怎么实现的? 下面将逐个回答。
    自从接触Java多线程,一直对Join理解不了。JDK是这样说的:
Thread (Java Platform SE 6)    join
    public final void join(long millis)throws InterruptedException
    Waits at most millis milliseconds for this thread to die. A timeout of 0 means to wait forever.
 大家能理解吗? 字面意思是等待一段时间直到这个线程死亡,我的疑问是那个线程,是它本身的线程还是调用它的线程的,上代码: 
package concurrentstudy;
/**
 *
 * 
@author vma
 
*/
public class JoinTest {
    
public static void main(String[] args) {
        Thread t 
= new Thread(new RunnableImpl());
        t.start();
        
try {
            t.join(
1000);
            System.out.println(
"joinFinish");
        } 
catch (InterruptedException e) {
            
// TODO Auto-generated catch block
            e.printStackTrace();
     
        }
    }
}
class RunnableImpl implements Runnable {

    @Override
    
public void run() {
        
try {
            System.out.println(
"Begin sleep");
            Thread.sleep(
1000);
           System.out.println(
"End sleep");
        } 
catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}
结果是:
Begin sleep
End sleep
joinFinish
明白了吧,当main线程调用t.join时,main线程等待t线程,等待时间是1000,如果t线程Sleep 2000呢
 public void run() {
        
try {
            System.out.println(
"Begin sleep");
            // Thread.sleep(
1000);
            Thread.sleep(2000);
           System.out.println("End sleep");
        } 
catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

结果是:
Begin sleep
joinFinish
End sleep
也就是说main线程只等1000毫秒,不管T什么时候结束,如果是t.join()呢, 看代码:  
 public final void join() throws InterruptedException {
    join(0);
    }
就是说如果是t.join() = t.join(0) 0 JDK这样说的 A timeout of 0 means to wait forever 字面意思是永远等待,是这样吗?
其实是等到t结束后。
这个是怎么实现的吗? 看JDK代码:
    /**
     * Waits at most <code>millis</code> milliseconds for this thread to 
     * die. A timeout of <code>0</code> means to wait forever. 
     *
     * 
@param      millis   the time to wait in milliseconds.
     * 
@exception  InterruptedException if any thread has interrupted
     *             the current thread.  The <i>interrupted status</i> of the
     *             current thread is cleared when this exception is thrown.
     
*/
    
public final synchronized void join(long millis) 
    
throws InterruptedException {
    
long base = System.currentTimeMillis();
    
long now = 0;

    
if (millis < 0) {
            
throw new IllegalArgumentException("timeout value is negative");
    }

    
if (millis == 0) {
        
while (isAlive()) {
        wait(
0);
        }
    } 
else {
        
while (isAlive()) {
        
long delay = millis - now;
        
if (delay <= 0) {
            
break;
        }
        wait(delay);
        now 
= System.currentTimeMillis() - base;
        }
    }
    }
其实Join方法实现是通过wait(小提示:Object 提供的方法)。 当main线程调用t.join时候,main线程会获得线程对象t的锁(wait 意味着拿到该对象的锁),调用该对象的wait(等待时间),直到该对象唤醒main线程,比如退出后。

这就意味着main 线程调用t.join时,必须能够拿到线程t对象的锁,如果拿不到它是无法wait的,刚开的例子t.join(1000)不是说明了main线程等待1秒,如果在它等待之前,其他线程获取了t对象的锁,它等待时间可不就是1毫秒了。上代码介绍:
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 
*/
package concurrentstudy;
/**
 *
 * 
@author vma
 
*/
public class JoinTest {
    
public static void main(String[] args) {
        Thread t 
= new Thread(new RunnableImpl());
       
new ThreadTest(t).start();
        t.start();
        
try {
            t.join();
            System.out.println(
"joinFinish");
        } 
catch (InterruptedException e) {
            
// TODO Auto-generated catch block
            e.printStackTrace();
     
        }
    }
}
class ThreadTest extends Thread {

    Thread thread;

    
public ThreadTest(Thread thread) {
        
this.thread = thread;
    }

    @Override
    
public void run() {
        holdThreadLock();
    }

    
public void holdThreadLock() {
        
synchronized (thread) {
            System.out.println(
"getObjectLock");
            
try {
                Thread.sleep(
9000);

            } 
catch (InterruptedException ex) {
             ex.printStackTrace();
            }
            System.out.println(
"ReleaseObjectLock");
        }

    }
}

class RunnableImpl implements Runnable {

    @Override
    
public void run() {
        
try {
            System.out.println(
"Begin sleep");
            Thread.sleep(
2000);
           System.out.println(
"End sleep");
        } 
catch (InterruptedException e) {
            e.printStackTrace();
        }


    }
}
在main方法中 通过new ThreadTest(t).start();实例化ThreadTest 线程对象, 它在holdThreadLock()方法中,通过 synchronized (thread),获取线程对象t的锁,并Sleep(9000)后释放,这就意味着,即使
main方法t.join(1000),等待一秒钟,它必须等待ThreadTest 线程释放t锁后才能进入wait方法中,它实际等待时间是9000+1000 MS
运行结果是:
getObjectLock
Begin sleep
End sleep
ReleaseObjectLock
joinFinish

小结:
本节主要深入浅出join及JDK中的实现。
在下一节中,我们将要讨论SWing 中的事件方法线程来解决一个网友问到的问题:
如何控制Swing程序在单机只有一个实例,也就是不能运行第二个Main方法。





   

posted on 2008-08-23 23:25 advincenting 阅读(27123) 评论(13)  编辑  收藏

评论

# re: 深入浅出Java多线程(1)-方法 join 2008-09-04 20:46 Brian

学习了,我一直知道join方法的用法,但从没想法它的实现。受益啊!  回复  更多评论   

# re: 深入浅出Java多线程(1)-方法 join 2008-09-08 23:04 Xsource

明白了····
谢谢  回复  更多评论   

# re: 深入浅出Java多线程(1)-方法 join 2009-02-24 22:51 小石~~

好文章 不愧是深入浅出 拜读  回复  更多评论   

# re: 深入浅出Java多线程(1)-方法 join 2009-04-09 15:59 Adams

bu cuo de   回复  更多评论   

# re: 深入浅出Java多线程(1)-方法 join 2009-04-21 15:45 陌生人

看了你的文章.我测试了下,发现你最后一个例子中,“main方法t.join(1000),等待一秒钟,它必须等待ThreadTest 线程释放t锁后才能进入wait方法中,它实际等待时间是9000+1000 MS” ,它并不是如你写的这样,而是ReleaseObjectLock 和joinFinish几乎一起出现的。 ...


  回复  更多评论   

# re: 深入浅出Java多线程(1)-方法 join 2009-04-21 16:28 陌生人

我做了个测试:public static void main(String[] args) {
Thread t = new Thread(new RunnableImpl());
new ThreadTest(t).start();
// new ThreadTest(t).start();
t.start();
try {
System.out.println("joinBegin?");
t.join(50000);
System.out.println("joinFinish");
//t.start();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();

}
}
当只有1个new ThreadTest(t).start();的时候,不管你 t.join(50000);里面写多少,都是一起出现最后结果ReleaseObjectLock,joinFinish。但是当你写了2个new ThreadTest(t).start(); 这个t.join(50000);里面数字就有关系了,它影响到了joinFinish打印的顺序,但是不管你怎么写,它都是和其中一个ReleaseObjectLock 一起出现..呵呵...希望我才现在回复这个还不嫌晚..  回复  更多评论   

# re: 深入浅出Java多线程(1)-方法 join[未登录] 2011-05-26 16:49 Michael

写得好,学习了  回复  更多评论   

# re: 深入浅出Java多线程(1)-方法 join 2011-08-24 18:14 Scott Fan

博主啊,你最后这不把我们往坑里带嘛··

你看啊,
Thread的public final synchronized void join(long millis) 方法中
有这么一个分支:
if (millis == 0) {
while (isAlive()) {
wait(0);
}
} else {
while (isAlive()) // 大家注意这句啊!!
{
long delay = millis - now;
if (delay <= 0) {
break;
}
wait(delay);
now = System.currentTimeMillis() - base;
}
}

走到 while (isAlive()) 这个循环的时候,线程对象的isAlive()是false啊,所以直接就返回了,
不会像你说的似的,9000+1000毫秒。

大家看的时候别往坑里跳啊。  回复  更多评论   

# re: 深入浅出Java多线程(1)-方法 join 2012-02-26 23:34 路人甲

哥们你这篇深入浅出写得...最后一个程序这毛病多了去了..新手不要往坑里跳....jion的JDK很有参考意义 最后一个程序作为捉虫程序(逻辑错误) 很有价值。。  回复  更多评论   

# re: 深入浅出Java多线程(1)-方法 join 2012-02-27 00:11 路人甲

关于最后一个程序,按照作者所写程序,线程间的运行状况如下所述:
首先启动ThreadTest,对t加锁(注意,加锁的是t的代码块,此处对t加锁导致main不能获得t的锁,所以t.jion无法执行,但是不影响t线程本身start),然后sleep ,接着t.start(),t sleep 2秒。之后程序无事可做,再7秒之后,ThreatTest线程结束,锁释放。main获得t的锁,此时t线程已经不是alive。所以立刻输出jionFinish。在作者的程序中,t.jion相当于将main的线程blocked.若想达到作者最后一句所说的jion 9000+1000毫秒,则在ThreadTest释放锁之后,t线程应该处于alive状态。所以讲RunnableImpl中的sleep时间设置为大于10000,则实际等待时间为9000+1000毫秒。但是此时的输出顺序发生变化,为:
getObjectLock
Begin sleep
ReleaseObjectLock
jionFinish
End sleep
希望上述解释能够让大家走出作者的坑。。。另,我把这篇博文转载到我的blog里面进行更正了  回复  更多评论   

# re: 深入浅出Java多线程(1)-方法 join[未登录] 2012-11-06 15:45 test

最后一个运行了一下,怎么也只有9秒啊?
Tue Nov 06 15:44:22 CST 2012getObjectLock
Tue Nov 06 15:44:22 CST 2012Begin sleep
Tue Nov 06 15:44:24 CST 2012End sleep
Tue Nov 06 15:44:31 CST 2012ReleaseObjectLock
Tue Nov 06 15:44:31 CST 2012joinFinish  回复  更多评论   

# re: 深入浅出Java多线程(1)-方法 join[未登录] 2013-04-10 14:59 eason

@路人甲
精彩,了解了  回复  更多评论   

# re: 深入浅出Java多线程(1)-方法 join[未登录] 2013-06-21 14:51

Begin sleep
joinFinish
End sleep
我的怎么不一样呀  回复  更多评论   


只有注册用户登录后才能发表评论。


网站导航:
 

公告

Locations of visitors to this page

导航

<2008年8月>
272829303112
3456789
10111213141516
17181920212223
24252627282930
31123456

统计

常用链接

留言簿(13)

随笔分类(71)

随笔档案(179)

文章档案(13)

新闻分类

IT人的英语学习网站

JAVA站点

优秀个人博客链接

官网学习站点

生活工作站点

最新随笔

搜索

积分与排名

最新评论

阅读排行榜

评论排行榜