1. public class TestThread{
   
2. public static void main(String args[]){
   
3. Thread1 t1=new Thread1();
   
4. Thread2 t2=new Thread2();
   
5. t1.start();
   
6. t2.start();
   
7. try{
   
8. <FONT color=red>t1.join();
   
9. </FONT>}catch (Exception e) {
   
10. e.printStackTrace();
    
11. }
    
12. }
    
13. }
    
14. 
    
15. class Thread1 extends Thread{
    
16. private int j=0;
    
17. public void run(){
    
18. for(int i=0;i<10;i++){
    
19. try {
    
20. Thread.sleep(1000);
    
21. } catch (InterruptedException e) {
    
22. e.printStackTrace();
    
23. }
    
24. System.out.println("thread1:"+j++);
    
25. }
    
26. }
    
27. }
    
28. class Thread2 extends Thread{
    
29. private int j=0;
    
30. public void run(){
    
31. for(int i=0;i<10;i++){
    
32. try {
    
33. Thread.sleep(1000);
    
34. } catch (InterruptedException e) {
    
35. e.printStackTrace();
    
36. }
    
37. System.out.println("thread2:"+j++);
    
38. }
    
39. }
    
40. }

复制代码

启动线程1和线程2之后，我的线程1使用了join()方法，为什么线程1还是和线程2轮流执行呢？不应该是线程1执行完了再执行线程2吗？求解释。。

public class TestThread{
public static void main(String args[]){
Thread1 t1=new Thread1();
Thread2 t2=new Thread2();
t1.start();                                 
//t1.join();  把这个放这就好了，
t2.start();
try{
<FONT color=red>t1.join();
</FONT>}catch (Exception e) {
e.printStackTrace();
}
}
}

class Thread1 extends Thread{
private int j=0;
public void run(){
for(int i=0;i<10;i++){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("thread1:"+j++);
}
}
}
class Thread2 extends Thread{
private int j=0;
public void run(){
for(int i=0;i<10;i++){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("thread2:"+j++);
}
}
}

t1.start();
t1.join();
t2.start();   //这种情况是 t1执行完后，t2才执行，主线程放弃资格。

t1.start();
t2.start();
t1.join();//这情况是t1和t2交替执行，  t1结束后主线程就开始运行，此时不管t2是否还在执行。

sunhaodi 发表于 2012-6-15 20:36
public class TestThread{
public static void main(String args[]){
Thread1 t1=new Thread1();

这样确实可以，谢谢。。

你的join方法是在主线程中被调用的，而且是在t1和t2两个线程都启用的情况下才被调用。
所以会两个线程交替执行，从调用join（）那一刻开始，主线程main就一直等待t1结束。
好比三个人在做饭，厨师长指挥两个厨师一个开始调汤，一个开始配菜，自己在弄秘制酱料，
发现秘制酱料要汤好了才可以继续做......此时两人都开动了，于是开始等待汤熬好。