线程、线程池

布满荆棘的人生 2022-10-22 04:27 250阅读 0赞

创建线程的3种方法：

package com.frank.threadPool.createThread;
    
    /**
     * @author 小石潭记
     * @date 2021/4/4 13:56
     * @Description: ${todo}
     */
    public class ExtendsThread extends Thread {
        @Override
        public void run() {
            System.out.println("通过继承创建线程！");
        }
    }
    
    
    
    
    package com.frank.threadPool.createThread;
    
    /**
     * @author 小石潭记
     * @date 2021/4/4 13:56
     * @Description: ${todo}
     */
    public class ImplementThread implements Runnable {
    
        int i = 0;
    
        public ImplementThread(int i) {
            this.i = i;
        }
    
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "--" + i);
            try {
                Thread.sleep(1000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    
    
    
    package com.frank.threadPool.createThread;
    
    import java.util.concurrent.Callable;
    
    /**
     * @author 小石潭记
     * @date 2021/4/4 14:06
     * @Description: ${todo}
     */
    public class ImplementCallable implements Callable {
        @Override
        public Object call() throws Exception {
            return "成功执行！";
        }
    }
    
    
    
    
    
    package com.frank.threadPool.createThread;
    
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    
    /**
     * @author 小石潭记
     * @date 2021/4/4 13:57
     * @Description: ${todo}
     */
    public class MainTest {
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            // 1.使用继承创建线程
            ExtendsThread extendsThread = new ExtendsThread();
            extendsThread.start();
    
            // 2.通过实现runnable创建线程
            Thread thread = new Thread(new ImplementThread(10));
            thread.start();
    
            // 3.实现callable接口
            // 3.1 创建futureTask实例，创建callable实例
            FutureTask<String> task = new FutureTask<String>(new ImplementCallable());
            Thread thread1 = new Thread(task, "myCallable");
            thread1.start();
            String result = task.get();
            System.out.println("callable执行返回的结果：" + result);
        }
    }

常用的线程池：

package com.frank.threadPool;
    
    import java.util.concurrent.*;
    
    /**
     * @author 小石潭记
     * @date 2021/4/3 11:09
     * @Description: ${todo}
     */
    public class CachedThreadPool {
        public static void main(String[] args) {
            // todo 任务太多太多 cpu 100% 不一定 oom 内存溢出
            Executors.newCachedThreadPool();
            // corePoolSize：核心员工 maximumPoolSize - 非核心员工 当前核心员工就是0
            // maximumPoolSize：最大的线程数 int最大值
            // 非核心员工：maximumPoolSize - corePoolSize = int最大值
            // 同步队列
            new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                    60L, TimeUnit.SECONDS,
                    new SynchronousQueue<Runnable>());
    
        }
    }
    
    
    
    
    package com.frank.threadPool;
    
    import java.util.concurrent.*;
    
    /**
     * @author 小石潭记
     * @date 2021/4/3 11:09
     * @Description: ${todo}
     */
    public class FixedThreadPool {
        public static void main(String[] args) {
            // todo 任务太多太多 oom 内存溢出
            Executors.newFixedThreadPool(10);
            // corePoolSize：核心员工 maximumPoolSize - 非核心员工 当前核心员工就是10
            // maximumPoolSize：最大的线程数 10
            // 非核心员工：maximumPoolSize - corePoolSize = 0
            // 链式阻塞队列 大小int最大值  内存装载任务
            new ThreadPoolExecutor(10, 10,
                    0L, TimeUnit.MILLISECONDS,
                    new LinkedBlockingQueue<Runnable>());
            // 例如100个task   首先0-10 给核心员工完成，11-20存入队列中 21-30等待前面的完成...
    
        }
    }
    
    
    
    
    package com.frank.threadPool;
    
    import java.util.concurrent.Executors;
    import java.util.concurrent.LinkedBlockingQueue;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;
    
    /**
     * @author 小石潭记
     * @date 2021/4/3 11:09
     * @Description: ${todo}
     */
    public class SingleThreadPool {
        public static void main(String[] args) {
            // todo 任务太多太多 oom 内存溢出
            Executors.newSingleThreadExecutor();
            // corePoolSize：核心员工 maximumPoolSize - 非核心员工 当前核心员工就是1
            // maximumPoolSize：最大的线程数 1
            // 非核心员工：maximumPoolSize - corePoolSize = 0
            // 链式阻塞队列 大小int最大值
            new ThreadPoolExecutor(1, 1,
                    0L, TimeUnit.MILLISECONDS,
                    new LinkedBlockingQueue<Runnable>());
            // 100个task  1给核心员工   2-100存入链式阻塞队列中...
        }
    }
    
    
    package com.frank.threadPool;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Random;
    
    /**
     * @author 小石潭记
     * @date 2021/4/3 10:10
     * @Description: ${todo}
     */
    public class Test1 {
    
        public static void main(String[] args) throws InterruptedException {
            long start = System.currentTimeMillis();
            final Random random = new Random();
            final List<Integer> list = new ArrayList<>();
            for (int i = 0; i < 10000; i++) {
                Thread thread = new Thread(() -> list.add(random.nextInt()));
                thread.start();
                thread.join();
            }
    
            System.out.println("时间：" + (System.currentTimeMillis() - start));
            System.out.println("大小：" + list.size());
    
        }
    
    }
    
    
    
    
    
    package com.frank.threadPool;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Random;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.TimeUnit;
    
    /**
     * @author 小石潭记
     * @date 2021/4/3 10:10
     * @Description: ${todo}
     */
    public class Test2 {
    
        public static void main(String[] args) throws InterruptedException {
            long start = System.currentTimeMillis();
            final Random random = new Random();
            final List<Integer> list = new ArrayList<>();
    
            ExecutorService executorService = Executors.newSingleThreadExecutor();
            for (int i = 0; i < 10000; i++) {
                executorService.execute(() -> list.add(random.nextInt()));
            }
            executorService.shutdown();
            executorService.awaitTermination(1, TimeUnit.DAYS);
            System.out.println("时间：" + (System.currentTimeMillis() - start));
            System.out.println("大小：" + list.size());
    
        }
    
    }
    
    
    
    
    
    
    package com.frank.threadPool;
    
    import java.util.concurrent.*;
    
    /**
     * @author 小石潭记
     * @date 2021/4/3 10:10
     *
     * @Description: return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
     *                                       60L, TimeUnit.SECONDS,
     *                                       new SynchronousQueue<Runnable>());
     */
    public class Test3 {
    
        public static void main(String[] args) throws InterruptedException {
            long start = System.currentTimeMillis();
            // 同步的队列
            ExecutorService executorService1 = Executors.newCachedThreadPool(); //1054
            ExecutorService executorService2 = Executors.newFixedThreadPool(10); //10017
            ExecutorService executorService3 = Executors.newSingleThreadExecutor(); // 100056
            // 自定义线程池
            // 第31个就开始异常了
            // 核心员工10个 最大值20个 非核心员工也是20-10=10个，核心员工1-10，
            // 11-20存入队列中，21-30存入非核心员工，31-40时，无法交付，则抛出异常，被拒绝
            // 提交优先级 核心员工 > 队列 > 非核心员工
            // 执行优先级 核心员工 > 非核心员工 > 队列
            ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 20,
                    // 这里是设置非核心员工的“合同年限”（给线程续命的~~）
                    0L,
                    TimeUnit.MILLISECONDS,
                    new ArrayBlockingQueue<>(10));
            for (int i = 1; i <= 100; i++) {
                // execute() 里面三个if 则是提交优先级的判断  addWorker都会有这个方法
                // addWorker(Runnable firstTask, boolean core)
                //  private final class Worker
                //        extends AbstractQueuedSynchronizer
                //        implements Runnable
                // w = new Worker(firstTask); 这里的worker是实现了runnable接口
                // 查看run方法  Worker分核心和非核心 task任务不分
                // while (task != null || (task = getTask()) != null)  执行优先级
                // task不为空 则直接执行，否则才会去队列里面取
                threadPoolExecutor.execute(new MyTask(i));
            }
            // 阻止新来的任务提交，对已经提交了的任务不会产生任何影响。当已经提交的任务执行完后，
            // 它会将那些闲置的线程（idleWorks）进行中断，这个过程是异步的。
           /* executorService1.shutdown();
            // awaitTermination会一直等待，直到线程池状态为TERMINATED或者，
            // 等待的时间到达了指定的时间。
            executorService1.awaitTermination(1, TimeUnit.DAYS);
            System.out.println("时间：" + (System.currentTimeMillis() - start));*/
        }
    }
    
    class MyTask implements Runnable {
    
        int i = 0;
    
        public MyTask(int i) {
            this.i = i;
        }
    
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "--" + i);
            try {
                Thread.sleep(1000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    
    
    
    package com.frank.threadPool;
    
    import java.util.concurrent.LinkedBlockingQueue;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;
    
    /**
     * @author 小石潭记
     * @date 2021/4/3 11:09
     * @Description: ${todo}
     */
    public class Test4 {
        public static void main(String[] args) {
            // 自定义线程池
            // corePoolSize：核心员工 maximumPoolSize - 非核心员工
            // maximumPoolSize：最大的线程数
            // 非核心员工：maximumPoolSize - corePoolSize
            ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(100,
                    100,
                    0L,
                    TimeUnit.MILLISECONDS,
                    new LinkedBlockingQueue<Runnable>());
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2_size_16_color_FFFFFF_t_70][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2_size_16_color_FFFFFF_t_70]: /images/20221022/a76bb3e21f604a5a992562c511510136.png