25. 线程的四种创建方式

25. 线程的四种创建方式

四种创建线程的方式：

• 继承 Thread 类
• 实现 Runnable 接口
• 通过 ExecutorService 和 Callable<Class> 实现有返回值的线程
• 基于线程池的execute()，创建临时线程

1 继承 Thread 类

Thread 类实现了 Runnable 接口并定义了操作线程的一些方法，我们可以通过创建类时继承 Thread类来创建一个线程。

具体实现：

（1）创建一个继承Thread的类ThreadDemo

（2）重新run()方法

调用步骤：

（1）创建ThreadDemo 类的对象t1

（2）执行t1.start() 方法来启动线程

//创建线程类
public class ThreadDemo extends Thread {
    //重写run()方法
	@Override
	public void run() {
		for(int i = 0;i<1000;i++) {
			System.out.println("Thread::"+i);
		}
	}
}

/***********************************************************************/
//调用线程

//创建线程对象
ThreadDemo t1 = new ThreadDemo();

//启动线程
t1.start();

run()方法中是线程的具体逻辑操作，

start()是一个native本地方法，通过操作系统启动一个线程。

2 实现 Runnable 接口

通过实现Runnable 接口来创建线程类 RThread，但是使用的时候，仍需要创建Thread 对象，把RThread的对象当成参数传入。

具体操作：

（1）实现Runnable 接口创建线程类 RThread

（2）重写run()方法

调用步骤：

（1）创建RThread 类的对象 rThread

（2）创建Thread类对象，并把rThread当成参数传入，相当于对rThread进行了封装。

（3）通过start()方法启动线程

//实现Runnable 接口创建线程类 RThread
public class RThread implements Runnable {
	@Override
	//重写run()方法
	public void run() {
		for(int i = 0;i<1000;i++) {
			System.out.println("Thread::"+i);
		}
	}
}

/***********************************************************************/
//调用线程

//创建RThread 类的对象 rThread
RThread rThread = new RThread();

//创建Thread类对象，并把rThread当成参数传入，相当于对rThread进行了封装。
Thread t2 = new Thread(rThread);

//通过start()方法启动线程
t2.start();

3 通过 ExecutorService 和 Callable<Class> 实现有返回值的线程

我们需要在主线程中开启多个线程去执行一个任务，然后收集各个线程的返回结果并将最终结果进行汇总，这是就需要用到 Callable 接口。

具体步骤：

（1）创建一个类实现Callable接口

（2）重写 call() 方法

调用步骤：

（1）创建线程池

（2）创建接收结果的列表集合

（3）创建线程对象

（4）将线程对象提交到线程池中，并将返回结果接收

（5）将返回结果加入结果集合

（6）关闭线程池

//通过实现Callable接口来创建线程类
public class CThread implements Callable<String> {
	private String name;
	
	public CThread(String name ) {
		this.name = name;
	}
	
	//重写call()方法
	@Override
	public String call() throws Exception {
		return name;
	}	
}
/***********************************************************************/
//调用线程

//创建线程池
ExecutorService pool = Executors.newFixedThreadPool(5);

//创建接收结果的列表集合
List<Future> list = new ArrayList<Future>();

for(int i = 0;i<5;i++) {
//创建线程对象
Callable c = new CThread("线程"+i);

//将线程对象提交到线程池中，并将返回结果接收
Future future = pool.submit(c);
System.out.println("线程"+i+"已经加入线程池");

//将返回结果加入集合
list.add(future);
}

//关闭线程池
pool.shutdown();

//打印返回结果
for (Future future : list) {
    try {
        System.out.println(future.get().toString());
    } catch (InterruptedException | ExecutionException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
	}
}

4 基于线程池的execute()，创建临时线程

我们可以利用缓存策略使用线程池来创建线程

具体创建：

（1）创建线程池

（2）调用线程池的execute()方法

（3）采用匿名内部类的方法，创建Runnable对象，并重写run()方法

public class EThread {
	public static void main(String[] args) {
		//创建线程池
		ExecutorService threadPool = Executors.newFixedThreadPool(10);
		for(int i = 0;i<10;i++) {
			//调用execute()方法创建线程
			//采用匿名内部类的方法，创建Runnable对象，并重写run()方法
			threadPool.execute(new Runnable() {
				@Override
				public void run() {
					System.out.println(Thread.currentThread().getName());	
				}
			});
		}
	}
}