Java多线程实践-优快云博客

做实验的过程中需要用到多线程，许久不用有点儿生疏了，现在查资料做个多线程创建的方法记录。

Java使用线程大致有以下四种方法：

继承Thread类，重写run方法。（Thread类本身也实现了Runnable接口）
实现Runnable接口，重写run方法。
实现Callable接口，重写call方法（有返回值）
使用线程池（有返回值）

1.继承Thread类，重写run方法

每次创建一个新的线程，都需要新建一个Thread子类的对象。
一个线程调用两次start()方法将会抛出线程状态异常。
继承Thread类的方式是多个线程各自完成各自的任务。
创建线程实际调用的是父类Thread空参的构造器。

public class Test {
	public static void main(String[] args) {
		for (int i = 0; i < 10; i++) {
			MyThread thread = new MyThread();
			thread.satrt();
		}
		System.out.println("This is main thread");
	}
}

public class MyThread extends Thread {
	@Override
	public void run() {
		System.out.println("This is MyThread.");
	}
}

2.实现Runnable接口，重写run()方法

覆写Runnable接口实现多线程，可以避免单继承局限。不论创建多少个线程，只需要创建一个Runnable接口实现类的对象。
创建线程实际调用的Thread类Runnable类型参数的构造器。
实现Runnable接口的方法是多个线程共同完成一个任务。

public class Test {
	public static void main(String[] args) {
		Task task = new Task();
		for (int i = 0; i < 10; i++) {
			Thread thread = new Thread(task);
			thread.satrt();
		}
		System.out.println("This is main thread");
	}
}

public class Task implements Runnable {
	@Override
	public void run() {
		System.out.println("This is MyThread.");
	}
}

3.实现Callable接口，重写call()方法

自定义类实现Callable接口时，必须指定泛型，该泛型即返回值的类型。
每次创建一个新的线程，都需要创建一个新的Callable接口的实现类。
启动线程的过程：

创建一个Callable接口的实现类的对象实例。
创建一个FutureTask对象，传入Callable类型的参数。
调用Thread类重载参数为Runnable的构造器创建Thread对象，将FutureTask作为参数传入。
线程允许完后获取返回值：
使用FutureTask的get()方法。

public class Test {
	public static void main(String[] args) {
		for (int i = 0; i < 10; i++) {
			Task task = new Task();
			FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
            Thread thread = new Thread(futureTask);
            thread.start();
            try {
                System.out.println("The result is : " + futureTask.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
		}
		System.out.println("This is main thread");
	}
}

public class Task implements Callable<Integer> {
	@Override
	public Integer call() {
		int result = 0;
		for (int i = 0; i < 10000; i++)
			result += i;
		return result;
	}
}

FutureTask的get()方法在调用的时候会阻塞，直到当前的线程完成运行后将结果返回。

4.使用线程池

在java.util.concurrent包下，提供了一系列与线程池有关的类。合理使用线程池，可以带来诸多好处：

降低资源消耗，通过重复利用已创建的线程来降低线程创建和销毁造成的消耗。
提高响应速度，当任务到达时，任务可以不必等到新线程创建就能立即运行。
提高线程的可管理性，线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配、调优和监控。
线程池可以应对突然大爆发的访问，通过有限个固定线程为大量的操作服务，减少创建和销毁线程所需的时间。
使用线程池的过程：
创建线程池。
创建任务。
执行任务。
关闭线程池。

这里使用一个固定大小的线程池来举例子。

public class Test {

	private static final int THREAD_POOL_SIZE = 5;

	public static void main(String[] args) {
		ExecutorService executorService = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
		Task task = new Task();
		FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
		executorService.submit(futureTask);
		executorService.shutdown();
		try {
			System.out.println("The result is : " + futureTask.get());
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}
		System.out.println("This is main thread");
	}
}

public class Task implements Callable<Integer> {
	@Override
	public Integer call() {
		int result = 0;
		for (int i = 0; i < 10000; i++)
			result += i;
		return result;
	}
}