实现多线程有以下方式：
1. 继承Thread类，重写run（）方法。然后直接new这个对象的实例，创建一个线程的实例，再调用start（）方法启动线程。（其实本质上Thread是实现了Runnable接口的一个实例，Thread源文件：public class Thread implements Runnable）
2.实现Runnable接口，重写run（）方法。然后调用new Thread（runnable）的方式创建一个线程，再调用start（）方法启动线程。
3.实现Callable接口，重写call（）方法。Callable是类似于Runnable的接口，是属于Executor框架中的功能类。是JDK1.5中引入的新特性。
4.线程池：提供了一个线程队列，队列中保存着所有等待状态的线程。避免了创建与销毁额外开销，提高了响应的速度。
5.Spring方式：使用Spring来实现多线程，可以通过Spring的@Async注解非常方便的实现多线程。
Runnable和Callable的不同点：
- ①Callable规定的方法是call()，而Runnable规定的方法是run().
- ②Callable的任务执行后可返回值，而Runnable的任务是不能返回值的（有返回值用callable方法，无返回值用runnable方法）
- ③call()方法可抛出异常，而run()方法是不能抛出异常的。
- ④运行Callable任务可拿到一个Future对象，Future表示异步计算的结果。它提供了检查计算是否完成的方法,以等 待计算的完成,并检索计算的结果.通过Future对象可了解任务执行情况,可取消任务的执行,还可获取任务执行的结果
体系结构：
java.util.concurrent.Executor : 负责线程的使用与调度的根接口
|--ExecutorService 子接口: 线程池的主要接口
|--ThreadPoolExecutor 线程池的实现类
|--ScheduledExecutorService 子接口：负责线程的调度
|--ScheduledThreadPoolExecutor ：继承 ThreadPoolExecutor， 实现 ScheduledExecutorService *工具类 : Executors
ExecutorService newFixedThreadPool() : 创建固定大小的线程池
ExecutorService newCachedThreadPool() : 缓存线程池，线程池的数量不固定，可以根据需求自动的更改数量。
ExecutorService newSingleThreadExecutor() : 创建单个线程池。线程池中只有一个线程
ScheduledExecutorService newScheduledThreadPool() : 创建固定大小的线程，可以延迟或定时的执行任务。1) 继承Thread类
package com.root.thread;
public class TestThread {
public static void main(String[] args) {
ThreadDemo threadDemo = new ThreadDemo();
threadDemo.start();
}
}
class ThreadDemo extends Thread{
@Override
public void run() {
boolean flag = false;
for(int i = 3 ; i < 100 ; i ++) {
flag = false;
for(int j = 2; j <= Math.sqrt(i) ; j++) {
if(i % j == 0) {
flag = true;
break;
}
}
if(flag == false) {
System.out.print(i+" ");
}
}
}
}运行结果：
3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 972）实现Runnable接口
package com.root.thread;
public class TestRunnable {
public static void main(String[] args) {
RunnableDemo runnableDemo = new RunnableDemo();
new Thread(runnableDemo).start();
}
}
class RunnableDemo implements Runnable {
@Override
public void run() {
boolean flag = false;
for (int i = 3; i < 100; i++) {
flag = false;
for (int j = 2; j <= Math.sqrt(i); j++) {
if (i % j == 0) {
flag = true;
break;
}
}
if (flag == false) {
System.out.print(i + " ");
}
}
}
}运行结果：
3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97实现Runnable接口的好处，优点：
1、实现Runnable接口的方法中线程类只是实现了Runnable接口，还可以继承其他的类。避免的java单继承的局限性。
2、在这种方式下，可以多个线程共享一个Runnable对象，利于资源共享。适合多个相同的线程去处理同一份资源。
尽量使用实现Runnable接口的方法
3）实现Callable接口
package com.root.thread;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class TestCallable1 {
public static void main(String[] args) throws InterruptedException, ExecutionException {
CallableDemo callableDemo = new CallableDemo();
FutureTask futureTask = new FutureTask<>(callableDemo);
new Thread(futureTask).start();
List<Integer> lists = (List<Integer>) futureTask.get(); //获取返回值
for (Integer integer : lists) {
System.out.print(integer + " ");
}
}
}
class CallableDemo implements Callable<List<Integer>> {
@Override
public List<Integer> call() throws Exception {
boolean flag = false;
List<Integer> lists = new ArrayList<>();
for (int i = 3; i < 100; i++) {
flag = false;
for (int j = 2; j <= Math.sqrt(i); j++) {
if (i % j == 0) {
flag = true;
break;
}
}
if (flag == false) {
lists.add(i);
}
}
return lists;
}
}运行结果：
3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 974) 线程池
package com.root.thread;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;
public class TestThreadPool {
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService executorService = Executors.newFixedThreadPool(5);
List<Future<List<Integer>>> ints = new ArrayList<>();
for (int i = 0; i < 5; i++) {
Future<List<Integer>> future = executorService.submit(new Callable<List<Integer>>() {
@Override
public List<Integer> call() throws Exception {
boolean flag = false;
System.out.println(Thread.currentThread().getName() + " ");
List<Integer> lists = new ArrayList<>();
for (int i = 3; i < 100; i++) {
flag = false;
for (int j = 2; j <= Math.sqrt(i); j++) {
if (i % j == 0) {
flag = true;
break;
}
}
if (flag == false) {
lists.add(i);
}
}
return lists;
}
});
ints.add(future);
}
for (Future<List<Integer>> future : ints) {
System.out.println(future.get());
}
}
}
class ThreadPoolDemo {
}运行结果:
pool-1-thread-1
[3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
pool-1-thread-2
[3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
pool-1-thread-3
pool-1-thread-4
[3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
pool-1-thread-5
[3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
[3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
...
...5)Spring对多线程支持
其实非常简单，只需要在配置类中添加@EnableAsync就可以使用多线程。在希望执行的并发方法中使用@Async就可以定义一个线程任务。通过spring给我们提供的ThreadPoolTaskExecutor就可以使用线程池。
首先定义配置类
package com.root.thread;
import java.util.concurrent.Executor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
@Configuration
@ComponentScan("com.root.thread")
@EnableAsync // 启用异步任务
public class ThreadConfig {
// 这里是声明一个bean，类似于xml中的<bean>标签。
// Executor 就是一个线程池
@Bean
public Executor getExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(5);
executor.setMaxPoolSize(10);
executor.setQueueCapacity(25);
executor.initialize();
return executor;
}
}定义要执行的任务
package com.root.thread;
import java.util.Random;
import java.util.UUID;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
@Service // 注解的方式把AsyncService交给Spring来管理
public class AsynTaskService {
// 这里可以注入spring中管理的其他bean，这也是使用spring来实现多线程的一大优势
@Async // 这里进行标注为异步任务，在执行此方法的时候，会单独开启线程来执行
public void t1() {
System.out.println("t1 : " + Thread.currentThread().getName() + " " + UUID.randomUUID().toString());
try {
Thread.sleep(new Random().nextInt(100));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
@Async
public void t2() {
System.out.println("t2 : " + Thread.currentThread().getName() + " " + UUID.randomUUID().toString());
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}测试类
package com.root.thread;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class Main {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ThreadConfig.class);
AsynTaskService service = context.getBean(AsynTaskService.class);
for (int i = 0; i < 10; i++) {
service.t1(); // 执行异步任务
service.t2();
}
context.close();
}
}输出结果:
t1 : ThreadPoolTaskExecutor-5 20e6ba88-ae51-42b9-aac6-ed399419fe6d
t2 : ThreadPoolTaskExecutor-2 0d7b1da4-e045-4d58-9054-e793f931cae1
t2 : ThreadPoolTaskExecutor-4 17b8d7c7-24e3-4bcf-b4da-822650a8f0be
t1 : ThreadPoolTaskExecutor-3 a9b32322-1c9b-4fc7-9c2a-1f7a81f2b089
t1 : ThreadPoolTaskExecutor-1 13a85fde-73c7-4c9b-9bb2-92405d1d3ac4可以看到我们两个任务是异步进行的。
下面关于线程池的配置还有一种方式，就是直接实现AsyncConfigurer接口，重写getAsyncExecutor方法即可，代码如下:
package com.root.thread;
import java.util.concurrent.Executor;
import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
@Configuration
@ComponentScan("com.root.thread")
@EnableAsync
public class ThreadConfig implements AsyncConfigurer {
@Override
public Executor getAsyncExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(5);
executor.setMaxPoolSize(10);
executor.setQueueCapacity(25);
executor.initialize();
return executor;
}
@Override
public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
return null;
}
}使用Spring实现多线程是不是非常简单。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
