线程的创建和启动

Java使用Thread类代表线程，所有的线程对象都必须是Thread类或者其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流（一段顺序执行的代码）。Java使用线程执行体来代表这段程序流
一、继承Thread类创建线程类
通过继承Thread类来创建并启动多线程的步骤如下：
1.定义Thread类的子类，并重写该类的run（）方法，该run（）方法的方法体就代表了线程需要完成的任务。因此把run（）方法称为线程执行体
2.创建Thread子类的实例，即创建了线程对象
3.调用线程对象的start（）方法来启动该线程
下面程序示范了通过继承Thread类来创建并启动多线程

public class FirstThread extends Thread {
	private int i;
	//重写run（）方法，run（）方法的方法体就是线程执行体
	public void run()
	{
		for(;i<100;i++)
		{
			System.out.println(getName()+""+i);
			//当线程类继承Thread类时，直接使用this即可获取当前线程
			//Thread对象的getName（）返回当前线程的名字
			//因此可以直接调用getName（）方法返回当前线程的名字
		}
	}
	public static void main(String[] agrs) {
		for(int i=0;i<100;i++)
		{
			//调用Thread的currentThread（）方法获取当前线程
			System.out.println(Thread.currentThread().getName()+""+i);
			if(i==20)
			{
				//创建并启动第一个线程
				new FirstThread().start();
				//创建并启动第二个线程
				new FirstThread().start();
			}
		}
	}

}

上面的程序中的FirstThread类继承了Thread类，并实现了run（）方法，如程序中第一段 public void run（）代码体所示，该run（）方法里的代码执行流就是该线程所需要完成的任务。程序的主方法中也包含了一个循环，当循环变量i等于20时创建并启动两个新线程。

虽然上面程序只显示地创建并启动了2个线程，但实际上程序有3个线程，即程序显示创建的2个子线程和主线程。当Java程序开始运行后，程序至少会创建一个主线程，主线程的线程执行体不是由run（）方法确定的，而是由main（）方法确定的——main（）方法的方法体代表主线程的线程执行体

（注意：进行多线程编程时不要忘记了Java程序运行时默认的主线程，main（）方法的方法体就是主线程的线程方法体）

除此之外,上面程序还用到了线程的如下两个方法

——Thread.currentThread():currentThread()是Thread类的静态方法，该方法总是返回当前正在执行的线程对象

——getName（）：该方法是Thread类的实例方法，该方法返回调用该方法的线程名字

（注意：程序可以通过setName（String name）方法为线程设置名字，也可以通过getName（）方法返回指定线程的名字。在默认情况下，主线程的名字为main，用户启动的多个线程的名字依次为Thread-0、Thread-1、Thread-2、、、Thread-n等）

上面的程序运行起来，Thread-0、Thread-1两个线程输出的i变量不连续——注意：i变量是FirstThread的实例变量，而不是局部变量，但因为程序每次创建线程对象时都需要创建一个FirstThread对象，所以Thread-0、Thread-1不能共享该实例变量

（注意：使用继承Thread类的方法来创建线程类时，多个线程之间无法共享线程类的实例变量）

二、实现Runnable接口创建线程类

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

1.定义Runnable接口的实现类，并重写该接口的run（）方法，该run（）方法的方法体同样是该线程的线程执行体

2.创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象，代码如下

//创建Runnable实现类的对象
SecondThread st=new SecondThread();
//以Runnable实现类的对象作为Thread的target来创建Thread对象，即线程对象
new Thread(st);

也可以在创建Thread对象时为该Thread对象指定一个名字，代码如下所示：

//创建Thread对象时指定target和新线程的名字
new Thread(st,"新线程1");

（提示：Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run（）方法仅作为线程执行体，而实际的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run（）方法）

//通过实现runnable接口来创建并启动多线程
public class SecondThread implements Runnable{
	private int i;
	//run（）方法同样是线程执行体
	public void run()
	{
		for(;i<100;i++)
		{
			//当线程类实现Runnable接口时
			//如果想获取当前线程，只能用Thread.currentThread（）方法
			System.out.println(Thread.currentThread().getName()+" "+i);
		}
	}
	public static void main(String[] args)
	{
		for(int i=0;i<100;i++)
		{
			System.out.println(Thread.currentThread().getName()+" "+i);
			if(i==20)
			{
				SecondThread st=new SecondThread();
				//通过new Thread（target，name）方法创建新线程
				new Thread(st,"新线程1").start();
				new Thread(st,"新线程2").start();
			}
		}
	}

}

上面部分代码实现了run（）方法，也就是定义了该线程的线程执行体。 对比FirstThread中的run（）方法体和和SecondThread中的run（）方法体不难发现，通过继承Thread类来获得当前线程对象比较简单，直接使用this就可以了；但通过实现Runnable接口来获得当前线程对象，则必须使用Thread.currentThread()方法。

（提示：Runnable接口中只包含一个抽象方法，从Java8开始，Runnable接口使用了FunctionalInterface修饰。也就是说，Runnable接口是函数式接口，可使用Lambda表达式创建Runnable对象。）

除此之外，上面的程序中run（）方法体创建了两个Thread对象，并调用start（）方法来启动这两个线程，在FirstThread和SecondThread中创建线程对象的方式有所区别：前者直接创建的Thread子类即可代表线程对象：后者创建的Runnable对象只能作为线程对象的target。

运行上面程序，会发现，两个子线程的i变量是连续的，也就是采用Runnable接口的方式创建的多个线程可以共享线程类的实例变量，这是因为在这种方式下，程序所创建的Runnable对象只是线程的target，而多个线程可以共享同一个target，所以多个线程可以共享同一个线程类（实际应该是线程target类）的实例变量。

 

《疯狂Java讲义》电子工业出版社——李刚 编著