线程的创建和启动

继承Thread类创建线程类

通过继承Thread类来创建并启动多线程的步骤：

（1）定义Thread类的子类，并重写这个类的run()方法，该run()方法的方法体代表了线程需要完成的任务。因此把run()方法称为线程的执行体。

（2）创建Thread子类的实例，即创建线程对象。

（3）调用线程对象的start()方法来启动线程。

线程类：

package com.hadoop.java;

public class MyThread extends Thread{
	private String name;
	public MyThread(String name){
		this.name= name;
	}
	@Override
	public void run(){
		for(int i = 0; i < 100; i++){
			System.out.println(name+"...i="+i);
		}
	}
}

测试类：

package com.hadoop.java;

public class MyThreadTest {

	public static void main(String[] args) {
		MyThread t1 = new MyThread("线程A");
		MyThread t2 = new MyThread("线程B");
		t1.start();
		t2.start();
	}

}

运行结果：

线程A...i=80
线程A...i=81
线程A...i=82
线程A...i=83
线程A...i=84
线程A...i=85
线程A...i=86
线程A...i=87
线程A...i=88
线程A...i=89
线程A...i=90
线程A...i=91
线程A...i=92
线程A...i=93
线程A...i=94
线程A...i=95
线程A...i=96
线程A...i=97
线程A...i=98
线程A...i=99

每次运行的结果都不一样，两条线程在快速的轮换执行。

实现Runnable接口创建线程类

实现Runnable接口来创建并启动线程的步骤：

（1）定义Runnable接口的实现类，并重写Runnable接口的run()方法，这个run()方法的方法体同样是线程的执行体。

（2）创建Runnable实现类的实例，并以此实例作为Thread类的target来创建Thread对象，这个Thread对象才是真正的线程对象。

（3）调用线程对象的start()方法来启动线程。

线程类：

package com.hadoop.java;

public class MyThread1 implements Runnable{
	private String name;
	public MyThread1(String name){
		this.name = name;
	}
	@Override
	public void run(){
		for(int i = 0; i < 100; i++){
			System.out.println(name+"...i="+i);
		}
	}
}

测试类：

package com.hadoop.java;

public class MyThreadTest {

	public static void main(String[] args) {
		MyThread1 mt1 = new MyThread1("线程A");
		MyThread1 mt2 = new MyThread1("线程B");
		Thread t1 = new Thread(mt1);
		Thread t2 = new Thread(mt2);
		t1.start();
		t2.start();
	}

}

运行结果：

线程B...i=42
线程B...i=43
线程B...i=44
线程B...i=45
线程B...i=46
线程B...i=47
线程B...i=48
线程B...i=49
线程B...i=50
线程B...i=51
线程B...i=52
线程B...i=53
线程B...i=54
线程B...i=55
线程B...i=56
线程B...i=57
线程B...i=58
线程B...i=59
线程B...i=60
线程B...i=61
线程B...i=62
线程B...i=63
线程B...i=64
线程B...i=65
线程B...i=66
线程B...i=67
线程B...i=68
线程B...i=69
线程B...i=70
线程B...i=71
线程B...i=72
线程B...i=73
线程B...i=74
线程B...i=75
线程B...i=76
线程B...i=77
线程B...i=78

以上两种实现方式，都必须依靠Thread类才能启动线程。

使用实现Runnable接口的方式，还可以实现资源共享。可以通过一个卖票的例子进行说明：如果有3个售票点同时卖票，可以使用实现Runnable接口的方式让3个售票点共享同一个票数资源。

线程代码：

package com.hadoop.java;

public class TicketThread implements Runnable{
	private int tickets = 5;
	@Override
	public void run(){
		for(int i = 0; i < 100; i++){
			if(tickets > 0){
				System.out.println("selling ticket "+tickets--);
			}
		}
	}
}

测试类：

package com.hadoop.java;

public class MyThreadTest {

	public static void main(String[] args) {
		TicketThread tt = new TicketThread();
		Thread t1 = new Thread(tt);
		Thread t2 = new Thread(tt);
		Thread t3 = new Thread(tt);
		t1.start();
		t2.start();
		t3.start();
	}

}

运行结果之一：

selling ticket 5
selling ticket 3
selling ticket 2
selling ticket 1
selling ticket 4

这是其中的一个执行结果，但是也有可能出现一些不正确的结果，但是，这个例子中的3个线程是共享tt的，所以它们的票数也是共享的。

继承Thread类和实现Runnable接口创建线程的方式对比

通过继承Thread类或实现Runnable接口都可以实现多线程。

使用实现Runnable接口的方式创建多线程

优势：线程类只是实现了Runnable接口，那么它还可以继承其他两类。在这种方式下，多个线程可以共享同一个target对象，所以适合多个相同线程类处理同一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。

劣势：但是使用这种方式，编程会有点复杂，如果需要访问当前线程的时候，则必须使用Thread.currentThread()。

使用继承Thread类的方式创建多线程

劣势：因为线程类已经继承了Thread类，就不能再继承其它父类了。

优势：编写简单，如果需要访问当前线程，直接使用this就可以了。

所以，在开发的时候，一般采用实现Runnable接口的方式来创建多线程。

线程的生命周期

线程是具有生命周期的，线程的生命周期一般包括5中状态，即新建、就绪、运行、阻塞、死亡。当线程启动后，它不可能一直“霸占”着CPU独自运行，所有CPU需要在多条线程之间切换，所以线程的状态也会多次在运行、阻塞之间切换。

线程状态的转移和方法间的关系如图所示：

新建状态:

当程序使用new关键字创建了一下线程之后，这个线程就处于新建状态，此时，它和其他的Java对象一样，仅仅有Java虚拟机为其分配内存，并初始化成员变量的值。这个时候的线程对象，没有表现出线程的任何动态的特征，程序也不会执行线程的线程执行体。

就绪状态:

当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。

运行状态:

如果处于就绪状态的线程获取 CPU 资源，就开始执行 run()方法了，此时线程便处于运行状态。如果计算机只有一个CPU，那么任何时刻只有一个线程处于运行状态。当然，在一个多处理器的机器上，将会有多个线程并行（并行才是同时执行）；当线程数大于处理器数的时候，依然会存在多个线程在同一个CPU上轮换的现象。

阻塞状态:

一个正在执行的线程在某些特殊的情况下，如被人为挂起或需要执行耗时的输入输出的时候，会将CPU让出并且暂时中止自己的执行，进入到阻塞状态。

死亡状态:

当线程调用stop()方法或run()方法执行结束后，线程就处于死亡状态。处于死亡状态的线程不具有继续执行的能力。

线程操作相关的方法

线程操作的方法主要是在Thread类中。