线程的停止、休眠、礼让和强制执行 | Java多线程（三）

这是我参与更文挑战的第27天，活动详情查看： 更文挑战

---

相关文章

Java多线程汇总：Java多线程

---

前言

静态代理属于设计模式中的代理模式。反之则有动态代理，本篇文章不展开讲，有兴趣的可自行谷歌研究研究。 其实继承Thread也属于静态代理的一种，所以在这里学习静态代理有助于我们学习多线程。

一、静态代理

• 实际案例：买房

  • 买房人 我
  • 买房办理人 中介
  • 共同的行为 买房

• 代码实现案例：

class MyI implements BuyHouse {

    //对我来说，我只需负责拿钱，签字即可
    @Override
    public void Buy() {
        System.out.println("一百万，签合同，房子是我的了！");
    }
}

class Agent implements BuyHouse{
    private BuyHouse buyHouse;
    
    public Agent(BuyHouse buyHouse){
        this.buyHouse = buyHouse;
    }

    //先帮我准备合同等材料
    public void work1(){
        System.out.println("准备合同等材料~");
    }
    //带我去房管局办理手续
    public void work2(){
        System.out.println("带着客户去办手续~");
    }

    //中介收了我的钱，他得帮我准备购房材料，带着我跑购房流程等等
    @Override
    public void Buy() {
        work1();
        work2();
        //客户买房
        buyHouse.Buy();
    }
}

• 执行结果如下：

• 结论：
  • 本质上还是相当于把业务分开，降低程序的耦合性，不管是中介还是我，最终的目的都是买房，我只关注于买房的业务，其他业务无需管，而中介需要准备材料，准备合同，带我去房管局等一系列流程。

二、线程停止（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（时间）指定当前线程阻塞的毫秒数；
  • 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);
        }

    }
}

• 执行结果如下：

四、线程礼让（yield）

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

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

• 让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）

• 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);
        }
    }
}

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

---

路漫漫其修远兮，吾必将上下求索~

如果你认为i博主写的不错！写作不易，请点赞、关注、评论给博主一个鼓励吧~hahah