JAVA多线程异步与线程池------JAVA

初始化线程的四种方式
继承Thread
实现Runnable接口
实现Callable接口+FutureTask(可以拿到返回结果,可以处理异常)
线程池

继承Thread和实现Runnable接口的方式,主进程无法获取线程的运算结果,不适合业务开发
实现Callable接口+FutureTask可以获取线程内的返回结果,但是不利于控制服务器的线程资源,容易导致资源耗尽
通过线程池的方式性能稳定,且可以获取结果,并捕获异常
但是在复杂业务下,我们可能会出现一个异步依赖另一个异步的情况

初始化线程的四种方式
继承Thread
实现Runnable接口
实现Callable接口+FutureTask(可以拿到返回结果,可以处理异常)
线程池

继承Thread和实现Runnable接口的方式,主进程无法获取线程的运算结果,不适合业务开发
实现Callable接口+FutureTask可以获取线程内的返回结果,但是不利于控制服务器的线程资源,容易导致资源耗尽
通过线程池的方式性能稳定,且可以获取结果,并捕获异常
但是在复杂业务下,我们可能会出现一个异步依赖另一个异步的情况

package com.alatus.testmvc;

import java.util.concurrent.*;

public class ThreadTest {
    public static ExecutorService service = Executors.newFixedThreadPool(10);
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main"+Thread.currentThread().getId());
        Thread thread = new Thread01();
        Runable01 runable01 = new Runable01();
        thread.start();
        new Thread(runable01).start();
//        FutureTask甚至可以接收一个Runnable,只是需要一个对象来接收返回值而已
        Integer result = new Integer(0);
        FutureTask<Integer> futureTask = new FutureTask<>(new Runable01(),result);
        FutureTask<Integer> integerFutureTask = new FutureTask<>(new Callable01());
        new Thread(integerFutureTask).start();
//        FutureTask的这个get方法会等待整个线程执行完成,获取返回结果
//        它是一个阻塞等待
        Integer i = integerFutureTask.get();
        new Thread(futureTask).start();
        Integer i1 = futureTask.get();
        System.out.println(i1);
        System.out.println(i);
//        应该把任务直接提交给线程池
//        当前系统中,最好只有一个或两个线程池,是系统共用的
//        每一个异步任务都把业务提交给线程池处理即可
//        使用线程池的好处是,可以控制资源,比方说对应内存下只能容纳对应线程数量,性能稳定
//        不会导致资源耗尽的问题
        service.execute(runable01);
    }
    public static class Thread01 extends Thread{
        @Override
        public void run() {
            System.out.println("当前线程"+Thread.currentThread().getId());
        }
    }
    public static class Runable01 implements Runnable{
        @Override
        public void run() {
            System.out.println("当前线程"+Thread.currentThread().getId());
        }
    }
    public static class Callable01 implements Callable<Integer>{

        @Override
        public Integer call() throws Exception {
            Thread.sleep(2000);
            return 1+1;
        }
    }
}

package com.alatus.testmvc;

import java.util.concurrent.*;

public class ThreadTest {
    public static ExecutorService service = Executors.newFixedThreadPool(10);
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main"+Thread.currentThread().getId());
        Thread thread = new Thread01();
        Runable01 runable01 = new Runable01();
        thread.start();
        new Thread(runable01).start();
//        FutureTask甚至可以接收一个Runnable,只是需要一个对象来接收返回值而已
        Integer result = new Integer(0);
        FutureTask<Integer> futureTask = new FutureTask<>(new Runable01(),result);
        FutureTask<Integer> integerFutureTask = new FutureTask<>(new Callable01());
        new Thread(integerFutureTask).start();
//        FutureTask的这个get方法会等待整个线程执行完成,获取返回结果
//        它是一个阻塞等待
        Integer i = integerFutureTask.get();
        new Thread(futureTask).start();
        Integer i1 = futureTask.get();
        System.out.println(i1);
        System.out.println(i);
//        应该把任务直接提交给线程池
//        当前系统中,最好只有一个或两个线程池,是系统共用的
//        每一个异步任务都把业务提交给线程池处理即可
//        使用线程池的好处是,可以控制资源,比方说对应内存下只能容纳对应线程数量,性能稳定
//        不会导致资源耗尽的问题
        service.execute(runable01);
    }
    public static class Thread01 extends Thread{
        @Override
        public void run() {
            System.out.println("当前线程"+Thread.currentThread().getId());
        }
    }
    public static class Runable01 implements Runnable{
        @Override
        public void run() {
            System.out.println("当前线程"+Thread.currentThread().getId());
        }
    }
    public static class Callable01 implements Callable<Integer>{

        @Override
        public Integer call() throws Exception {
            Thread.sleep(2000);
            return 1+1;
        }
    }
}