常用创建线程的两种方式（3）

概要

线程作为独立调度运行和分派的基本单位，很明显的一个特征便是可运行的。Runnable接口便是对可被调度运行进行了抽象声明。本章主要内容如下：

线程构造函数介绍
Thread和Runnable的区别与联系
创建线程示例

线程构造函数介绍

    /**
     * 无参构造函数，常用
     */
    public Thread() {
        init(null, null, "Thread-" + nextThreadNum(), 0);
    }

    /**
     * 需要参数Runnable对象构造函数，常用
     */
    public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }

    Thread(Runnable target, AccessControlContext acc) {
        init(null, target, "Thread-" + nextThreadNum(), 0, acc, false);
    }

    public Thread(ThreadGroup group, Runnable target) {
        init(group, target, "Thread-" + nextThreadNum(), 0);
    }

    /**
     * 线程名称，常用
     */
    public Thread(String name) {
        init(null, null, name, 0);
    }

    public Thread(ThreadGroup group, String name) {
        init(group, null, name, 0);
    }

    /**
     * 常用
     */
    public Thread(Runnable target, String name) {
        init(null, target, name, 0);
    }

创建线程的时候常用无参和设置线程名、设置Runnable对象及组合的方式。常见的有Thread()、Thread(Runnable target)、Thread(String name)和Thread(Runnable target, String name)，设置线程组的方式比较少见，除非真的有必要进行分组管理，系统启动的时候会设置系统线程组、main线程组。

线程init初始化方法

java.lang.Thread

    /**
     * Initializes a Thread.
     *
     * @param g 线程组
     * @param target 可被调度运行对象
     * @param name 线程名
     * @param stackSize 线程堆栈大小，0表示忽略
     * @param acc 线程内部访问控制
     * @param inheritThreadLocals 是否继承线程本地变量
     */
    private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc,
                      boolean inheritThreadLocals) {
        if (name == null) {
            throw new NullPointerException("name cannot be null");
        }
        //设置线程名称
        this.name = name;

        Thread parent = currentThread();
        //默认情况下jvm不开启安全管理器
        SecurityManager security = System.getSecurityManager();
        if (g == null) {
            /* Determine if it's an applet or not */

            /* If there is a security manager, ask the security manager
               what to do. */
            if (security != null) {
                g = security.getThreadGroup();
            }

            /* If the security doesn't have a strong opinion of the matter
               use the parent thread group. */
            if (g == null) {
                //不是通过设置线程组的方式创建线程，默认归属于父线程的线程组
                g = parent.getThreadGroup();
            }
        }

        /* checkAccess regardless of whether or not threadgroup is
           explicitly passed in. */
        g.checkAccess();

        /*
         * Do we have the required permissions?
         */
        if (security != null) {
            if (isCCLOverridden(getClass())) {
                security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
            }
        }

        g.addUnstarted();
        //线程组赋值
        this.group = g;
        //是否守护线程继承默认继承自父线程
        this.daemon = parent.isDaemon();
        //线程优先级，也是继承自父线程，默认为5
        this.priority = parent.getPriority();
        //线程对应类加载器
        if (security == null || isCCLOverridden(parent.getClass()))
            this.contextClassLoader = parent.getContextClassLoader();
        else
            this.contextClassLoader = parent.contextClassLoader;
        this.inheritedAccessControlContext =
                acc != null ? acc : AccessController.getContext();
        //Runnable实例，相当于要运行的task
        this.target = target;
        setPriority(priority);
        //继承父线程inheritThreadLocals
        if (inheritThreadLocals && parent.inheritableThreadLocals != null)
            this.inheritableThreadLocals =
                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
        /* Stash the specified stack size in case the VM cares */
        this.stackSize = stackSize;

        /* Set thread ID */
        tid = nextThreadID();
    }

除了安全管理器的访问检查稍微陌生（自行baidu、google），线程初始化相对比较简单，做了线程相关属性的初始化操作。

Thread和Runnable的区别与联系

Runnable是接口，用于声明Runnable实例是可以被线程调度运行的，只定义了一个run()方法：

public interface Runnable {
    public abstract void run();
}

可以通过public Thread(Runnable target)、public Thread(Runnable target, String name)构造函数进行创建线程。
Thread是类，实现了Runnable接口，这也说明了线程是可以被独立调度运行和分派的。

public class Thread implements Runnable {
    ...

    /**
     * 实现Runnable，线程CPU被调度后代码执行入口
     */
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }

    ...
}

从代码上看，直接通过无参构造函数创建线程并启动，实际上run()就相当于一个空方法。因此，如果不以Runnable实例创建线程，则应该通过继承Thread类覆盖run()方法的方式创建线程。接下来是常见的创建线程的两种方式。

创建线程示例

继承Thread类覆盖run()方法的方式

public class Hello extends Thread {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " Hello word !");
    }
}
//调用
public class ThreadCreate {
    public static void main(String[] args) {
        //启动三个线程
        for (int i = 0; i < 3; i++) {
            //一定要注意的是调用start()方法启动线程，而非调用run()方法
            new Hello().start();
        }
    }
}

运行结果：

Thread-0 Hello word !
Thread-2 Hello word !
Thread-1 Hello word !

实现Runnable方式创建线程
上边的代码修改为实现Runnable方式:

public static class Hello implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " Hello word !");
    }
}

public class ThreadCreate {
    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            new Thread(new Hello()).start();
        }
    }
}