039 三种实现多线程的方式

继承Thread类实现多线程

package com.xd.cubemall.juc;import lombok.extern.slf4j.Slf4j;/*** 1) 继承Thread类，实现多线程* extends Thread* 2) 实现Runnable接口，实现多线程* 3) FutureTask实现多线程*/
@Slf4j
public class ThreadDemo {public static void main(String[] args) {System.out.println("thread...........start........");//创建多线程对象ThreadA threadA = new ThreadA();//开启线程threadA.start();System.out.println("thread...........end........");}//多线程第一种实现方式: extends Threadpublic static  class ThreadA extends Thread{// run是线程执行主体; 多线程业务在run方法中运行@Overridepublic void run() {log.info("继承Thread实现方式......");//业务代码执行int i = 100/3;log.info("业务代码执行结果：{}， 线程名称：{}， 线程ID：{}",i,this.getName(),this.getId());}}}

实现Runnable接口实现多线程

package com.xd.cubemall.juc;import lombok.extern.slf4j.Slf4j;/*** 1) 继承Thread类，实现多线程* extends Thread* 2) 实现Runnable接口，实现多线程* 普通构建方式:*         //创建多线程对象*         Thread02 thread02 = new Thread02();*         Thread thread = new Thread(thread02);**         //开启线程*         thread.start();*  匿名内部类构建方式:*          Runnable runnable = new Runnable() {*             @Override*             public void run() {*                 log.info("实现Runnable接口实现方式......");*                 //业务代码执行*                 int i = 100/3;*                 log.info("业务代码执行结果：{}",i);*             }*         };**         // 创建线程对象*         Thread thread = new Thread(runnable);*         // 开启线程执行*         thread.start();**   lambda表达式构建方式:*           new Thread(()->{*             log.info("实现Runnable接口实现方式......");*             //业务代码执行*             int i = 100/3;*             log.info("业务代码执行结果：{}",i);*         }).start();**   lambda表达式特点:*   1 @FunctionalInterface：此注解表示可以使用lambda表达式的编程方式，此注解相当于是一个标识*   2 接口只有一个方法(必须满足)-- 即使没有上面注解，也可以使用lambda表达式，程序会在后台自动识别*   语法形式:*   方法括号(有参写，无参不写) -> {业务执行方法体}* 3) Callable + FutureTask实现多线程*/
@Slf4j
public class ThreadDemo {public static void main(String[] args) {System.out.println("thread...........start........");new Thread(()->{log.info("实现Runnable接口实现方式......");//业务代码执行int i = 100/3;log.info("业务代码执行结果：{}",i);}).start();System.out.println("thread...........end........");}// 02-实现Runnable接口，实现多线程public static class Thread02 implements Runnable{@Overridepublic void run() {log.info("实现Runnable接口实现方式......");//业务代码执行int i = 100/3;log.info("业务代码执行结果：{}",i);}}
}

Callable + FutureTask实现多线程

package com.xd.cubemall.juc;import lombok.extern.slf4j.Slf4j;import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;/*** 1) 继承Thread类，实现多线程* extends Thread* 2) 实现Runnable接口，实现多线程* 普通构建方式:*         //创建多线程对象*         Thread02 thread02 = new Thread02();*         Thread thread = new Thread(thread02);**         //开启线程*         thread.start();*  匿名内部类构建方式:*          Runnable runnable = new Runnable() {*             @Override*             public void run() {*                 log.info("实现Runnable接口实现方式......");*                 //业务代码执行*                 int i = 100/3;*                 log.info("业务代码执行结果：{}",i);*             }*         };**         // 创建线程对象*         Thread thread = new Thread(runnable);*         // 开启线程执行*         thread.start();**   lambda表达式构建方式:*           new Thread(()->{*             log.info("实现Runnable接口实现方式......");*             //业务代码执行*             int i = 100/3;*             log.info("业务代码执行结果：{}",i);*         }).start();**   lambda表达式特点:*   1 @FunctionalInterface：此注解表示可以使用lambda表达式的编程方式，此注解相当于是一个标识*   2 接口只有一个方法(必须满足)-- 即使没有上面注解，也可以使用lambda表达式，程序会在后台自动识别*   语法形式:*   方法括号(有参写，无参不写) -> {业务执行方法体}** 3) Callable + FutureTask实现多线程* jdk1.5后： 添加callable接口，实现多线程，相较于Thread，runnable接口没有返回值，但是callable接口是有返回值* @FunctionalInterface: 支持lambda表达式写法* public interface Callable<V>：* 1.具有泛型的接口，只有一个方法call，call方法就是多线程执行业务主体，* 2.方法执行完毕后有返回值，返回值类型就是指定的泛型类型* 疑问：多线程执行必须和Thread有关系，callable接口和Thread有什么关系？**** 普通方式*         // 创建对象: 实现了callable接口对象*         Thread03 thread03 = new Thread03();*         // 创建futureTask对象，把thread03对象传递构造函数中*         FutureTask<Integer> task = new FutureTask<Integer>(thread03);**         // 创建多线程对象*         Thread thread = new Thread(task);*         // 开启线程执行*         thread.start();**         // 等待子线程执行结束后，获取返回结果*         try {**             // 同步阻塞，必须等待异步线程执行结束，且返回结果后，再继续往下执行*             Integer integer = task.get();**             System.out.println("子线程执行结果："+integer);*         } catch (InterruptedException e) {*             e.printStackTrace();*         } catch (ExecutionException e) {*             e.printStackTrace();*         }*** 匿名内部类方式*         Callable<Integer> callable = new Callable<Integer>() {*             @Override*             public Integer call() throws Exception {*                 log.info("实现callable接口实现方式......");*                 //业务代码执行*                 int i = 100/3;*                 log.info("业务代码执行结果：{}",i);*                 return i;*             }*         };****         // 创建futureTask对象，把thread03对象传递构造函数中*         FutureTask<Integer> task = new FutureTask<Integer>(callable);**         // 创建多线程对象*         Thread thread = new Thread(task);*         // 开启线程执行*         thread.start();**         // 等待子线程执行结束后，获取返回结果*         try {**             // 同步阻塞，必须等待异步线程执行结束，且返回结果后，再继续往下执行*             Integer integer = task.get();**             System.out.println("子线程执行结果："+integer);*         } catch (InterruptedException e) {*             e.printStackTrace();*         } catch (ExecutionException e) {*             e.printStackTrace();*         }** 3 lambda表达式方式*         FutureTask<Integer> task = new FutureTask<Integer>(()->{*             log.info("实现callable接口实现方式......");*             //业务代码执行*             int i = 100/3;*             log.info("业务代码执行结果：{}",i);*             return i;*         });******/
@Slf4j
public class ThreadDemo {public static void main(String[] args) {System.out.println("thread...........start........");// 创建对象: 实现了callable接口对象// 创建futureTask对象，把thread03对象传递构造函数中FutureTask<Integer> task = new FutureTask<Integer>(()->{log.info("实现callable接口实现方式......");//业务代码执行int i = 100/3;log.info("业务代码执行结果：{}",i);return i;});// 创建多线程对象Thread thread = new Thread(task);// 开启线程执行thread.start();// 等待子线程执行结束后，获取返回结果try {// 同步阻塞，必须等待异步线程执行结束，且返回结果后，再继续往下执行Integer integer = task.get();System.out.println("子线程执行结果："+integer);} catch (InterruptedException e) {e.printStackTrace();} catch (ExecutionException e) {e.printStackTrace();}System.out.println("thread...........end........");}// 03-实现callable接口，实现多线程public static class Thread03 implements Callable<Integer>{// 业务执行主体@Overridepublic Integer call() throws Exception {log.info("实现callable接口实现方式......");//业务代码执行int i = 100/3;log.info("业务代码执行结果：{}",i);return i;}}}