1 前言
线程创建线程的方法一般可以分为四类：
- 通过实现Runnable接口来创建Thread线程
- 通过实现Callable接口来创建Thread线程
- 通过继承Thread类来创建一个线程
- 使用Executor框架来创建线程
2 创建线程的四种方式
2.1 实现Runnable接口创建Thread
通过实现Runnable接口来创建Thread线程，其步骤可以分为以下几步
- 步骤1：创建一个类实现Runnable接口
class TestRunnable implements Runnable{
public void run(){
}
}
- 步骤2：创建一个类对象
Runnable testRunnable = new TestRunnable();
- 步骤3：由Runnable创建一个Thead对象
Thread testThread = new Thread(testRunnable);
步骤4：启动线程：
testThread.start();
至此，通过实现Runnable接口来创建线程的步骤完成。
代码实现如下所示：
（1）TestRunnable类
package com.yds.test;
public class TestRunnable implements Runnable {
@Override
public void run() {
// TODO 自动生成的方法存根
int i=0;
while(i<10){
System.out.println(i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
i++;
}
}
}
（2）Test类调用
package com.yds.test;
public class Test {
public static void main(String[] args) {
// TODO 自动生成的方法存根
//使用实现Runnable接口创建线程
Runnable testRunnable = new TestRunnable();
Thread testThread = new Thread(testRunnable);
testThread.start();
}
}
2.2 实现Callable接口来创建Thread线程
Callable是一个接口，只有一个call方法，用Callable接口创建Thread线程的步骤如下：
- 步骤1：创建实现Callable接口的类TestCallable
package com.yds.test;
import java.util.concurrent.Callable;
public class TestCallable implements Callable<Integer>{
@Override
public Integer call() throws Exception {
// TODO 自动生成的方法存根
int i=0;
while(i<10){
System.out.println(i);
Thread.sleep(1000);
i++;
}
return i;
}
}
- 步骤2：创建一个类对象
TestCallable testCallable = new TestCallable();
- 步骤3：有Callable创建一个FutureTask对象
FutureTask<Integer> task = new FutureTask<Integer>(testCallable);
- 步骤4：由FutureTask对象创建一个Thread对象
Thread thread = new Thread(task);
- 步骤5：启动线程
thread.start();
FutureTask的get方法是返回Callable里的call返回的值，如果call方法里面是耗时任务，则get方法会阻塞主线程。
代码实现如下：
TestCallable类：
package com.yds.test;
import java.util.concurrent.Callable;
public class TestCallable implements Callable<Integer>{
@Override
public Integer call() throws Exception {
// TODO 自动生成的方法存根
int i=0;
while(i<10){
System.out.println(i);
Thread.sleep(1000);
i++;
}
return i;
}
}
Test调用
package com.yds.test;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class Test {
public static void main(String[] args) {
//1. 使用实现Runnable接口创建线程
// Runnable testRunnable = new TestRunnable();
// Thread testThread = new Thread(testRunnable);
// testThread.start();
//2. 使用Callable和Future创建线程
TestCallable testCallable = new TestCallable();
FutureTask<Integer> task = new FutureTask<Integer>(testCallable);
Thread thread = new Thread(task);
thread.start();
}
}
2.3 继承Thread类来创建线程
- 步骤1：定义一个继承Thread类的子类
public class TestThread extends Thread{
@Override
public void run() {
// TODO 自动生成的方法存根
}
}
- 步骤2：构造子类的一个对象
TestThread testThread = new TestThread();
- 步骤3：启动线程
testThread.start();
代码示例如下：
TestThread类
package com.yds.test;
public class TestThread extends Thread{
@Override
public void run() {
// TODO 自动生成的方法存根
int i = 0;
while(i<10){
System.out.println(i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
i++;
}
}
}
Test调用
package com.yds.test;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class Test {
public static void main(String[] args) {
//1. 使用实现Runnable接口创建线程
// Runnable testRunnable = new TestRunnable();
// Thread testThread = new Thread(testRunnable);
// testThread.start();
//2. 使用Callable和Future创建线程
// TestCallable testCallable = new TestCallable();
// FutureTask<Integer> task = new FutureTask<Integer>(testCallable);
// Thread thread = new Thread(task);
// thread.start();
//3. 继承Thread创建线程
TestThread testThread = new TestThread();
testThread.start();
}
}
2.4 使用Executor框架来创建线程池
Executors类中包含以下四个创建线程池方法。
| 方法名 | 描述 |
|---|---|
| newCachedThreadPool() | 创建一个可以缓存的线程池，如果线程池中有线程可用，则复用该线程，如果线程不可用，则创建一个新的线程并加入线程池中。终止并从缓存池中移除那些60秒未被使用的线程。 |
| newFixedThreadPool | 创建固定数目线程的线程池。 |
| newSingleThreadExecutor | 创建一个单线程化的Executor |
| newScheduledThreadPool | 创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代Timer类。 |
- Executor执行Runnable任务
package com.yds.test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
public class Test {
public static void main(String[] args) {
//1. 使用实现Runnable接口创建线程
// Runnable testRunnable = new TestRunnable();
// Thread testThread = new Thread(testRunnable);
// testThread.start();
//2. 使用Callable和Future创建线程
// TestCallable testCallable = new TestCallable();
// FutureTask<Integer> task = new FutureTask<Integer>(testCallable);
// Thread thread = new Thread(task);
// thread.start();
//3. 继承Thread创建线程
// TestThread testThread = new TestThread();
// testThread.start();
// 4. 使用Executor执行Runnable创建线程
ExecutorService executorServicec = Executors.newCachedThreadPool();
executorServicec.execute(new TestRunnable());
executorServicec.shutdown();
}
}
- Executor执行Callable创建线程
package com.yds.test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
public class Test {
public static void main(String[] args) {
//1. 使用实现Runnable接口创建线程
// Runnable testRunnable = new TestRunnable();
// Thread testThread = new Thread(testRunnable);
// testThread.start();
//2. 使用Callable和Future创建线程
// TestCallable testCallable = new TestCallable();
// FutureTask<Integer> task = new FutureTask<Integer>(testCallable);
// Thread thread = new Thread(task);
// thread.start();
//3. 继承Thread创建线程
// TestThread testThread = new TestThread();
// testThread.start();
// 4. 使用Executor执行Runnable创建线程
// ExecutorService executorServicec = Executors.newCachedThreadPool();
// executorServicec.execute(new TestRunnable());
// executorServicec.shutdown();
//5. 使用Executor执行Callable创建线程
ExecutorService executorServicec = Executors.newCachedThreadPool();
TestCallable testCallable = new TestCallable();
FutureTask<Integer> task = new FutureTask<Integer>(testCallable);
executorServicec.execute(task);
}
}
