Java基础-线程-线程的方法

Java工程师知识树 / Java基础

---

Thread类的public方法

Thread Thread.currentThread() ：获得当前线程的引用。获得当前线程后对其进行操作。与this是有区别的。
Thread.UncaughtExceptionHandler getDefaultUncaughtExceptionHandler() ：返回线程由于未捕获到异常而突然终止时调用的默认处理程序。
int Thread.activeCount()：当前线程所在线程组中活动线程的数目。
void dumpStack() ：将当前线程的堆栈跟踪打印至标准错误流。
int enumerate(Thread[] tarray) ：将当前线程的线程组及其子组中的每一个活动线程复制到指定的数组中。
Map<Thread,StackTraceElement[]> getAllStackTraces() ：返回所有活动线程的堆栈跟踪的一个映射。
boolean holdsLock(Object obj) ：当且仅当当前线程在指定的对象上保持监视器锁时，才返回 true。
boolean interrupted() ：测试当前线程是否已经中断。
void setDefaultUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh) ：设置当线程由于未捕获到异常而突然终止，并且没有为该线程定义其他处理程序时所调用的默认处理程序。
void sleep(long millis) ：休眠指定时间
void sleep(long millis, int nanos) ：休眠指定时间
void yield() ：暂停当前正在执行的线程对象，并执行其他线程。意义不太大
void checkAccess() ：判定当前运行的线程是否有权修改该线程。
ClassLoader getContextClassLoader() ：返回该线程的上下文 ClassLoader。
long getId() ：返回该线程的标识符。
String getName() ：返回该线程的名称。
int getPriority() ：返回线程的优先级。
StackTraceElement[] getStackTrace() ：返回一个表示该线程堆栈转储的堆栈跟踪元素数组。
Thread.State getState() ：返回该线程的状态。
ThreadGroup getThreadGroup() ：返回该线程所属的线程组。
Thread.UncaughtExceptionHandler getUncaughtExceptionHandler() ：返回该线程由于未捕获到异常而突然终止时调用的处理程序。
void interrupt() ：中断线程。
boolean isAlive() ：测试线程是否处于活动状态。
boolean isDaemon() ：测试该线程是否为守护线程。
boolean isInterrupted()：测试线程是否已经中断。
void join() ：等待该线程终止。
void join(long millis) ：等待该线程终止的时间最长为 millis 毫秒。
void join(long millis, int nanos) ：等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。
void run() ：线程启动后执行的方法。
void setContextClassLoader(ClassLoader cl) ：设置该线程的上下文 ClassLoader。
void setDaemon(boolean on) ：将该线程标记为守护线程或用户线程。
void start()：使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
String toString()：返回该线程的字符串表示形式，包括线程名称、优先级和线程组。

常用静态方法

currentThread() ：返回对当前正在执行的线程对象的引用。 调用方式Thread.currentThread()。
sleep(long millis) ：使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行），具体取决于系统定时器和调度程序的精度和准确性。Thread.sleep(10)
yield() ：对调度程序的一个暗示，即当前线程愿意产生当前使用的处理器。 Thread.yield()
setDefaultUncaughtExceptionHandler()：设置当线程由于未捕获到异常而突然终止，并且没有为该线程定义其他处理程序时所调用的默认处理程序。Thread.setDefaultUncaughtExceptionHandler(new ThreadUncaughtExceptionHandler())

常用成员方法

start() ：导致此线程开始执行; Java虚拟机调用此线程的run方法。 Thread类成员方法
join() ：等待这个线程死亡。 Thread类成员方法
interrupt()：中断这个线程。Thread类成员方法
wait()：导致当前线程等待，直到另一个线程调用该对象的notify()方法或notifyAll()方法。Object类方法。
notify()：唤醒正在等待对象监视器的单个线程。Object类方法。
notifyAll()：唤醒正在等待对象监视器的所有线程。Object类方法。

当前线程

public static void main(String[] args) {

    Thread thread = new Thread(() -> System.out.println(Thread.currentThread().getName()));//thread
    thread.start();
    System.out.println(Thread.currentThread().getName());//主线程

    new Thread(() -> System.out.println(Thread.currentThread().getName()),"自定义线程").start();// 自定义线程
}

线程的静态方法

sleep

静态方法sleep(long millis)线程休眠，可由Runnable状态转为Timed_waiting状态

线程状态

package com.thread.study;

import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateUtil;

import java.util.Date;

public class ThreadMethod {

