线程常用的方法

Posted 2020-12-18 crabdumplings

线程的常用方法

1. start()
   • 启动当前线程
   • 调用当前线程的run()方法
2. run()
   • 通常需要重写Thread类中的此方法
   • 将创建的线程执行的操作声明在此方法中
3. currentThread()
   • 静态方法
   • 返回执行当前代码的线程
4. getName()
   • 获取当前线程的名字
5. setName()
   • 设置当前线程的名字
     • 还可以利用构造器给线程命名
6. yield()
   • 释放当前CPU的执行权，但是有可能该线程又抢到了CPU的执行权
7. join()
   • 在线程A中调用线程B的join()方法，此时线程A进入阻塞状态，直到线程B完全执行完以后，线程A才结束阻塞状态
8. sleep(long millitime)
   • 静态方法
   • 让当前线程睡眠指定的millitime毫秒，在指定的millitime时间内，当前线程是阻塞状态
   • 阻塞结束后，还要等待CPU给你分配资源
9. isAlive()
   • 判断当前线程是否存活
10. getPriority()
    • 用于检查线程的优先级

代码实现

class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 101; i++) {
            if (i % 2 == 0) {
                try {
                    //让当前线程睡眠指定的10毫秒，在指定的10时间内，当前线程是阻塞状态
                    sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                
                //Thread.currentThread().getName()：获取当前线程的名字
                //Thread.currentThread().getPriority()：获取线程的优先级
                System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getPriority() + i);
            }

            if (i % 20 == 0) {
                //释放当前CPU的执行权，但是有可能该线程又抢到了CPU的执行权
                yield();
            }
        }
    }

    //构造器，可以通过他来给线程命名
    public MyThread(String name) {
        super(name);
    }
}

public class Method {
    public static void main(String[] args) {
        //利用构造器给该线程命名
        MyThread m1 = new MyThread("Thread_1");
        //利用setName给该线程命名
        // m1.setName("Thread_1");

        //设置该线程的优先级
        m1.setPriority(Thread.MAX_PRIORITY);

        //启动当前线程
        m1.start();

        // 主线程命名
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
        Thread.currentThread().setName("主线程");

        for (int i = 0; i < 101; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getPriority() + i);
            }

            if (i == 20) {
                try {
                    //在线程A（主进程）中调用线程B（Thread_1）的join()方法，此时线程A进入阻塞状态，
                    //直到线程B完全执行完以后，线程A才结束阻塞状态
                    m1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        //判断当前线程是否存活
        System.out.println(m1.isAlive());
    }
}

代码分析

开始执行后

Thread_1线程优先级高于主线程

m1.start()，所以Thread_1线程开始执行

在Thread_1线程中，当i % 2 == 0 时，sleep(10);

代表该线程睡眠10毫秒，在这段时间中，Thread_1线程处于阻塞状态

另一个线程主线程得到了CPU资源，开始运行

当主线程的i = 20 时

m1.join()

代表在主线程中调用Thread_1的join()方法，此时主线程进入阻塞状态，直到Thread_1完全执行完以后，主线程才结束阻塞状态

所以开始运行Thread_1线程的内容，知道Thread_1线程结束

Thread_1线程结束后，主线程结束了阻塞状态，所以继续运行