java多线程和spring多线程实现
线程thread
线程的创建方法:
1、继承Thread类创建新的可执行线程
class PrimeThread extends Thread {
long minPrime;
PrimeThread(long minPrime) {
this.minPrime = minPrime;
}
public void run() {
// compute primes larger than minPrime
...
}
}
PrimeThread p = new PrimeThread(143);
p.start();
2、创建一个实现Runnable接口的类,该类必须实现run方法。这个实现类的实例可以作为创建Thread的入参,从而创建新的可执行线程
class PrimeRun implements Runnable {
long minPrime;
PrimeRun(long minPrime) {
this.minPrime = minPrime;
}
public void run() {
// compute primes larger than minPrime
...
}
}
PrimeRun p = new PrimeRun(143);
new Thread(p).start();
注:实际上 ,Thread类是Runnable的一个实现类,通过jdk源码可以看出
从java 1.5版本之后,使用java并发工具包java.util.concurrent
3、Callable接口、ExecutorService接口和Future接口实现有返回结果的线程
Callable接口与Runnable类似,Runnable无返回结果;ExecutorService接口是Executor接口的拓展
public class MyCallable implements Callable<Object>{
private String taskName;
MyCallable(String taskName) {
this.taskName = taskName;
}
@Override
public Object call() throws Exception {
return taskName;
}
}
int poolSize = 10;
// 创建大小为10的 线程池
ExecutorService pool = Executors.newFixedThreadPool(poolSize);
// 创建任务
List<Future> taskList = new ArrayList<Future>();
for (int i = 0; i < taskSize; i++) {
Callable c = new MyCallable("task "+i);
// 执行任务并获取Future对象
Future f = pool.submit(c);
// 添加到任务列表
taskList.add(f);
}
// 关闭线程池
pool.shutdown();
// 获取所有并发任务的运行结果
for (Future f : taskList) {
// 从Future对象上获取任务的返回值,并输出到控制台
try {
// 通过f.get()获得返回结果 ,do something
...
}catch (Exception e){
// 错误处理
...
}
}
4、FutureTask类和Callable接口实现线程
FutureTask是一个包装类,它同时实现了Future和Runnable接口,可以通过Callable实例来创建
public class MyCallable implements Callable<Object>{
private String taskName;
MyCallable(String taskName) {
this.taskName = taskName;
}
@Override
public Object call() throws Exception {
return taskName;
}
}
Callable c = new MyCallable("my task");
FutureTask<String> oneTask = new FutureTask<String>(c);
Thread cThread = new Thread(oneTask);
cThread.start();
Spring boot多线程
在spring的项目中,由于Bean对象是spring容器管理,我们可以自定义一个类,然后注册成bean的方式使用java多线程,比如我们使用上面第3种方法
MyCallable.class
import java.util.concurrent.Callable;
public class MyCallable implements Callable<Object>{
private String taskName;
MyCallable(String taskName) {
this.taskName = taskName;
}
@Override
public Object call() throws Exception {
return taskName;
}
}
TaskService.class
import org.springframework.stereotype.Service;
import java.util.concurrent.*;
@Service
public class TaskService {
ExecutorService executorService;
private int taskSize = 10;
public TaskService() {
if (executorService == null) {
executorService = Executors.newFixedThreadPool(taskSize);
}
}
public void execute(Runnable r) {
executorService.execute(r);
}
public <T> Future<T> submit(Callable<T> task) {
return executorService.submit(task);
}
}
这里直接使用测试方法
TaskServiceTest.class
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.Future;
/**
* demo test
*/
public class TaskServiceTest extends BaseTest {
@Autowired
private TaskService taskService;
@Test
public void main(){
List<Future> list = new ArrayList<Future>();
for (int i = 0; i < 10; i++) {
Callable c = new MyCallable("task "+i);
// 执行任务并获取Future对象
Future f = taskService.submit(c);
list.add(f);
}
// 获取所有并发任务的运行结果
for (Future f : list) {
// 从Future对象上获取任务的返回值,并输出到控制台
try {
System.out.println(f.get().toString());
}catch (Exception e){
e.printStackTrace();
}
}
}
}