【Java并发学习】之详解线程的点滴(1)

前言

在前面的几个小节中，我们粗略地学习了线程的基本概念，定义任务的方式，并且通过Java中的多线程API来驱动对应的任务，然后学习了线程的互斥与同步关系，线程之间进行资源共享后的同步操作等等一些简单的内容，可以说，线程中的主要内容我们已经掌握了，然而，也仅仅只是简单内容，很多比较细节、复杂的东西在之前我们刻意避开了，接下来的几个小节中，我们就来具体地学习线程的各个细节内容

线程的属性

线程有许多的属性，比如线程的ID、名字、优先级、状态等，接下来我们就来具体学习这些属性

线程的ID

每个线程都有对应的独一无二的ID，这些ID是由JVM在运行的时候为线程设置的，用于区分不同的线程，并且不对外提供设置线程ID的接口，也就是说，在Java中，我们仅能够获取多线程的ID，而不能设置线程的ID，访问代码如下

    class DetailTask implements Runnable{

        @Override
        public void run() {
            System.out.println("Details : " + Thread.currentThread().getId());
            // 其中Thread.currentThread()用于获取当前执行的线程
            // 通过thread.getId()则可以获取对应的线程的ID
        }
    }

线程的名字

在线程比较多的情况下，我们会倾向于根据执行不同任务的不同线程来为其设置名字，方便在日志以及其他场景中使用到，设置以及获取线程的名字操作具体如下

    class DetailTask implements Runnable{

        private static int cnt = 0;
        // 注意这里的代码是非线程安全的
        @Override
        public void run() {
            Thread.currentThread().setName("Thread " + cnt++); // 设置线程名字
            System.out.println("Details : " + Thread.currentThread().getName()); // 获取线程的名字
        }
    }

线程优先级

优先级是一个比较有价值的概念，在Java中，线程之间的调度采用的是基于时间片的轮转调度方式，其中在线程进行切换，重新调度时，调度的主要依据就是优先级，通常来说，优先级比较高的线程，被调度的可能性会比较大，也就是说，在单位时间内，优先级高的线程被调度的次数会大于优先级低的线程

不过，在设置线程的优先级的时候，需要注意一下几点

• 线程的有效优先级仅能为 0 - 10 之间的整数，其他数字则会抛出java.lang.IllegalArgumentException
• 由于不同的操作系统的优先级的范围不一致，而映射到0-10之间则会出现一些意想不到的惊喜，所以一般在设置优先级的时候，不能过分依赖于优先级，尽量只使用Thread.MAX_PRIORITY、Thread.MIN_PRIORITY以及默认的优先级，分别对应的数值为10,0,1
• 设置优先级仅仅仅能提高线程被调度的概率，也就是仅能提高线程被调度的次数，但是并不能保证执行次数一定会高，所以，不能仅依赖优先级来实现如同步、合作之类的操作
• 优先级的设置必须在线程启动之前设置，也就是必须在thread.start()方法执行之前进行设置，否则，会采用默认的优先级，言下之意即不能在run方法中进行优先级的设置

    for (int i = 0; i < 10; i++){
        Thread thread = new Thread(task);
        System.out.println("Priority " + thread.getPriority());
        if (i % 2 == 0){
            thread.setPriority(Thread.MIN_PRIORITY); // 设置优先级为最低
        }else {
            thread.setPriority(Thread.MAX_PRIORITY); // 设置优先级为最高
        }
        thread.start();
    }

线程的状态

通常来讲，线程的数量是多于CPU的数量，这也就意味着，为了保证每个线程都能得到执行，在特定时刻，总会有线程处于非运行状态，当然，Java中线程的状态不止这两种，具体如下

• NEW：新建状态，此时线程已经被赋予了任务，但需要注意的是，此时执行该线程所需要的资源仍未准备好，是不具备执行条件的，也就是在调用start()方法之前的状态
• RUNNABLE：可运行状态，表明此时该线程已经是处于可执行的状态，这里需要注意的是，可运行状态可以是该线程正在执行，也可能该线程的除了CPU之外的其他资源都已经准备完毕，只要分配给其CPU就能执行。注意是Runnable而不是Run
• BLOCKED：阻塞状态，线程如果处于该状态，则表明此时该线程正在等在某个锁的释放
• WAITING：等待状态，表明此时该线程正在等待某些其他线程的资源，通常是调用了Object.wait()、join()、LockSupport.park()这几个方法
• TIMED_WAITING：等待超时状态，同样是等待状态，只是多了个计时器，通常是调用了上面几个方法中带时间参数的重载方法
• TERMINATED：中断/结束状态，表明此时该线程已经处于执行完毕的状态或者是被其他线程或者JVM中断，结束其运行

关于这几个状态的详细介绍，可以参考JDK源码中的注释

    /* A thread can be in only one state at a given point in time.
     * These states are virtual machine states which do not reflect
     * any operating system thread states.
     *
     * @since   1.5
     * @see #getState
     */
    public enum State {
        /**
         * Thread state for a thread which has not yet started.
         */
        NEW,

        /**
         * Thread state for a runnable thread.  A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         */
        RUNNABLE,

        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         */
        BLOCKED,

        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * <ul>
         *   <li>{@link Object#wait() Object.wait} with no timeout</li>
         *   <li>{@link #join() Thread.join} with no timeout</li>
         *   <li>{@link LockSupport#park() LockSupport.park}</li>
         * </ul>
         *
         * <p>A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called <tt>Object.wait()</tt>
         * on an object is waiting for another thread to call
         * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
         * that object. A thread that has called <tt>Thread.join()</tt>
         * is waiting for a specified thread to terminate.
         */
        WAITING,

        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         */
        TIMED_WAITING,

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         */
        TERMINATED;
    }

守护线程

上面我们主要学习了线程的几个属性，ID、名字、优先级、状态等，接下来我们来学习一个新的概念，守护线程

守护线程是一类特殊的线程，主要的特点如下

• 被调度的频率较低
• 当当前系统中的所有非守护线程结束时，守护线程也会结束，而且不管正在执行什么任务

基于守护线程的特点，在使用的时候需要注意，不能在守护线程中做一些逻辑比较复杂的操作，不能做一些比较重要的操作

一个典型的使用守护线程的例子就是JVM中的垃圾回收器

    
    public static void main(String[] args) {
        Thread daemonTask = new Thread(new DaemonTask());
        daemonTask.setDaemon(true);// 设置为守护线程，这里同样需要注意，必须在线程启动之前进行设置
        daemonTask.start();
    }

    class DaemonTask implements Runnable{
        @Override
        public void run() {
            while (true){
                System.out.println("I'm Daemon thread");
            }
        }
    }

总结

本小计我们主要学习了线程的相关属性，包括了ID、名字、优先级、状态，以及守护线程的概念和设置守护线程的方法，线程中的异常处理，接下来我们将学习线程的中断以及线程的异常处理等等的内容