Thread

让主线程等待子线程的运行

方法一：join,理解成等待子线程终止，可用于等待一个或多个子线程的结果，而后主线程再继续执行。

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.e("Thread", "主线程开始运行");
        new Thread1().start();
        Log.e("Thread", "主线程结束运行");
    }
}

public class Thread1 extends Thread{
    @Override
    public void run() {
        Log.e("Thread", "Thread1开始运行");
        Thread2 thread2 = new Thread2();
        thread2.start();
        try {
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Log.e("Thread","Thread1结束运行");
    }
}

public class Thread2 extends Thread{
    @Override
    public void run() {
        Log.e("Thread", "Thread2开始运行");
        try {
            Thread2.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Log.e("Thread","Thread2结束运行");
    }
}

 咱们在主线程中添加了一个thread1，在thread1中运行并加入thread2，在thread2中让他延时1S。

咱们来看看结果，（主线程可能在Thread1开始前结束，可能在在开始后结束，这不是重点），Thread1在Thread2运行结束后才结束

说明咱们作到了让父线程（Thread1）等待子线程(Thread2)

 

 

 2.使用FLAG标志位，就是设一个全局变量，子线程没结束就一直while（）

public class MainActivity extends AppCompatActivity {
    public static int FLAG = 0;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        new Thread1().start();
    }
}

public class Thread1 extends Thread{
    @Override
    public void run() {
        Log.e("Thread", "Thread1开始运行");
        Thread2 thread2 = new Thread2();
        thread2.start();
        while(MainActivity.FLAG != 1){
            //这里能够作点其余的事情哦
        }
        MainActivity.FLAG = 0;
        Log.e("Thread","Thread1结束运行");
    }
}

public class Thread2 extends Thread{
    @Override
    public void run() {
        Log.e("Thread", "Thread2开始运行");
        try {
            Thread2.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Log.e("Thread","Thread2结束运行");
        MainActivity.FLAG = 1;
    }
}

 

运行结果，能够看到咱们成功了，可是我不喜欢这种方法，感受很卑鄙

 

3.CountDownLatch 经过检查子线程的个数来实现的

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        new Thread1().start();
    }
}


public class Thread1 extends Thread{
    public static CountDownLatch countDownLatch = new CountDownLatch(1);//设置数量
    @Override
    public void run() {
        Log.e("Thread", "Thread1开始运行");
        Thread2 thread2 = new Thread2();
        thread2.start();
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Log.e("Thread","Thread1结束运行");
    }
}


public class Thread2 extends Thread{
    @Override
    public void run() {
        Log.e("Thread", "Thread2开始运行");
        try {
            Thread2.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Log.e("Thread","Thread2结束运行");
        Thread1.countDownLatch.countDown();//运行结束，数量减小
    }
}

 

 

不用说太多