java多线程和spring多线程实现

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();
}
}
}
}