java创建线程的两种方式及源码解析

创建线程的方式有很多种，下面我们就最基本的两种方式进行说明。主要先介绍使用方式，再从源码角度进行解析。

• 继承Thread类的方式
• 实现Runnable接口的方式

这两种方式是最基本的创建线程的方式，其实核心也就是Thread类，后面分析源码会讲到，下面先介绍使用方式。

一：继承Thread类的方式创建线程

---

1，创建线程步骤

• 创建一个子类继承于Thread类
• 子类重写Thread类的run方法，方法内实现子线程要完成的功能
• 创建一个子类的对象
• 调用子类对象的start()的方法，该方法有两个作用：启动此线程；调用重写的run方法。

代码如下：

package com.yefengyu.thread;

//1,创建一个子类继承于Thread类
public class SubThread extends Thread {

    //2,子类重写Thread类的run方法，方法内实现子线程要完成的功能
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("Thread ...." + i);
        }
    }
}

package com.yefengyu.thread;

public class TestThread {

    public static void main(String[] args) {
        //3,创建一个子类的对象。
        SubThread subThread = new SubThread();
        //4,调用线程的start()的方法。该方法有两个作用：启动此线程;调用响应的run方法。不能显示调用run方法，因为这样不能开启线程
        subThread.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("main ...." + i);
        }
    }
}

每次执行结果都不相同，这是因为多个线程都在获取cpu的执行权，cpu执行到谁，就执行谁。但是要明确一点，在某个时刻，单个cpu只能执行一个线程，cpu进行着快速切换，已达到看上去是并行执行的效果，这就是线程的一个特点：随机性，哪个线程抢到cpu资源，就执行该线程，至于执行多长时间，是cpu说了算。

main ....0
Thread ....0
Thread ....1
Thread ....2
main ....1
main ....2
main ....3
main ....4
Thread ....3
Thread ....4

2，设置与获取线程名称

由于默认的线程名称没有可读性，因此设置一个线程名称还是比较重要的，Thread类有个构造方法：

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

因此子类增加线程名称则比较简单：

package com.yefengyu.thread;

//1,创建一个子类继承于Thread类
public class SubThread extends Thread {

    //通过构造函数设置线程名称，当然使用set方法也可以
    public SubThread(String name) {
        super(name);
    }

    //2,子类重写Thread类的run方法，方法内实现子线程要完成的功能
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            //下面两种方法都会获取线程名称
            System.out.println(this.getName()+" ... " + i);
            System.out.println(Thread.currentThread().getName()+" *** " + i);
        }
    }
}

package com.yefengyu.thread;

public class TestThread {

    public static void main(String[] args) {
        //（3）创建一个子类的对象。
        SubThread subThread1 = new SubThread("my-thread11111");
        SubThread subThread2 = new SubThread("my-thread22222");
        //（4）调用线程的start()的方法。该方法有两个作用：启动此线程;调用响应的run方法。不能显示调用run方法，因为这样不能开启线程
        subThread1.start();
        subThread2.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("main ...." + i);
        }
    }
}

结果：

main ....0
my-thread22222 ... 0
my-thread11111 ... 0
my-thread22222 *** 0
my-thread22222 ... 1
my-thread22222 *** 1
main ....1
my-thread22222 ... 2
my-thread11111 *** 0
my-thread22222 *** 2
main ....2
main ....3
main ....4
my-thread22222 ... 3
my-thread11111 ... 1
my-thread11111 *** 1
my-thread11111 ... 2
my-thread22222 *** 3
my-thread22222 ... 4
my-thread22222 *** 4
my-thread11111 *** 2
my-thread11111 ... 3
my-thread11111 *** 3
my-thread11111 ... 4
my-thread11111 *** 4

3，实战：汽车票买票程序

假如车站有3张票，三个窗口，多线程如何卖票？

package com.yefengyu.thread;

public class SubThread extends Thread {

    //票的总数
    private int ticket = 3;

    public SubThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + "卖票 " + ticket--);
            }
        }
    }
}

package com.yefengyu.thread;

public class TestThread {

    public static void main(String[] args) {
        //三个线程模拟三个窗口同时卖票
        SubThread subThread1 = new SubThread("my-thread11111");
        SubThread subThread2 = new SubThread("my-thread22222");
        SubThread subThread3 = new SubThread("my-thread33333");
        subThread1.start();
        subThread2.start();
        subThread3.start();
    }
}

结果和我们想的大不相同，竟然每个线程都卖了3张票，一共卖了9张票，这是不可以忍受的。

my-thread11111卖票 3
my-thread11111卖票 2
my-thread11111卖票 1
my-thread33333卖票 3
my-thread22222卖票 3
my-thread33333卖票 2
my-thread22222卖票 2
my-thread33333卖票 1
my-thread22222卖票 1

修改1：使用静态变量：

//票的总数
private static int ticket = 3;

定义静态可以解决卖出多余票的情况，但是这种变量一般不定义静态的，因为静态属性生命周期太长。

修改2：new一个SubThread实例，多次启动

package com.yefengyu.thread;

public class TestThread {
    public static void main(String[] args) {
       //一个线程对象多次启动
       SubThread subThread1 = new SubThread("my-thread11111");
       subThread1.start();
       subThread1.start();
       subThread1.start();
    }
}

出现异常：

my-thread11111卖票 3Exception in thread "main"
my-thread11111卖票 2
my-thread11111卖票 1
java.lang.IllegalThreadStateException
    at java.lang.Thread.start(Thread.java:708)
    at com.yefengyu.thread.TestThread.main(TestThread.java:8)

源码这样说：线程不是NEW状态是不可以调用start方法的，调用会报异常，也就是一个线程启动之后不能再启动。关于线程状态后面博文会讲到。

