1. 继承 Thread 类
重写run(),然后调用 start 方法。
class SampleThread extends Thread {
//重写run方法,线程运行后,跑的就是run方法
public void run(){
//System.out.println("");
}
public static void main(String[] args){
Thread t1 = new SampleThread();
Thread t2 = new SampleThread();
t1.start(); //线程运行,调用的 run()方法.
t2.start(); //线程运行,调用的 run()方法..
}
}
2. 实现 Runnable 接口
实现的 run 方法, 然后再用 Thread 类包裹后,调用 start 方法。
class A implements Runnable{
@Override
public void run() {
// implement run method here
}
public static void main() {
final A obj = new A();
Thread t1 = new Thread(new A());
t1.start();
}
}
3. 匿名内部类
// Runnable匿名类,实现其run()方法
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " is running");
}
}).start();
// 同上,使用lambda表达式函数式编程
new Thread(()->{
System.out.println(Thread.currentThread().getName() + " is running");
}).start();
4. 实现Callabe接口
实现 Callable 接口的 call 方法,用 FutureTask 类包裹 Callable 对象。然后再用 Thread 类包裹 FutureTask 类,并调用 start 方法。call() 方法可以有返回值。
class MyCallable implements Callable {
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 1; i <= 100; i++) {
sum += i;
}
return sum;
}
public static void main(String[] args) throws Exception {
MyCallable mc = new MyCallable(); //实例化 callable
FutureTask oneTask = new FutureTask(mc); //用FutureTask包裹
Thread oneThread = new Thread(oneTask); //用Thread包裹
oneThread.start();
System.out.print(oneTask.get()); //获取返回值
}
}
Callable 方法在 Java 8 后,支持拉姆达表达式的写法,可以创建一个 FutureTask 类,语句上不是太罗嗦。 Callable 方式有以下几个优点:
- 可以捕获线程上的异常。
- 可以通过 get 方法得到返回值。
- get 方法阻塞当前线程,直到调用的线程运行结束。
- 可以取消线程的运行。
下面代码演示了使用 FutureTask 类运行线程,捕获异常的例子:
FutureTask<Integer> task=new FutureTask<Integer>(()->{
throw new Exception("自定义异常");
});
new Thread(task).start();
try {
System.out.println(task.get());
} catch (Exception e) {
System.out.println(e.getMessage());
}
5. 定时器(java.util.Timer)
使用定时器java.util.Timer可以快速地实现定时任务,TimerTask实际上实现了Runnable接口。
public class CreatingThread05 {
public static void main(String[] args) {
Timer timer = new Timer();
// 每隔1秒执行一次
timer.schedule(new TimerTask() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " is running");
}
}, 0 , 1000);
}
}
6. 线程池
使用线程池的方式,可以复用线程,节约系统资源。通过创建线程池来创建线程,使用 ExecutorService 的 execute 方法:
public class CreatingThread06 {
public static void main(String[] args) {
ExecutorService threadPool = Executors.newFixedThreadPool(5);
for (int i = 0; i < 100; i++) {
threadPool.execute(()-> System.out.println(Thread.currentThread().getName() + " is running"));
}
}
}
7. lambda表达式
使用并行计算的方式,可以提高程序运行的效率,多线程并行执行。
public static void main(String[] args) {
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
// 串行,打印结果为12345
list.stream().forEach(System.out::print);
System.out.println();
// 并行,打印结果随机,比如35214
list.parallelStream().forEach(System.out::print);
}
8. Spring异步方法
首先,springboot启动类加上@EnableAsync
注解(@EnableAsync是spring支持的,这里方便举例使用springboot)。
@SpringBootApplication
@EnableAsync
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
其次,方法加上@Async
注解。
@Service
public class CreatingThread08Service {
@Async
public void call() {
System.out.println(Thread.currentThread().getName() + " is running");
}
}
然后,测试用例直接跟使用一般的Service方法一模一样。
@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class CreatingThread08Test {
@Autowired
private CreatingThread08Service creatingThread08Service;
@Test
public void test() {
creatingThread08Service.call();
creatingThread08Service.call();
creatingThread08Service.call();
creatingThread08Service.call();
}
}
总结:
本质上就两种,一种是继承Thread类并重写其run()方法,一种是实现Runnable接口的run()方法
请看下面的例子,同时继承Thread并实现Runnable接口,应该输出什么呢?
public class CreatingThread09 {
public static void main(String[] args) {
new Thread(()-> {
System.out.println("Runnable: " + Thread.currentThread().getName());
}) {
@Override
public void run() {
System.out.println("Thread: " + getName());
}
}.start();
}
}
说到这里,我们有必要看一下Thread类的源码:
public class Thread implements Runnable {
// Thread维护了一个Runnable的实例
private Runnable target;
public Thread() {
init(null, null, "Thread-" + nextThreadNum(), 0);
}
public Thread(Runnable target) {
init(null, target, "Thread-" + nextThreadNum(), 0);
}
private void init(ThreadGroup g, Runnable target, String name,
long stackSize, AccessControlContext acc,
boolean inheritThreadLocals) {
// ...
// 构造方法传进来的Runnable会赋值给target
this.target = target;
// ...
}
@Override
public void run() {
// Thread默认的run()方法,如果target不为空,会执行target的run()方法
if (target != null) {
target.run();
}
}
}
看到这里是不是豁然开朗呢?既然上面的例子同时继承Thread并实现了Runnable接口,根据源码,实际上相当于重写了Thread的run()方法,在Thread的run()方法时实际上跟target都没有关系了。
所以,上面的例子输出结果为Thread: Thread-0
,只输出重写Thread的run()方法中的内容。