Java的线程实现方式一共有三种，继承Thread、实现Runable接口，实现Callable接口。不过实现Runnable接口与实现Callable接口的方式基本相同，只是Callable接口里定义的方法有返回值，可以声明抛出异常而已。

一、 继承Thread类创建线程类

1） 定义Thread类的子类，并重写该类的run（）方法，该run（）方法的方法体就代表了线程需要完成的任务。

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

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

// 通过继承Thread类来创建线程类
public class FirstThread extends Thread
{
	private int i ;
	// 重写run方法，run方法的方法体就是线程执行体
	public void run()
	{
		for ( ; i < 100 ; i++ )
		{
			// 当线程类继承Thread类时，直接使用this即可获取当前线程
			// Thread对象的getName()返回当前该线程的名字
			// 因此可以直接调用getName()方法返回当前线程的名
			System.out.println(getName() +  " " + i);
		}
	}
	public static void main(String[] args) 
	{
		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();
			}
		}
	}
}

这里我们需要注意的是，启动线程必须通过start（）方法，而不是直接调用run（）方法。

除此以外，上面程序中海油如下两个方法：

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

· getName(): 该方法是Thread类的实例方法，该方法返回调用该方法的线程名字。

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

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

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

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

// 通过实现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();
			}
		}
	}
}

对比FirstThread中的run（）方法和SecondThread中的run（）方法，可以发现继承Thread类来获取当前线程对象比较简单，直接可以使用this就可以了； 但通过实现Runnable接口来获取当前线程，就必须使用Thread.currentThread（）方法。

三、 使用Callable和Future创建线程

Callable接口提供了一个call（）方法，作为线程执行体，但是call（）方法比run方法更加强大。

· call（）方法可以有返回值。

· call（）方法可以声明抛出异常。

// 实现Callable接口来实现线程
public class ThirdThread implements Callable<Integer>
{
	// 实现call方法，作为线程执行体
	public Integer call()
	{
		int i = 0;
		for ( ; i < 100 ; i++ )
		{
			System.out.println(Thread.currentThread().getName()
				+ " 的循环变量i的值：" + i);
		}
		// call()方法可以有返回值
		return i;
	}

	public static void main(String[] args) 
	{
		// 创建Callable对象
		ThirdThread rt = new ThirdThread();
		// 使用FutureTask来包装Callable对象
		FutureTask<Integer> task = new FutureTask<Integer>(rt);
		for (int i = 0 ; i < 100 ; i++)
		{
			System.out.println(Thread.currentThread().getName()
				+ " 的循环变量i的值：" + i);
			if (i == 20)
			{
				// 实质还是以Callable对象来创建、并启动线程
				new Thread(task , "有返回值的线程").start();
			}
		}
		try
		{
			// 获取线程返回值
			System.out.println("子线程的返回值：" + task.get());
		}
		catch (Exception ex)
		{
			ex.printStackTrace();
		}
	}
}