多线程基础学习（五）——控制线程

一、join线程

    Thread提供的join()方法，可以让一个线程等待另一个线程完成。当在某个程序执行流中调用其他线程的join方法时，调用线程被阻塞，知道被join()方法加入的线程执行完毕。

    join()方法通常由使用线程的程序调用，以将大问题划分为许多小问题，每个小问题分配一个线程。当所有小问题都得到处理后，再调用主线程来进一步操作。

    代码样例

/**
 * 准备Join到其他线程的线程
 **/
public class JoinThread extends Thread {
    //有参构造，设置线程的名字
    public JoinThread(String name){
        super(name);
    }
    @Override
    public void run() {
        for (int i = 1; i <= 20; i++) {
            System.out.println(getName() + " " + i);
        }
    }
}

/**
 * Join线程-单元测试
 **/
public class JoinThreadTest {
    @Test
    public void testJoinThread() throws InterruptedException {
        for (int i = 0; i < 50; i++) {
            if(i == 20){
                JoinThread jt = new JoinThread("被Join的线程");
                jt.start();
                jt.join();
            }
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }
}

    打印结果（只截取部分）

    分析：

    主方法的执行，作为主线程，然后在主线程中创建了JoinThread的名为“被Join的线程”的线程对象并启动，然后调用了线程对象的join()方法，该线程不会和主线程并发执行，主线程此时处于阻塞状态，必须等该线程执行完后才能继续执行。

    join()方法的重载形式：

    join();    等待被join的线程执行完毕。

    join(long millis);    等待被join的线程的时间最长为millis毫秒，如果在millis毫秒内被join的线程还没结束，则不再等待。

    join(long millis,int nanos);    等待被join的线程的时间最长为millis毫秒加nanos毫微秒。这种很少使用：程序对时间的精度无须精确到毫微秒；计算机硬件、操作系统本身也无法精确到毫微秒。

二、后台线程

    一种后台运行的为其他线程提供服务的线程，被称为后台线程，又被称为守护线程或精灵线程。JVM的垃圾回收线程就是典型的后台线程。

    当所有的后台线程都死亡，后台程序会自动死亡。

    调用Thread对象的setDaemon(true)方法可以将指定线程设置为后台线程。

    代码样例：

/**
 * 用户线程（前台线程）
 **/
public class UserThread implements Runnable {
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("线程第" + i + "次执行！");
        }
        try {
            Thread.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程执行完毕！");
    }
}

/**
 * 后台线程单元测试
 **/
public class DaemonThreadTest {
    @Test
    public void testUserDaemonThread(){
        DaemonThread daemonThread = new DaemonThread();
        UserThread userThread = new UserThread();
        Thread t1 = new Thread(userThread);
        Thread t2 = new Thread(daemonThread);
        t2.setDaemon(true); //设置为守护线程
        t2.start();
        t1.start();
    }
}

    分析：

    单元测试开始，创建了两个线程对象t1和t2，在线程启动前，将t2设置为后台线程（守护线程），然后依次启动t1和t2。t1在执行时，t2也在执行。但是t1执行完不久后，t2就不再继续往下执行。是因为用户线程结束后，JVM会主动退出，后台线程也就结束了。

    Thread类还有一个方法：isDaemon()方法，用于判断指定线程是否为后台线程。

    并不是所有线程默认都是前台线程，有些线程默认是后台线程。前台线程创建的字线程默认是前台线程，后台线程创建的字线程默认是后台线程。

    前台线程死亡后，JVM会通知后台程序死亡，但从它接收指令到做出响应，需要一定时间。

    要将线程设置为后台线程，必须在该线程启动之前设置，否则会引发IllegalThreadStateException异常。

三、线程睡眠：sleep

    通过调用Thread类的静态方法sleep()方法，可以让当前正在执行的线程暂停一段时间，并进入阻塞状态。

    sleep()方法两种重载形式：

    static void sleep(long millis);    让当前正在执行的线程暂停millis毫秒，并进入阻塞状态。该方法受到系统计时器和线程调度器的精度与准确度的影响。

    static void sleep(long millis,int nanos);    让当前正在执行的线程暂停millis毫秒加nanos毫微秒，并进入阻塞状态，该方法会受到系统计时器和线程调度器的精度和准确度的影响。这种形式很少使用。

    当线程调用sleep()方法进入阻塞状态后，在其睡眠时间段内，该线程不会获得执行的机会。sleep()方法常用来暂停程序的执行。

    代码样例：

/**
 * 线程睡眠单元测试
 **/
public class SleepThreadTest {
    @Test
    public void test() throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            System.out.println("当前时间：" + new Date());
            Thread.sleep(1000);
       }
    }
}

    打印结果：

    

四、线程让步yield

    yield()方法和sleep()方法类似，可以让当前线程暂停，但是不会阻塞该线程，只是将线程转入就绪状态。

    yield()方法只是让当前线程暂停一下，让系统的线程调度器重新调度一次。完全可能的情况是：当某个线程调用了yield()方法暂停后，线程调度器又将其调度出来重新执行。

    当某个线程调用了yield()方法暂停后，只有优先级与之相同，或者比它高的处于就绪状态的线程才能获得执行的机会。

    //TODO

转载于:https://my.oschina.net/alexjava/blog/3009774