实现多线程方式三种方式

2015年1月11日13:43:29 天气阴

方式一：继承Thread类

步骤：

1.继承Thread

2.重写run方法，线程执行体(希望多线程完成什么任务就在run方法中作)

3.创建线程实例，然后调用start方法启动线程，让线程进入就绪状态,并没有运行，什么时候运行了，由系统决定

注意：不要调用run方法，如果调用了run方法，就是单线程效果

 TestThread.java

public class TestThread extends Thread {

	// 继承Thread方式 并 重写 run方法(没有返回值、不能 throws 异常)
	@Override
	public void run() {
		Thread thread = Thread.currentThread();
		for (int i = 0; i < 10; i++) {
			//getId()获得当前线程的编号 getName()获得当前线程的名字
			System.out.println("-run-" + i + "--" + thread.getId() + "--" + thread.getName());
		}
	}

	public static void main(String[] args) {

		TestThread testThread = new TestThread();
		// 调用start方法(线程并不是立即运行，进入一个 就绪状态)
		testThread.start();
		Thread mainThread = Thread.currentThread();
		for (int i = 0; i < 10; i++) {
			System.out.println("-main-" + i + "--" + mainThread.getId() + "--" + mainThread.getName());
		}
	}
}

方式二：实现Runnable接口(*)

步骤：

1.实现Runnable接口

2.重写run方法

3.创建一个Runnable实例交给Thread构造器

4.调用Thread的start方法(启动线程，进入就绪状态)

TestRunnable.java

//1:实现 Runnable接口 
public class TestRunnable implements Runnable{
	
	//2: 重写run方法
	@Override
	public void run() {
		Thread runnableThreadInfo = Thread.currentThread();
		for (int i = 0; i < 10; i++) {
			System.out.println("-run-"+ i + "--" + runnableThreadInfo.getId() + "--" + runnableThreadInfo.getName());
		} 
	} 
	
	public static void main(String[] args) {
		//3: 创建一个Runnable实例 交给 Thread 构造器
		Runnable runnable = new TestRunnable();
		Thread threadThread = new Thread(runnable);
		
		//4:调用Thread的strat方法(启动线程，进入就绪状态)
		threadThread.start();
		Thread maintThread = Thread.currentThread();
		for (int i =0; i < 10; i++) {
			System.out.println("-main-" + i + "--" + maintThread.getId() + "--" +maintThread.getName());
		} 
	}
}

方式三：实现Calable接口

为了解决Runnable接口的不足，Java5 新增了Callable接口

Callable接口相当于Runnable的增强版，它包含了call方法，该方法就有返回值，也声明了抛出异常。

步骤：

1.实现Callable接口

2.重写call方法(可以有返回值，可以throws异常)-----call方法就是和原来的run一样的，都是写多线程需要执行的代码的线程体方法

3.创建Callable类的实例交给FutureTask构造器

4.将创建好的FutureTask实例交给Thread的构造器

5.通过Thread的start方法启动线程，就如就绪状态

//可以通过FutureTask的实例的get方法获得call方法执行完毕返回的结果(get方法时阻塞方法)

TestCallable.java

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

//1: 实现 Callable 接口
public class TestCallable implements Callable<Integer>{

	//2: 重写call方法（可以有返回值， 可以throws 异常） --call 方法就是和原来的run一样的，都是写多线程需要执行的代码的线程体方法
	@Override
	public Integer call() throws Exception {
		int sum = 0;
		Thread callThreadInfo = Thread.currentThread();
		for (int i = 0; i < 10; i++) {
			System.out.println("-call-" + i + "--" + callThreadInfo.getId() + "--" + callThreadInfo.getName());
			sum += i;
		} 
		return sum;
	}
	
	public static void main(String[] args) throws Exception {
		//3: 创建Callable类的实例交给 FutureTask构造器
		Callable<Integer> callable = new TestCallable();
		FutureTask<Integer> futureTask = new FutureTask<Integer>(callable);
		
		//4: 将创建好的FutureTask实例交给Thread构造器
		Thread callableTreThread = new Thread(futureTask);
		
		//5: 通过Thread的start方法启动线程 ，进入 就绪状态
		callableTreThread.start();
		Thread mainThread = Thread.currentThread();
		for (int i =0; i < 10; i++) {
			System.out.println("-main-" + i + "--" + mainThread.getId() + "--" + mainThread.getName());
		} 
		
		//可以通过FutureTask的实例的get方法获得call方法执行完毕返回的结果 （注意get方法是阻塞方法）
		System.out.println("获得call方法执行完毕返回的结果："+futureTask.get());
	}

}