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