JAVA多线程+线程池学习

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 + "个线程");
                }
            });
        }
    }


}