java多线程的创建 java创建多线程有哪些方式

目录

• 一、继承Thread类的方式
• 二、实现Runnable接口的方式
• 三、匿名内部类的方式
• 四、带返回值的方式
• 五、定时器方式
• 六、线程池的方式
• 七、Spring实现多线程（Spring的异步任务）
• 八、lambda表达式方式（jdk1.8提供的lambda表达式进行并行计算）

一、继承Thread类的方式

1、模拟示例代码如下：

package com.rf.springboot01.concurrentAndThread.t2;
/**
 * @description: 创建多线程的方式：1、继承Thread类的方式
 * @author: xiaozhi
 * @create: 2020-07-08 09:39
 */
public class Demo1 extends Thread{
    private int count =5;

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+"正在运行。。。。。");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Thread thread1 = new Thread(new Demo1());
        Thread thread2 = new Thread(new Demo1());
        thread1.start();
        thread2.start();
    }
}

2、输出结果如下：

二、实现Runnable接口的方式

1、模拟示例代码如下：

package com.rf.springboot01.concurrentAndThread.t2;
/**
 * @description: 创建多线程的方式：2、实现Runnable接口的方式
 * @author: xiaozhi
 * @create: 2020-07-08 09:32
 */
public class Demo2 implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+"正在运行。。。。");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(new Demo2());
        Thread t2 = new Thread(new Demo2());
        t1.start();
        t2.start();
    }
}

2、输出结果如下：

三、匿名内部类的方式

1、模拟示例代码如下：

package com.rf.springboot01.concurrentAndThread.t2;
/**
 * @description: 创建多线程的方式：3、匿名内部类的方式
 * @author: xiaozhi
 * @create: 2020-07-08 09:48
 */
public class Demo3 {

    //第一种情况：匿名内部类继承Thread类创建线程的方式
    public static void test1(){
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println(Thread.currentThread().getName()+"=====匿名内部类继承Thread类创建线程的方式");
                }
            }
        }.start();
    }

    //第二种情况：匿名内部类实现Runnable接口创建线程的方式
    public static void test2(){
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println(Thread.currentThread().getName()+"=====匿名内部类实现Runnable接口创建线程的方式");
                }
            }
        }).start();
    }
    //第三种情况：匿名内部类中继承Thread类创建线程的方式同时又实现Runnable接口创建线程的方式
    //输出的结果以继承Thread类中的结果为准。
    public static void test3(){
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println(Thread.currentThread().getName() + "---------->实现Runnable接口创建线程的方式");
                }
            }
        }){
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println(Thread.currentThread().getName() + "---------->继承Thread类创建线程的方式");
                }
            }
        }.start();

    }
    public static void main(String[] args) {
        test1();
        test2();
        test3();

    }
}

2、输出结果如下：

四、带返回值的方式

1、模拟示例代码如下：

package com.rf.springboot01.concurrentAndThread.t2;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
 * @description:  创建多线程的方式：4、带返回值的方式
 * @author: xiaozhi
 * @create: 2020-07-08 10:15
 */
public class Demo4 implements Callable<Integer> {

    //重写call方法，call方法内计算求和
    @Override
    public Integer call() throws Exception {
        int count=0;
        for(int i=0;i<10;i++){
            count+=i;
            System.out.println("正在计算求和："+count);
        }
        return count;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Demo4 d = new Demo4();
        FutureTask<Integer> futureTask=new FutureTask<Integer>(d);

        Thread thread = new Thread(futureTask);
        thread.start();

        Integer result = futureTask.get();//获取线程的返回值
        System.out.println("线程执行的结果："+result);
    }
}

2、输出结果如下：

五、定时器方式

1、模拟示例代码如下：

package com.rf.springboot01.concurrentAndThread.t2;
import java.util.Timer;
import java.util.TimerTask;
/**
 * @description: 创建多线程的方式：5、定时器方式
 * @author: xiaozhi
 * @create: 2020-07-08 10:33
 */
