多线程——Thread类

目录

 

1、Thread类的构造方法

public Thread();
public Thread(Runnable target);
public Thread(String name);
public Thread(ThreadGroup group, Runnable target);
public Thread(ThreadGroup group, String name);
public Thread(Runnable target, String name);
public Thread(ThreadGroup group, Runnable target, String name);
public Thread(ThreadGroup group, Runnable target, String name, long stackSize);

首先解释一下：

线程组ThreadGroup，参考文章：https://blog.csdn.net/dgh112233/article/details/88913429。

虚拟机栈大小stackSize参数，JVM的虚拟机栈是线程私有的，用于为线程的方法分配栈空间，这个stackSize参数就是用于为此线程明确指定栈空间的大小，如果超出，就会报栈溢出的错误，所以一般，我们不设置这个参数，让它默认为0，0表示让JVM忽略这个参数，按照JVM的标准来。                           

1、public Thread()方法：空参构造方法，创建的线程属于当前运行线程所属的线程组，创建的线程是extends Thread的方式，线程名字是“Thread-数字”形式，数字部分随着线程数量增加，会自动递增的，最后，stackSize参数是0。 

2、public Thread(Runnable target)方法：只是指定了线程对象（implements Runnable方法），其它的参数也是默认。

3、public Thread(String name)：指定线程名，其它的参数也是默认。

4、public Thread(ThreadGroup group, Runnable target)：指定线程组，线程对象，其它默认。

5、public Thread(ThreadGroup group, String name)：指定线程组，线程名，其它默认。

6、public Thread(Runnable target, String name)：指定线程对象，线程名，其它默认。

7、public Thread(ThreadGroup group, Runnable target, String name)：执行线程组，线程对象，线程名，其它默认。

8、public Thread(ThreadGroup group, Runnable target, String name, long stackSize)：执行线程组，线程对象，线程名，栈大小。

2、线程的6种状态

线程状态代表一个线程在生命周期中所处的状态或者阶段。

public class Thread implements Runnable {
    public enum State {
        //用new创建了之后，但是还未start运行
        NEW,
        //正在执行状态
        RUNNABLE,
        //阻塞状态
        BLOCKED,
        //等待线程状态
        WAITING,
        //具有指定等待时间的等待线程状态
        TIMED_WAITING,
        //线程执行执行结束状态
        TERMINATED;
    }

}

给个状态转换图，借用博主的图片：https://blog.csdn.net/PCCEO1/article/details/52444730

NEW状态：就是用new 创建了线程对象，但是还没有调用start()方法运行，此时处于NEW状态。

RUNNABLE状态：正在运行状态，即线程正在执行任务。

TIMED_WAITING状态：线程调用了sleep()方法，等待指定时间后再继续执行；

BLOCKED状态：比如线程访问了一个同步锁（这个锁正被其它线程占用），此时线程状态为阻塞状态，等待系统唤醒它；

WAITING状态：线程主动调用了Object.wait()方法，线程进入等待状态（睡眠），当再次用Object.notify()方法时，才会唤醒该线程，需注意： 要调用Object.wait()，必须先获取该对象的锁，然后执行Object.wait()后，该线程会进入睡眠状态，该对象的锁会被释放。等到调用Object.notify()的时候，也要先获取该对象的锁，然后才调用Object.notify()，唤醒线程，并释放该锁。

TERMINATED状态：终止状态，要么线程正常运行结束，要么就是执行return语句，或者抛出了没有捕获的异常，都会导致线程结束。

synchronized(Object){

    Object.wait();

}

synchronized(Object){

    Object.notify();

}

3、Thread类中常用的方法

public static void sleep(long millis)：睡眠多少毫秒后，继续执行。

public synchronized void start()：运行线程的启动方法。

public void interrupt()：详细说一下，这个方法只是改变一个线程的中断标志，仅此而已，线程的中断标志（true 或 false），true表示中断状态，false表示未中断状态，调用interrupt() 方法就是将中断标志设置为true，当一下线程正在正常运行的时候，是不会去检查这个中断标志的，只有当阻塞的时候，才会频繁去检查这个中断标志，wait()、join()、sleep() 方法都会使线程进入阻塞，如果阻塞期间，该线程调用了interrupt() 方法，那么检查到中断标志已经变为了true，此时出错了，因为本来我线程只是阻塞了，还没有终止呢，但是此时检查到线程已经处于中断状态，就要抛出异常，那么java虚拟机会将中断标志改为false，等抛出了异常，这个线程就算退出了。

