方式一:继承Thread类
- 创建一个继承于Thread类的子类
- 重写Thread类的run()
- 创建Thread类子类的对象
- 通过子类对象调用star()
//创建一个继承于Thread类的子类
class MyThread extends Thread {
//重写Thread类的run()
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if(i % 2 == 0){
System.out.println(i);
}
}
}
}
public class ThreadTest {
public static void main(String[] args) {
//创建Thread类子类的对象
MyThread myThread = new MyThread();
//通过子类对象调用star()
myThread.start();
}
}
方式二:实现Runnable接口
- 创建一个实现了Runnable接口的类
- 实现类去实现Runnable中的抽象方法:run()
- 创建实现类的对象
- 将次对象作为参数传递到Thread类的构造器中,创建Thread类的对象
- 通过Thread类的对象调用star()
//创建一个实现了Runnable接口的类
class MyThread1 implements Runnable {
//实现类去实现Runnable中的抽象方法:run()
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if(i % 2 == 0){
System.out.println(i);
}
}
}
}
public class ThreadTest {
public static void main(String[] args) {
//创建实现类的对象
MyThread1 m1 = new MyThread1();
//将次对象作为参数传递到Thread类的构造器中,创建Thread类的对象
Thread t1 = new Thread(m1);
//通过Thread类的对象调用star()
t1.start();
}
}
方式三:实现Callable接口
- 创建一个实现Callable接口的类
- 实现call()方法,将次线程需要执行的操作声明在call()内
- 创建Callable接口实现类的对象
- 将次Callable接口实现类的对象作为参数传递到FutureTask构造器中,创建FutureTask对象
- 将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象
- 通过Thread类的对象调用star()
- (可选)使用FutureTask对象调用get()获取Callable实现类重写的call()的返回值
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.Callable;
//创建一个实现Callable接口的类
class MyThread2 implements Callable {
//实现call()方法,将次线程需要执行的操作声明在call()内
@Override
public Object call() throws Exception {
int sum = 0;
for (int i = 0; i < 100; i++) {
if(i % 2 == 0){
System.out.println(i);
sum += i;
}
}
return sum;
}
}
public class ThreadTest {
public static void main(String[] args) {
//创建Callable接口实现类的对象
MyThread2 m1 = new MyThread2();
//将次Callable接口实现类的对象作为参数传递到FutureTask构造器中,创建FutureTask对象
FutureTask futureTask = new FutureTask(m1);
//将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象
Thread t1 = new Thread(futureTask);
//通过Thread类的对象调用star()
t1.start();
//(可选)使用FutureTask对象调用get()获取Callable实现类重写的call()的返回值
try {
int sum = (int) futureTask.get();
System.out.println(sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
方法四、线程池
- 提供指定线程数量的线程池
- 执行自动线程的操作,需要提供实现Runnable接口或Callable接口实现类的对象
- 关闭线程池
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadTest3 {
public static void main(String[] args) {
//提供指定线程数量的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
//执行自动线程的操作,需要提供实现Runnable接口或Callable接口实现类的对象
service.execute(new MyThread1());//适合用于Runnable
service.submit(new MyThread3());//适合用于Callable
//关闭线程池
service.shutdown();
}
}