3、线程的调度

最新推荐文章于 2024-11-02 18:08:32 发布

原创最新推荐文章于 2024-11-02 18:08:32 发布 · 479 阅读

0 ·

CC 4.0 BY-SA版权

java多线程专栏收录该内容

8 篇文章

订阅专栏

本文详细介绍了Java中线程控制的几种方式，包括线程睡眠、线程让步、线程等待以及线程加入等核心概念和技术实现细节。通过具体示例展示了如何使用这些方法来协调线程间的执行顺序。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1. 线程睡眠

Thread.sleep(long millis)方法，使线程转到阻塞状态。millis参数设定睡眠的时间，以毫秒为单位。当睡眠结束后，就转为就绪（Runnable）状态。

sleep()使当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会执行；

由于sleep()方法是Thread类的方法，因此它不能改变对象的机锁。所以当在一个Synchronized方法中调用sleep（）时，线程虽然休眠了，但是对象的机锁没有被释放，其他线程仍然无法访问这个对象。sleep()方法不需要在同步的代码块中执行。但是sleep()可以通过interrupt()方法打断线程的暂停状态，从而使线程立刻抛出InterruptedException。

2. 线程让步

yield()的作用是让步。它能让当前线程由“运行状态”进入到“就绪状态”，从而让其它具有相同优先级的等待线程获取执行权；但是，并不能保证在当前线程调用yield()之后，其它具有相同优先级的线程就一定能获得执行权；也有可能是当前线程又进入到“运行状态”继续运行！

调用yield方法并不会让线程进入阻塞状态，yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。

yield()方法对应了如下操作：先检测当前是否有相同优先级的线程处于同可运行状态，如有，则把 CPU 的占有权交给此线程，否则继续运行原来的线程。所以yield()方法称为”退让”,它把运行机会让给了同等优先级的其他线程。

public class YieldTest {  
    public static void main(String[] args) throws InterruptedException {  
        // 创建线程对象  
        YieldThread t1 = new YieldThread("t1");  
        YieldThread t2 = new YieldThread("t2");  
        // 启动线程  
        t1.start();  
        t2.start();  
        // 主线程休眠100毫秒  
        Thread.sleep(100);  
        // 终止线程  
        t1.interrupt();  
        t2.interrupt();  
    }  
}  
class YieldThread extends Thread {  
    int i = 0;  
    public YieldThread(String name) {  
        super(name);  
    }  
    public void run() {  
        while(!isInterrupted()) {  
            System.out.println(getName() + "执行了" + ++i + "次");  
            if(i % 10 == 0) {// 当i能对10整除时，则让步  
                Thread.yield();  
            }  
        }  
    }  
}

在i%10==0的时候2个线程会重写竞争执行quan

sleep和yield区别

sleep()方法会给其他线程运行的机会，而不考虑其他线程的优先级，因此会给较低线程一个运行的机会;yield()方法只会给相同优先级或者更高优先级的线程一个运行的机会。
当线程执行了sleep(long millis)方法后，将转到阻塞状态，参数millis指定睡眠时间;当线程执行了yield()方法后，将转到就绪状态。
sleep()方法声明抛出InterruptedException异常，而yield()方法没有声明抛出任何异常
sleep()方法比yield()方法具有更好的移植性

3. 线程等待 wait()

wait()方法：当缓冲区已满/空时，生产者/消费者线程停止自己的执行，放弃锁，使自己处于等等状态，让其他线程执行。

notify()方法：当生产者/消费者向缓冲区放入/取出一个产品时，向其他等待的线程发出可执行的通知，同时放弃锁，使自己处于等待状态。

仓库

package com.lf.collection;

import java.util.LinkedList;

/**
 * @author LF
 * @date 2017/11/18 16:38
 * @description
 */
public class Storage {
    /**
     * 仓库最多能存放多少产品
     */
    private  final int maxNum = 5000;

    /**
     * 仓库存储的载体
     */
    private final LinkedList<Object> list =  new LinkedList<Object>();

    /**
     * 生产产品
     */
    public void product(int num) {
        synchronized (list) {
            while (list.size() + num > maxNum) {
                System.out.println("【要生产的产品数量】:" + num + "/t【库存量】:"
                    + list.size() + "/t暂时不能执行生产任务!");
                try {
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        for (int i = 0; i < num; i++) {
            list.add("产品");
        }
        System.out.println("【已经生产产品数】:" + num + "/t【现仓储量为】:" + list.size());
        list.notifyAll();
        }
    }

    public void consume(int num) {
        synchronized (list) {
            while (list.size() < num) {
                System.out.println("【要消费的产品数量】:" + num + "/t【库存量】:"
                    + list.size() + "/t暂时不能执行生产任务!");
                try {
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            for (int i = 1; i <= num; ++i) {
                list.remove();
            }

            System.out.println("【已经消费产品数】:" + num + "/t【现仓储量为】:" + list.size());

            list.notifyAll();
        }
    }

    public int getMaxNum() {
        return maxNum;
    }

    public LinkedList<Object> getList() {
        return list;
    }
}

生产者

package com.lf.collection;

/**
 * @author LF
 * @date 2017/11/18 18:52
 * @description
 */
public class Produce extends Thread {
    private Storage storage;

    public Produce(String name, Storage storage) {
        this.storage = storage;
    }

    @Override
    public void run() {
        while (true) {
            storage.product(100);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

消费者

package com.lf.collection;

/**
 * @author LF
 * @date 2017/11/18 16:22
 * @description
 */
public class Consumer extends Thread {
    private Storage storage;

    public Consumer(String name, Storage storage) {
        this.storage = storage;
    }

    @Override
    public void run() {
        while (true){
        storage.consume(10);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

测试类

package com.lf.collection;

/**
 * @author LF
 * @description
 * @date 2017/11/18 19:41
 */
public class CommunicationTest {
    public static void main(String[] args) {
        Storage storage = new Storage();
        Produce produce = new Produce("生产者", storage);
        produce.start();
       new Consumer("消费者", storage).start();
    }
}

4. 线程加入 join()

t.join()方法阻塞调用此方法的线程(calling thread)，直到线程t完成，此线程再继续；通常用于在main()主线程内，等待其它线程完成再结束main()主线程。

public class JoinTest {  
    public static void main(String[] args) throws InterruptedException {  
        JoinThread t1 = new JoinThread("t1");  
        JoinThread t2 = new JoinThread("t2");  
        t1.start();  
        t2.start();  
        t1.join();  
        t2.join();  
        System.out.println("主线程开始执行！");  
    }  
}  
class JoinThread extends Thread {  
    public JoinThread(String name) {  
        super(name);  
    }  
    public void run() {  
        for(int i = 1; i <= 10; i++)  
            System.out.println(getName() + getId() + "执行了" + i + "次");  
    }  
}