创建线程的方式有很多种，下面我们就最基本的两种方式进行说明。主要先介绍使用方式，再从源码角度进行解析。
- 继承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的类