public class Demo5 {
    public static void main(String[] args) {
        Timer timer=new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                //实现定时任务
                System.out.println("每隔一秒执行一次");
            }
        },0,1000);
    }
}

2、输出结果如下：

六、线程池的方式

1、模拟示例代码如下：

package com.rf.springboot01.concurrentAndThread.t2;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * @description: 创建多线程的方式：6、线程池的方式
 * @author: xiaozhi
 * @create: 2020-07-08 13:42
 */
public class Demo6 {
    public static void main(String[] args) {
        //创建一个固定大小的线程池
        Executor threadPool= Executors.newFixedThreadPool(10);
        for(int i=0;i<20;i++){
            //在将来的某个时间执行给定的命令。命令可以在新线程、池线程或调用中执行线程
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                }
            });
        }
        //在之前提交的文件中启动有序关机执行任务，但不接受新任务。如果已经关闭，调用没有额外的影响
        ((ExecutorService) threadPool).shutdown();
    }
}

2、输出结果如下：

七、Spring实现多线程（Spring的异步任务）

1、模拟示例代码如下：
1）、创建maven项目并且pom文件中引入spring-context依赖

<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.0.RELEASE</version>
</dependency>

2）、创建配置类

package com.rf.springboot01.concurrentAndThread.t3;

import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.Executor;
/**
 * @description:
 * @author: xiaozhi
 * @create: 2020-07-08 13:57
 */
@Configuration
@ComponentScan("com.rf.springboot01.concurrentAndThread.t3")
@EnableAsync
public class Demo7Config implements AsyncConfigurer {
    //注册执行器
    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        taskExecutor.setCorePoolSize(10);
        taskExecutor.setMaxPoolSize(80);
        taskExecutor.setQueueCapacity(100);
        taskExecutor.initialize();//如果不初始化，导致找到不到执行器
        return taskExecutor;
    }
    // 用于捕获异步异常
    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return null;
    }
}

3）、创建service类

package com.rf.springboot01.concurrentAndThread.t3;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
/**
 * @description:
 * @author: xiaozhi
 * @create: 2020-07-08 14:03
 */
@Service
public class Demo7Service {

    @Async
    public void a(){
       for(int i=0;i<5;i++){
            System.out.println("a......");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    @Async
    public void b(){
        for(int i=0;i<5;i++){
            System.out.println("b。。。");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

4）、创建测试类

package com.rf.springboot01.concurrentAndThread.t3;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
/**
 * @description: 创建多线程的方式：7、Spring的异步任务
 * @author: xiaozhi
 * @create: 2020-07-08 14:06
 */
public class Demo7Test {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext=new AnnotationConfigApplicationContext(Demo7Config.class);
        Demo7Service ds = applicationContext.getBean(Demo7Service.class);
        ds.a();
        ds.b();
    }
}

2、输出结果如下：

八、lambda表达式方式（jdk1.8提供的lambda表达式进行并行计算）

1、模拟示例代码如下：

package com.rf.springboot01.concurrentAndThread.t2;


import java.util.Arrays;
import java.util.List;

/**
 * @description: 创建多线程的方式：8、jdk1.8提供的lambda表达式进行并行计算
 * @author: xiaozhi
 * @create: 2020-07-08 15:14
 */
public class Demo8 {
    public int add(List<Integer> list){
        System.out.println("stream方法串行执行开始，每一个值输出的顺序是确定的");
        list.stream().forEach(System.out::println);
        System.out.println("parallelStream方法并行执行开始，每一个值输出的顺序是不确定的");
        list.parallelStream().forEach(System.out::println);
        System.out.println("parallelStream方法并行执行,并且使用forEachOrdered方法排序开始");
        list.parallelStream().forEachOrdered(System.out::println);
        return list.parallelStream().mapToInt(a->a).sum();
    }

    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(10,20,30,40);
        int result = new Demo8().add(list);
        System.out.println("计算结果为："+result);
    }
}

2、输出结果如下：