/**
* A zero status value corresponds to state "NEW".
*/
if (threadStatus != 0)
    throw new IllegalThreadStateException();

如何解决卖票程序中的问题呢？使用Runnable接口。

二：实现Runnable接口的方式创建多线程

---

1，创建线程步骤

• 编写一个类实现Runnable接口

• 该类实现run方法
• 创建该类的对象
• 在创建 Thread 时作为一个参数来传递并启动

2，代码演示

package com.yefengyu.thread;

public class SubThread implements Runnable {

    //票的总数
    private int ticket = 3;

    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + "卖票 " + ticket--);
            }
        }
    }
}

package com.yefengyu.thread;

public class TestThread {
    public static void main(String[] args) {

        //创建该类的对象
       SubThread subThread = new SubThread();

        //在创建 Thread 时作为一个参数来传递并启动
       new Thread(subThread, "线程1").start();
       new Thread(subThread, "线程2").start();
       new Thread(subThread, "线程3").start();
    }
}

运行结果如下，是我们想要的结果。

线程1卖票 3
线程3卖票 2
线程2卖票 1

稍微研究一下，第一种继承Thread类的方式，new了3次SubThread实例，那么实例的变量ticket也有三个，线程分别拥有各自的ticket。而实现Runnable接口的方式，数据只存在与SubThread这个实例对象中，代码中只需new一次，因此只有一份ticket数据，而将持有这份数据的对象通过构造方法传入到多个线程中的时候，线程对象只是执行的载体，真实数据只有一份，因此Runnable接口的实现方式适合多个相同的程序代码的线程去处理同一个资源。

3，本节小总结

• 采用继承Thread类方式
• 优点：编写简单，如果需要访问当前线程，无需使用Thread.currentThread()方法，直接使用this，即可获得当前线程。

• 缺点：因为线程类已经继承了Thread类，所以不能再继承其他的父类
• 采用实现Runnable接口方式：
• 优点：线程类只是实现了Runable接口，还可以继承其他的类。可以多个线程共享同一个目标对象，所以非常适合多个相同线程来处理同一份资源的情况。

• 缺点：编程稍微复杂，如果需要访问当前线程，必须使用Thread.currentThread()方法。

三：源码分析

---

1，理论分析

多线程是java开发中必不可少的一项技术点，下面主要研究Thread类，通过分析该类了解多线程执行的过程，为以后的线程池等高级技术打下坚实基础。

当我们使用多线程进行开发的时候，最开始学习的例子就是使用Thread类。使用步骤如下，和上面演示的对比，简化了步骤：

• 编写一个类，继承Thread

• 重写run方法

• 通过调用start方法启动线程。

后来又有一种方法，实现Runnable接口，主要步骤如下：

• 编写一个类，实现Runnable 接口，重写run方法

• 将该类的对象传入Thread类中

• 通过调用start方法启动线程。

通过上面，我们来分析一下，线程执行离不开Thread类，最后都要使用start方法启动线程。我们可以想到start方法是一个入口方法，它可以做很多事。假如start方法做了如下的事情：

• do x

• do y

• do run

• do z

我们不关心x、y、z具体是什么，只要明白start方法是一个入口方法，它做了很多事情，但是在某一步，它调用了 run 方法。而run方法是我们必须实现的，也就是我们自己实现的逻辑在start里面被执行了。接着我们考虑下 run 方法，怎么样才能自己定义run方法，然后在run方法里面写自己的逻辑？

• 一种方法是，在Thread类里面，我们定义一个抽象方法 run，这个时候，必须有子类来实现。这是模板设计模式思想。

• 另一种方法是提供一个接口，并且接口中有个方法 run，Thread类持有这个接口(通过属性持有，再通过构造器传入)，并且Thread类也有个run方法（为啥也要有个run方法后面会提到），该run方法调用接口的run方法。此时只要编写一个类实现接口，重写run方法，并传入Thread类，那么Thread类在执行start方法的时候，会调用自身的run方法，该run方法又会调用接口实现的run方法，这是策略设计模式思想。

以上两种模式就是实现Thread类和实现Runnable接口的实现原理。需要注意的是，Thread类本身也实现了Runnable接口，那么Thread类本身拥有run方法则水到渠成。

2，源码分析

Runnable的源码很简单：

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

Thread类的属性非常多，我们暂时不管，注意有一个属性，它是对Runnable接口的引用。

private Runnable target;

有了属性，我们需要看如何传入这个属性值：

public Thread() {
     init(null, null, "Thread-" + nextThreadNum(), 0);
}

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

init方法内容很多，但是关于target变量，只有一句：

this.target = target;

因此可以判断，上面两个构造器，第一个没有给Runnable赋值，值为null，第二个通过参数进行赋值。

我们再看下Thread类：

public class Thread implements Runnable

Thread类实现了Runnable接口，因此必须实现run方法：

    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }

对于这个run方法，如果是使用继承Thread类重写run方法；那么这里面的内容将会被覆盖，如果是实现Runnable接口重写run方法，那么此处就会调用接口实现的run方法。这就让两种实现多线程的方式得以共存。

这个run方法何时调用？在start方法中：

public synchronized void start() {

        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {

            }
        }
    }

private native void start0();

注意start方法中的start0方法和最后一行start0方法。该start0方法是native方法，实质是调用run方法，此处暂时不做详解。

Thread类使用模板设计模式，模板方法是start，start方法里面的start0方法才能真正启动线程、调用了Thread类的run方法。

3，Runnable接口的好处：

• 适合多个相同的程序代码的线程去处理同一个资源

• 可以避免java中的单继承的限制
• 增加程序的健壮性，代码可以被多个线程共享，代码和数据独立
• 线程池只能放入实现Runable或callable类线程，不能直接放入继承Thread的类