JAVA多线程+线程池学习

落日映苍穹つ 2022-01-15 20:41 513阅读 0赞

# JAVA多线程学习 #

#### Java 多线程编程 ####

多线程理论相关可直接上https://www.runoob.com/java/java-multithreading.html查看

代码如下：  
main方法执行时将其他同名函数改名

package com;
    
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.concurrent.*;
    
    /**
     * @ClassName ThreadPoolExecutorTest
     * @Description 多线程+线程池学习
     * @Author 
     * @Data 2019/6/13
     */
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class ThreadPoolExecutorTest {
    
        //多线程使用，集成Thead并重写run方法
        //执行结果
    //    我是第一个子线程0
    //    我是第一个子线程1
    //    我是第一个子线程2
    //    我是第一个子线程3
    //    我是第一个子线程4
    //    我是第二个子线程0
    //    我是第二个子线程1
    //    我是第二个子线程2
    //    我是第二个子线程3
    //    我是第二个子线程4
        public static void main4(String[] args) throws InterruptedException {
            //多线程编程之机场Thread类执行
            class ExtendThread extends Thread{
    
                private String task;
    
                public ExtendThread(String task){
                    this.task = task;
                }
    
                //集成Thread类并重写run方法
                @Override
                public void run(){
                    for(int i=0; i<5; i++){
                        System.out.println(task+i);
                    }
                }
    
            }
            ExtendThread extendThread = new ExtendThread("我是第一个子线程");
            ExtendThread extendThread1 = new ExtendThread("我是第二个子线程");
            extendThread1.start();
            extendThread.start();
        }
    
    
        //通过实现 Runnable 接口来创建线程
        //执行结果
    //   我是子线程0
    //   我是子线程1
    //   我是子线程2
    //   我是主线程
        public static void main5(String[] args) throws InterruptedException {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for(int i=0; i<3; i++){
                        System.out.println("我是子线程" + i);
                    }
                }
            }).start();
            Thread.sleep(1000);//延迟一秒执行
            System.out.println("我是主线程");
        }
    
        //通过 Callable 和 Future 创建线程
        //创建 Callable 接口的实现类，并实现 call() 方法，该 call() 方法将作为线程执行体，并且有返回值。
        //创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值
        //使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。
        //调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值。
        //执行结果
    //    我是返回值
        public static void main6(String[] args) throws ExecutionException, InterruptedException {
    
            class Call implements Callable<String>{
                @Override
                public String call() throws Exception {
                    return "我是返回值";
                }
            }
    
            //使用FutureTask来执行任务，task.get()获取值
            FutureTask<String> task = new FutureTask<String>(new Call());
            new Thread(task).start();
            System.out.println(task.get());
    
        }
    
        //　Callable 和 Future接口的区别
        //（1）Callable规定的方法是call()，而Runnable规定的方法是run().
        //（2）Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。
        //（3）call()方法可抛出异常，而run()方法是不能抛出异常的。
        //（4）运行Callable任务可拿到一个Future对象， Future表示异步计算的结果。
        // 它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。
        // 通过Future对象可了解任务执行情况，可取消任务的执行，还可获取任务执行的结果。
        // Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。
    
        // Executors.newCacheThreadPool()：可缓存线程池，
        // 先查看池中有没有以前建立的线程，如果有，就直接使用。如果没有，就建一个新的线程加入池中，缓存型池子通常用于执行一些生存期很短的异步型任务
        // 执行结果，线程池为无限大，当执行当前任务时上一个任务已经完成，会复用执行上一个任务的线程，而不用每次新建线程
        // excute与submit的区别在于是否有返回值，excute无返回值，submit返回值被包装在Future中
    //    pool-1-thread-1正在被执行
    //            返回值0
    //    pool-1-thread-1正在被执行
    //            返回值1
    //    pool-1-thread-2正在被执行
    //            返回值2
    //    pool-1-thread-1正在被执行
    //            返回值3
    //    pool-1-thread-1正在被执行
    //            返回值4
        @Test
        public void cachedThreadPool() throws ExecutionException, InterruptedException {
            ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
            for(int i=0;i<5;i++){
                final int index = i;
                //execute无返回值 Runnable无返回值
                cachedThreadPool.execute(new Runnable() {
                    @Override
                    public void run() {
                        System.out.println(Thread.currentThread().getName()+"正在被执行");
                    }
                });
                //submit有返回值 Callable有返回值
                Future<String> a = cachedThreadPool.submit(new Callable<String>() {
                    @Override
                    public String call() throws Exception {
                        return "返回值"+index;
                    }
                });
                System.out.println(a.get());
            }
    
        }
    
        //Executors.newFixedThreadPool(int n)：创建一个可重用固定个数的线程池，以共享的无界队列方式来运行这些线程。
        //执行结果
    //    pool-1-thread-1正在执行
    //    pool-1-thread-3正在执行
    //    pool-1-thread-2正在执行
    //    pool-1-thread-1正在执行
    //    pool-1-thread-3正在执行
    //    pool-1-thread-2正在执行
    //    pool-1-thread-1正在执行
    //    pool-1-thread-2正在执行
    //    pool-1-thread-3正在执行
    //    pool-1-thread-1正在执行
        //因为线程池大小为3，每个任务输出打印结果后sleep 1秒，所以每秒打印3个结果。
        //定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()
        public static void main1(String[] args){
            ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
            for(int i=0;i<10;i++){
                fixedThreadPool.execute(new Runnable() {
                    @Override
                    public void run() {
                        try{
                            System.out.println(Thread.currentThread().getName()+"正在执行");
                            Thread.sleep(1000);
                        }catch (Exception e){
                            e.printStackTrace();
                        }
    
                    }
                });
            }
        }
    
        //Executors.newScheduledThreadPool(int n)：创建一个定长线程池，支持定时及周期性任务执行
        //执行结果
    //    系统时间2019-06-13 11:41:51
    //    执行时间12019-06-13 11:41:52
    //    延迟1秒执行
    //    执行时间22019-06-13 11:41:52
    //    延迟1秒后每2秒执行一次
    //    执行时间22019-06-13 11:41:54
    //    延迟1秒后每2秒执行一次
    //    执行时间22019-06-13 11:41:56
    //    延迟1秒后每2秒执行一次
    //    执行时间22019-06-13 11:41:58
    //    延迟1秒后每2秒执行一次
        public static void main2(String[] args){
            ExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
            System.out.println("系统时间" + df.format(new Date()));
            //延迟一秒执行
            ((ScheduledExecutorService) scheduledThreadPool).schedule(new Runnable() {
                @Override
                public void run() {
                    System.out.println("执行时间1" + df.format(new Date()));
                    System.out.println("延迟1秒执行");
                }
            },1,TimeUnit.SECONDS);
    
            //延迟1秒执行后每2秒执行一次
            ((ScheduledExecutorService) scheduledThreadPool).scheduleAtFixedRate(new Runnable() {
                @Override
                public void run() {
                    System.out.println("执行时间2" + df.format(new Date()));
                    System.out.println("延迟1秒后每2秒执行一次");
                }
            },1, 2,TimeUnit.SECONDS);
        }
    
        //Executors.newSingleThreadExecutor()：创建一个单线程化的线程池，
        // 它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
        //执行结果
    //    pool-1-thread-1正在执行第0个线程
    //    pool-1-thread-1正在执行第1个线程
    //    pool-1-thread-1正在执行第2个线程
    //    pool-1-thread-1正在执行第3个线程
    //    pool-1-thread-1正在执行第4个线程
        public static void main3(String[] args){
            ExecutorService singleThread = Executors.newSingleThreadExecutor();
            for(int i=0;i<5;i++){
                final int index = i;
                singleThread.execute(new Runnable() {
                    @Override
                    public void run() {
                        System.out.println(Thread.currentThread().getName() + "正在执行第" + index + "个线程");
                    }
                });
            }
        }
    
    
    }