创建线程以及怎样创建有返回值的线程

一、继承Thread类创建线程类

    (1) 定义一个类并继承Thread，重写run方法，该run方法为该线程需要完成的任务，及线程的执行体。

    (2) 创建该类的实例对象，及为创建了线程对象。

    (3) 调用线程的start方法，及启动线程。

package com;

import java.util.ArrayList;
import java.util.List;

public class FirstCreateMethod extends Thread {
	private List<String> list;

	public FirstCreateMethod() {

	}

	public FirstCreateMethod(List<String> list) {
		this.list = list;
	}

	@Override
	public void run() {
		for (String target : list) {
			System.out.println(Thread.currentThread().getName() + target);
		}
	}

	public static void main(String[] args) {
		List<String> list1 = new ArrayList<String>();
		list1.add("六脉神剑");
		list1.add("独孤九剑");
		list1.add("辟邪剑法");
		FirstCreateMethod thread1 = new FirstCreateMethod(list1);
		List<String> list2 = new ArrayList<String>();
		list2.add("玄铁剑法");
		list2.add("全真剑法");
		list2.add("玉女素心剑法");
		FirstCreateMethod thread2 = new FirstCreateMethod(list2);
		thread1.start();
		thread2.start();
	}

	public List<String> getList() {
		return list;
	}

	public void setList(List<String> list) {
		this.list = list;
	}

}

上述代码中Thread.currentThread()方法返回当前正在执行的线程对象。GetName()方法返回调用该方法的线程的名字。

二、实现Runnable接口

      (1) 定义一个类实现Runnable接口，重写run方法

      (2) 创建Thread的实例对象，并将定义的类的对象作为参数传递进去

      (3) 调用start方法启动线程

package com;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

public class ThreadTest implements Runnable{

	private List<String> list;
	public ThreadTest() {
	}
	
	public ThreadTest(List<String> list) {
		this.list = list;
	}

	@Override
	public void run() {
		for (String target : list) {
			System.out.println(target);
			try {
				TimeUnit.MILLISECONDS.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("杨过");
		list.add("小龙女");
		list.add("梅超风");
		Thread thread1 = new Thread(new ThreadTest(list));
		thread1.start();
	}
}

其中TimeUnit.MILLISECONDS.sleep(1000)是表示延迟1秒

三、创建有返回值的线程

   (1) 定义一个类实现Callable接口，并写明泛型，泛型为返回值类型

   (2) 重写call方法

   (3) 返回值结果封装在future中，用get方法获取出来

package com;

import java.util.ArrayList;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class TaskWithResult implements Callable<String> {

	private int id;
	public TaskWithResult(int id){
		this.id=id;
	}
	@Override
	public String call() throws Exception {
		return "result of TaskWithResult"+id;
	}

	public static void main(String[] args){
		ExecutorService exec = Executors.newCachedThreadPool();
		ArrayList<Future<String>> results = new ArrayList<Future<String>>();
		for(int i = 0;i<10;i++)
			results.add(exec.submit(new TaskWithResult(i)));
		exec.shutdown();
		for (Future<String> future : results) {
			try {
				System.out.println(future.get());
			} catch (InterruptedException | ExecutionException e) {
				e.printStackTrace();
			}
		}
	}
}

利用执行器可以避免重复new线程，submit方法是有返回值的，入参为callable实例对象，返回值封装在future中，通过get方法一一获取出来。