Java多线程：抢占

概念

join可以理解成为强行抢占资源，谁调用join()谁抢占资源就先运行，要么运行完，要么设置占用资源时间。

join为非静态方法，定义如下：

1
2
3
4
5
6
void join()    
    等待该线程终止。    
void join(long millis)    
    等待该线程终止的时间最长为 millis 毫秒。    
void join(long millis, int nanos)    
    等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。

join（）方法使等待当前Thread对象完成线程,例如thread1.join()表示等这个线程结束再执行下一个线程，而且，使用join()方法，必须注意顺序，打个比方：

1
2
3
thread2.start();
thread2.join(); 
thread1.start();

这样的顺序join()方法才有用,如果使用： 

1
2
3
thread2.start();
thread1.start();
thread2.join();

这样的顺序没有改变什么！完全没有发挥join()方法的特点。

测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/***
 * Java多线程—抢占
 *
 */
public class Join {
    
    public static void main(String[] args){
          Thread t1 = new JoinThread("AA");
          t1.start();
          try{
                t1.join(500);                 //Join在这里~
          } catch(InterruptedException e) {
                e.printStackTrace();
          }      
          System.out.println("over");
    }
}
 class JoinThread extends Thread{
    public JoinThread(String name){
          super(name);
    }
    
    public void run(){
          for(int i=0; i<10; i++){
                for(long k=0; k<100000000; k++){}
                System.out.println(this.getName() + ": " +i);
          }
    }

输出结果

1
2
3
4
5
6
7
8
9
10
11
AA: 0
AA: 1
AA: 2
AA: 3
AA: 4
AA: 5
AA: 6
over
AA: 7
AA: 8
AA: 9

但是如果把 t.join(500) 改成 t.join() 的话输出结果会变成：

1
2
3
4
5
6
7
8
9
10
11
AA: 0
AA: 1
AA: 2
AA: 3
AA: 4
AA: 5
AA: 6
AA: 7
AA: 8
AA: 9
over

这样子就很明显了，t.join(int wait_time);后面的代码想要执行需要满足以下条件之一：
1、线程t死了；
2、等待时间超过wait_time；

Java
Java, Thread