方式一:继承Thread类
步骤
- 创建一个继承于Thread类的子类。
- 在子类中重写Thread类的run()方法。
- 创建Thread类的子类的对象。
- 对象调用start()方法。
代码示例
用方式一创建一个线程,输出100以内的偶数,main主线程输出100以内的奇数。
//Main.java
//1.创建一个继承于Thread类的子类
class MyThread extends Thread {
//2.在子类中重写Thread类的run()方法
@Override
public void run() {
for (int i = 0; i < 100; i = i + 2) {
System.out.println(currentThread().getName() + ": " + i);
}
}
}
public class Main {
public static void main(String[] args) {
//3.创建Thread类的子类的对象
MyThread t1 = new MyThread();
//4.对象调用start()方法
t1.start();
for (int i = 1; i < 100; i = i + 2) {
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
- start()方法有两个作用,一启动当前线程;二调用当前线程的run方法。
- 不能直接调用run()方法启动线程。
- 不可以让已经start()线程再去执行start(),会报IllegalThreadStateException。
方式二:实现Runnable接口
步骤
- 创建一个实现了Runnable接口的类。
- 重写run()方法。
- 创建实现类的对象。
- 将实现类的对象作为形参传递到Thread类的构造器中,创建Thread类的对象。
- Thread类的对象调用start()方法。
代码示例
用方式二创建一个线程,输出100以内的偶数,main主线程输出100以内的奇数。
//Main.java
//1.创建一个实现了Runnable接口的类
class MyRunnable implements Runnable {
//2.重写run()方法
@Override
public void run() {
for (int i = 0; i < 100; i = i + 2) {
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
public class Main {
public static void main(String[] args) {
//3.创建实现类的对象
MyRunnable m = new MyRunnable();
//4.将实现类的对象作为参数传入Thread类的构造器中,创建Thread类的对象
Thread t1 = new Thread(m);
//5.Thread类的对象调用start()方法
t1.start();
//这里是主线程输出100以内的奇数
for (int i = 1; i < 100; i = i + 2) {
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
- 如果要创建t2,直接
Thread t2 = new Thread(m);
不需要MyRunnable m2 = new MyRunnable();
下面的方式三和方式四是JDK5新增的方式。
方式三:实现Callable接口
相比Runnable接口,Callable接口更强大
- 相比run()方法,call()方法可以有返回值。
- 方法可以抛出异常。
- 支持泛型的返回。
- 需要借助FutureTask类。
步骤
- 创建一个实现Callable接口的类。
- 重写call()方法,将线程需要执行的操作写到方法中。
- 创建实现类的对象。
- 将实现类的对象作为形参传入FutureTask类的构造器中,创建FutureTask类的对象。
- 将FutureTask类的对象作为形参传入到Thread类的构造器中,创建Thread类的对象。
- Thread类的对象调用start()方法。
- (可选)FutureTask类的对象调用get方法得到call()方法的返回值(需要try/catch处理)。
代码示例
//Main.java
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
//1.创建一个实现Callable接口的类
class MyCallable implements Callable {
//2.重写call()方法,将线程需要执行的操作写到方法中
@Override
public Object call() throws Exception {
int sum = 0;
for (int i = 0; i < 100; i = i + 2) {
sum += i;
System.out.println(Thread.currentThread().getName() + ": " + i);
}
return sum;
}
}
public class Main {
public static void main(String[] args) {
//3.创建一个实现类的对象
MyCallable myCallable = new MyCallable();
//4.将实现类的对象作为形参传入FutureTask类的构造器中,创建FutureTask类的对象
FutureTask futureTask1 = new FutureTask(myCallable);
//5.将FutureTask类的对象作为形参传入Thread类的构造器中,创建Thread类的对象
Thread t1 = new Thread(futureTask1);
//6.Thread类的对象调用start()方法
t1.start();
//再创建一个线程
FutureTask futureTask2 = new FutureTask(myCallable);
Thread t2 = new Thread(futureTask2);
t2.start();
//7.(可选)FutureTask类的对象调用get方法得到call()方法的返回值(需要try/catch处理)
try {
Object result = futureTask1.get();
System.out.println(Thread.currentThread().getName() + ": 100以内偶数和为" + result);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
- 再创建一个线程需要再创建一个FutureTask类的对象。
方式四:线程池
在并发情况下,如果按照上面三个方式来创建线程、销毁线程,会浪费资源,影响性能。于是出现了线程池,我们提前可以创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中。这样可以避免频繁的创建销毁线程,实现重复利用。
线程池的好处有:
- 提高响应速度(减少了创建线程的时间)。
- 降低资源消耗(重复利用线程池中的线程,不需要每次都创建销毁)。
- 便于线程管理。
步骤
- 提供指定线程数量的线程池。
- 执行指定的线程操作,需要提供实现Runnable接口或者Callable接口的实现类的对象。
- 关闭线程池。
代码示例
//Main.java
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
class MyRunnable implements Runnable {
@Override
public void run() {
for (int i = 0; i <100; i +=2) {
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
class MyCallable implements Callable {
@Override
public Object call() throws Exception {
for (int i = 1; i <100; i +=2) {
System.out.println(Thread.currentThread().getName() + ": " + i);
}
return null;
}
}
public class Main {
public static void main(String[] args) {
//1.提供指定线程数量的线程池
ExecutorService executorService = Executors.newFixedThreadPool(3);
//2.执行指定的线程操作,需要提供实现Runnable接口或者Callable接口实现类的对象
//第一种方式
MyRunnable myRunnable = new MyRunnable();
executorService.execute(myRunnable);
//第二种方式
MyCallable myCallable = new MyCallable();
executorService.submit(myCallable);
//3.关闭线程池
executorService.shutdown();
}
}