方式1:
继承Thread,重写run方法,直接new对象.start启动
public class T1 {
static class MyThread extends Thread{
@Override
public void run() {
System.out.println("MyThread...");
}
}
public static void main(String[] args) {
new MyThread().start();
}
}
方式2:
实现Runnable接口,重写run方法,new出Thread传入对象作为参数,.start启动
public class T2 {
static class MyRun implements Runnable{
public void run() {
System.out.println("MyRun...");
}
}
public static void main(String[] args) {
new Thread(new MyRun()).start();
}
}
方式3:
new出Tread对象,使用lambda表达式,.start启动
public class T3 {
public static void main(String[] args) {
new Thread(()-> System.out.println("lambda...")).start();
}
}
方式4:
使用线程池ExecutorService,调用execute方法,传入一个Runnable的实现类
public class T4 {
public static void main(String[] args) {
ExecutorService service = Executors.newCachedThreadPool();
service.execute(() -> System.out.println("Executor..."));
service.shutdown();
}
}
方式5:
实现Callable接口,用线程池的submit方法调用
返回值为Future,指定泛型作为线程的返回值类型
不用线程池的情况下,需要用FutureTask套一层作为参数传给Thread
public class T5 {
static class MyCall implements Callable<String> {
@Override
public String call(){
return "Callable...";
}
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
ExecutorService service = Executors.newCachedThreadPool();
Future<String> submit = service.submit(new MyCall());
System.out.println(submit.get());
service.shutdown();
FutureTask task = new FutureTask(new MyCall());
new Thread(task).start();
}
}