    public static void main(String[] args) {

        new Thread(() -> {
            System.out.println("正在运行的线程名称：" + Thread.currentThread().getName() + " 开始时间=" + DateUtil.format(new Date(), DatePattern.NORM_DATETIME_MS_PATTERN));
            try {
                Thread.sleep(2000);    //"张三"延时2秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("正在运行的线程名称：" + Thread.currentThread().getName() + " 结束时间=" + DateUtil.format(new Date(), DatePattern.NORM_DATETIME_MS_PATTERN));
        }, "张三").start();

        try {
            Thread.sleep(2000);// 主线程延时2秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            System.out.println("正在运行的线程名称：" + Thread.currentThread().getName() + " 开始时间=" + DateUtil.format(new Date(), DatePattern.NORM_DATETIME_MS_PATTERN));
            try {
                Thread.sleep(2000);    //"李四"延时2秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("正在运行的线程名称：" + Thread.currentThread().getName() + " 结束时间=" + DateUtil.format(new Date(), DatePattern.NORM_DATETIME_MS_PATTERN));
        }, "李四").start();

        System.out.println("正在运行的线程名称：" + Thread.currentThread().getName() + " 结束时间=" + DateUtil.format(new Date(), DatePattern.NORM_DATETIME_MS_PATTERN));
    }

}
//执行结果
正在运行的线程名称：张三 开始时间=2021-01-22 20:54:43.289
正在运行的线程名称：main 结束时间=2021-01-22 20:54:45.287
正在运行的线程名称：李四 开始时间=2021-01-22 20:54:45.287
正在运行的线程名称：张三 结束时间=2021-01-22 20:54:45.407
正在运行的线程名称：李四 结束时间=2021-01-22 20:54:47.288

静态方法sleep(long millis)目的就是让线程休眠，并且这个操作其实是没有释放锁的。

常用场景：1.模拟网络延时；2.计时器

public static void main(String[] args) {
    //模拟网络延时
    new Thread(() -> {
        System.out.println("正在运行的线程名称：" + Thread.currentThread().getName() + " 开始时间=" + DateUtil.format(new Date(), DatePattern.NORM_DATETIME_MS_PATTERN));
        try {
            Thread.sleep(2000);    //"张三"延时2秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("正在运行的线程名称：" + Thread.currentThread().getName() + " 结束时间=" + DateUtil.format(new Date(), DatePattern.NORM_DATETIME_MS_PATTERN));
    }, "张三").start();

    try {
        Thread.sleep(2000);// 主线程延时2秒
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    
    // 计时器
    new Thread(() -> {
        while (true) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("当前时间为："+ DateUtil.format(new Date(), DatePattern.NORM_DATETIME_PATTERN));
        }

    }, "秒表").start();
}

TimeUnit类与sleep()

TimeUnit是java.util.concurrent包下面的一个类，TimeUnit提供了可读性更好的与时间有关的一些方法。

TimeUnit常用于替代Thread.sleep(时间段)

//对比
Thread.sleep(2000);    //"张三"延时2秒
TimeUnit.SECONDS.sleep(2);   //"张三"延时2秒
Thread.sleep(1000);  //计时器
TimeUnit.SECONDS.sleep(1);  //计时器

yield

静态方法yield()线程礼让，可由Runnable状态中的Running转为Ready状态

线程状态

静态方法yield()用于暂停当前正在执行的线程，让其他线程执行。但是不一定有效果，因为让出后，让步的线程可能再次被CPU调度分给这个线程。

package com.thread.study;

public class ThreadMethod {

    public static void main(String[] args) {
        MethodRunnable methodRunnable = new MethodRunnable(false);
        Thread t1 = new Thread(methodRunnable, "张三");
        MethodRunnable importantRunnable = new MethodRunnable(true);
        Thread t2 = new Thread(importantRunnable, "李四");

        t1.start();
        t2.start();

        System.out.println(Thread.currentThread().getName() + "运行结束！");
    }
}

class MethodRunnable implements Runnable{
    private boolean importantFlag;

    public MethodRunnable(boolean importantFlag) {
        this.importantFlag = importantFlag;
    }

    @Override
    public void run() {
        System.out.println("正在运行的线程名称：" + Thread.currentThread().getName() );
        if (!importantFlag) { // 不重要的业务礼让一下
            System.out.println(Thread.currentThread().getName() + "礼让了！" );
            Thread.yield();//暂停当前正在执行的线程，让其他线程执行
        }
        System.out.println(Thread.currentThread().getName() + "运行结束！");
    }
}
//执行结果 大部分时候是真的礼让了
main运行结束！
正在运行的线程名称：张三
张三礼让了！
正在运行的线程名称：李四
李四运行结束！
张三运行结束！

线程的成员方法

join

join() ：只有等待调用join方法的线程死亡。join主要用于阻塞其他线程，待此线程执行完后，再执行其他线程。 Thread类成员方法，可由Runnable状态中的Running转为Timed_waiting状态或者waiting状态

线程状态

package com.thread.study;

public class ThreadMethod {

    public static void main(String[] args) {
        MethodRunnable methodRunnable = new MethodRunnable();
        Thread t1 = new Thread(methodRunnable, "张三");
        t1.start();
        for (int i = 0; i < 10; i++) {
            if (i == 5) {
                try {
                    t1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.print(Thread.currentThread().getName() +":"+ i +";");
        }
        System.out.println(Thread.currentThread().getName() + "运行结束！");
    }
}

class MethodRunnable implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.print(Thread.currentThread().getName() +":"+ i +";");
        }
        System.out.println(Thread.currentThread().getName() + "运行结束！");
    }
}
//打印结果  张三线程执行完后，再执行main线程
main:0;main:1;main:2;main:3;main:4;张三:0;张三:1;张三:2;张三:3;张三:4;张三:5;张三:6;张三:7;张三:8;张三:9;张三运行结束！
main:5;main:6;main:7;main:8;main:9;main运行结束！

wait/notify

wait()：导致当前线程等待，直到另一个线程调用该对象的notify()方法或notifyAll()方法。Object类方法。notify()：唤醒正在等待对象监视器的单个线程。Object类方法。

进行线程的等待和唤醒操作不建议使用Object的wait/notify ，推荐使用Condition 。
Condition 是JUC下的包。

// 创建 Condition 对象
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();

Object的wait/notify或者Condition ，常用场景为：生产者与消费者模型。

可由Runnable状态中的Running转为Timed_waiting状态或者waiting状态

线程状态

线程通讯方法wait/notify与Condition