多线程-线程的停止、休眠、礼让和强制执行

一、线程停止（stop）

在Java中有3种方法可以停止正在运行的线程:

• 使用退出标志使线程正常终止，也就是当run方法完成后线程终止。
• 使用stop方法强行终止线程，但是不推荐使用这个方法，因为stop和suspend、resume一样，都是过期作废的方法。
• 使用interrupt方法中断线程

使用标志位停止线程

/**
 * 使用状态标记来停止线程
 */
public class TestThreadDemo01 implements Runnable{
    public static void main(String[] args) throws Exception {
        TestThreadDemo01 threadDemo01 = new TestThreadDemo01();
        new Thread(threadDemo01).start();
        for (int i=0;i<1000;i++){
            System.out.println("主线程"+i);
            if (i==900){
                threadDemo01.stop();
                System.out.println("线程停止了！");
                break;
            }
        }
    }

    //状态标记
    private boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println("线程！" + (i++));
        }
    }

    public void stop(){
        this.flag = false;
    }

}

执行结果如下：

一、线程休眠

• 总结：

  • sleep（时间）指定当前线程阻塞的毫秒数；
  • sleep存在异常InterruptedException
  • sleep时间到达后线程进入就绪状态
  • sleep可以模拟网络延时，倒计时等。
  • 每一个对象都有一个锁，sleep不会释放锁

• 代码案例：

/**
 * 线程休眠 sleep
 */
public class TestThreadSleep implements Runnable{
    public static void main(String[] args) {
        TestThreadSleep th1 = new TestThreadSleep();
        new Thread(th1).start();
    }

    @Override
    public void run() {
        //模拟倒计时
        for (int i=10;i>0;i--){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(i);
        }

    }
}

• 执行结果如下：

一、线程礼让

• 礼让线程，让当前正在执行的线程暂停，但不阻塞

• 将线程从运行状态转为就绪状态

• 让cpu重新调度，礼让不一定成功！看CPU心情。

• 代码案例：

/**
 * 线程礼让
 */
public class TestThreadComity implements Runnable{
    public static void main(String[] args) {
        TestThreadComity th = new TestThreadComity();
        new Thread(th,"线程1").start();
        new Thread(th,"线程2").start();
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"开始执行！");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"结束执行！");
    }
}

• 执行结果如下：

一、线程强制执行

• join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞
• 相当于插队
• 代码案例：

/**
 * 线程强制执行---插队
 */
public class TestThreadJoin implements Runnable {

    public static void main(String[] args) throws Exception {
        Thread thread = new Thread(new TestThreadJoin());
        for (int i = 0; i < 400; i++) {
            System.out.println("主线程在排队！！！" + i);
            if (i == 100) {
                thread.start();
                thread.join();

            }
        }
    }

    @Override
    public void run () {
        for (int i = 0; i < 100; i++) {
            System.out.println("VIP线程来插队了！！！" + i);
        }
    }
}

• 执行结果如下：等待插队线程执行完，才继续执行主线程！