public static boolean interrupted()：线程的这个方法是用于判断“当前线程”是否已经中断，实际就是检查“中断标志”，将中断标志返回。注意：这个方法调用一次后，会清理掉中断标志，比如，当前线程调用了interrupt() 方法，中断标志是true，此时又调用interrupted() 方法，返回值为true，但是接着又调用interrupted() 方法，这个方法返回值就是 false，因为第一个调用完了之后，就清理掉中断标志了（中断标志变为false）。

public boolean isInterrupted()：返回线程的中断标志。

public static Thread currentThread()：返回当前线程引用。

public final void join()：比如在线程B中，调用线程a.join()方法，即等待线程a执行完后，线程B才继续执行。其实这个join调用的也是join(0)方法。

public final synchronized void join(long millis)：和join()方法类似，不同之处在于，线程a执行完后，线程B可以继续执行，或者等待的时间到了，线程B也可以继续执行，时间参数为0的话，即表示不考虑时间，只考虑线程a是否执行完毕。

public State getState()：返回当前线程的状态。

public static void yield()：这个方法是让线程放弃cpu资源，但是放弃多久呢？不确定，只是让线程放弃当前占用的cpu资源，也许放弃了之后，立马又是此线程占用cpu。

public final void setPriority(int newPriority)：设置当前线程的优先级，默认是5级。

public final void setDaemon(boolean on)：设置当前线程是否为守护线程，默认不是守护线程。

3.1 未捕获异常处理器

线程的创建有三种方式：extends Thread,  implements Runnable, implements callable。

前两种的run()方法不允许抛出异常，只能在run方法内容用try——catch，我们不可能预料到所有的异常，难免会有异常抛出，但是又没有相应的捕获器，导致线程因为异常而终止。

最后一种callable的方式，可以允许抛出异常，即允许call() throw Exception这种方式，只是说可以将异常抛给上一级代码处理，上一级代码还得去捕获异常并处理，另外，线程还是会因为抛出异常而终止（除非用try——catch）。

现在可以理解为什么要用未捕获异常的处理器了，第一，避免在未预料到的异常发生时，我们没有采取合理的处理方式（比如没有存入日志）；第二，将异常的抛出和异常的处理解耦，代码结构更加清晰易懂。

1、为线程定义异常处理器（举例说明）

下面代码定义了一个线程，里面有个错误，就是数组访问越界。

public class ThreadOne extends Thread {
    @Override
    public void run() {
        super.run();
        int[] array = {5, 7, 12, 9};
        System.out.println("线程开始运行了");
        System.out.println(array[8]);
    }
}

下面代码定义了一个线程的未捕获异常处理器。

public class MyHandler implements Thread.UncaughtExceptionHandler {
    @Override
    public void uncaughtException(Thread t, Throwable e) {
        System.out.println("抛出异常的线程是：id = " + t.getId() + ", name = " + t.getName());
        System.out.println("异常的内容是：" + e.getClass().toString());
    }
}

测试一下

public static void main(String[] args){
        ThreadOne threadOne = new ThreadOne();
        threadOne.setUncaughtExceptionHandler(new MyHandler());
        threadOne.start();
}

控制台输出：

2、为整个线程组的所有线程都定义一个公共的未捕获异常处理器

这么做的原因：我们也许无法预料到所有可能发生的异常，但是对于这些异常，如果说只需要做简单的日志记录，那么就不必要为每一个线程都去定义处理器，直接为这个线程组定义一个未捕获异常处理器即可，这样整个组内的线程如果抛出了未捕获的异常，该处理器都会去处理异常（即日志记录）。

threadOne.setDefaultUncaughtExceptionHandler(new MyHandler());
//或者这样 Thread.setDefaultUncaughtExceptionHandler(new MyHandler());