高级JAVA必会系列一：常用线程池和调度类

最新推荐文章于 2024-07-26 22:36:20 发布

it_monkey_ali

最新推荐文章于 2024-07-26 22:36:20 发布

阅读量353

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/it_monkey_ali/article/details/80511306

版权

java 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

一、常用线程池

1.newCachedThreadPool

(1)缓存型池子，先查看池中有没有以前建立的线程，如果有，就复用，如果没有，就建立一个新的线程加入池中；

(2)缓存型池子，通常用于执行一些生存周期很短的异步型任务；因此一些面向连接的daemon型server中用得不多；

(3)能复用的线程，缺省超时时间是60s,超过这个IDLE时长，线程实例将被终止及移出池。

(4)注意，放入CachedThreadPool的线程不必担心其结束，超过超时时间,其会自动被终止

2.newFixedThreadPool

(1)newFixedThreadPool与cacheThreadPool差不多，也是能复用就用，但不能随时建新的线程

(2)其独特之处:任意时间点，最多只能有固定数目的活动线程存在，此时如果有新的线程要建立，只能放在另外的队列中等待，直到当前的线程中某个线程终止直接被移出池子

(3)FixedThreadPool多数针对一些很稳定很固定的正规并发线程，多用于服务器

3.ScheduledThreadPool

（1）调度型线程池

（2）这个池子里的线程可以按schedule依次delay执行，或周期执行

4.SingleThreadExecutor

（1）单例线程，任意时间池中只能有一个线程

（2）用的是和cache池和fixed池相同的底层池，但线程数目是1-1,0秒IDLE（无IDLE）

二、常用线程调度类

1.wait、notify、notifyAll

顾名思义，wait是等待，notify是通知一个等待线程、notifyAll唤醒所有等待线程。

2.CountDownLatch

很适合用来将一个任务分为n个独立的部分，等这些部分都完成后继续接下来的任务.隶属于java.util.concurrent.CountDownLatch类是一个同步计数器,构造时传入int参数,该参数就是计数器的初始值，每调用一次countDown()方法，计数器减1,计数器大于0 时，await()方法会阻塞程序继续执行.当多个线程达到预期时（latch.countDown()），唤醒多个其他等待中的线程，即执行latch.await()后面的代码。样例是，张三、李四合作完成任务，张三5秒，李四8秒，当张三李四都完成后，总任务结束。代码如下：

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.CountDownLatch;

/**
 * @author Tom
 */
public class CountDownLatchDemo {

    final static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    public static void main(String[] args) {
        CountDownLatch latch = new CountDownLatch(2);
        new Worker("张三", 5000, latch).start();
        new Worker("李四", 10000, latch).start();
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("all work done at:" + sdf.format(new Date()));
    }

    static class Worker extends Thread {
        String workerName;
        int workerTime;
        CountDownLatch latch;

        public Worker(String workerName,
                      int workerTime,
                      CountDownLatch latch) {
            this.workerName = workerName;
            this.workerTime = workerTime;
            this.latch = latch;
        }

        @Override
        public void run() {
            System.out.println("worker " + workerName + " do worker begin at:" + sdf.format(new Date()));
            doWork();
            System.out.println("worker " + workerName + " do worker complete at:" + sdf.format(new Date()));
            latch.countDown();
        }

        private void doWork() {
            try {
                Thread.sleep(workerTime);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

worker 李四 do worker begin at:2020-01-19 10:47:02
worker 张三 do worker begin at:2020-01-19 10:47:02
worker 张三 do worker complete at:2020-01-19 10:47:07
worker 李四 do worker complete at:2020-01-19 10:47:12
all work done at:2020-01-19 10:47:12

Process finished with exit code 0

测试可见，张三李四共同协作完成。

3.CyclicBarrier

适合多线程循环到达屏障后再执行,字面意思循环屏障，可理解为栅栏，协同多个线程都执行到barrier.await时，如果构造CyclicBarrier barrier=new CyclicBarrier(2, Runnable)时，第一个参数代码线程数，如果有第二参Runnable,那么所有线程都await时，先执行Runnable，再各自执行await后续的代码。

CyclicBarrier和CountDownLatch区别：

1.CountDownLatch在多个线程都执行完毕latch.countDown后唤醒await线程，多个countDown子线程在执行完countDown后可继续执行后续代码。

2.CyclicBarrier可循环使用，CountDownLatch只1次。见代码示例：

3.CountDownLatch需要latch.countDown和latch.await()配合使用。CyclicBarrier就一个barrier.await。

下面举例：鸟、鱼2个线程同时运行问题。

package com.retail.juc;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

/**
 * 问题:一个池塘有很多鸟和鱼,鸟每分钟产生一个后代,鱼每30s产生2个后代.
 * 鸟每10s吃掉一条鱼.建一个鱼塘,初始化一些鸟和鱼,看看什么时候鸟把鱼吃光
 *
 * @author Tom
 */
public class CyclicBarrierDemo {
    long time;
    long birdNum;
    long fishNum;
    Object lock = new Object();
    CyclicBarrier barrier;

    public CyclicBarrierDemo(long birdNum, long fishNum) {
        this.birdNum = birdNum;
        this.fishNum = fishNum;
    }

    public static void main(String[] args) {
        // 初始化5只鸟,20条鱼
        CyclicBarrierDemo bf = new CyclicBarrierDemo(5, 20);
        bf.start();
    }

    /**
     * 生态圈开启
     */
    private void start() {
        // 构造鸟,鱼,时间线
        FishThread fish = new FishThread();
        BirdThread bird = new BirdThread();
        TimeLine tl = new TimeLine();
        // 初始化环形屏障,当barrier的await被调用2次,执行tl线程
        // 如果大于调用的await的线程数,会死锁
        barrier = new CyclicBarrier(2, tl);
        fish.start();
        bird.start();
    }

    public class FishThread extends Thread {
        @Override
        public void run() {
            // 循环
            while (true) {
                System.out.println("鱼已经就位,到达await!");
                try {
                    // 进入睡眠,等待所有子任务都进入睡眠,再继续
                    barrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
                synchronized (lock) {
                    // 鱼每30s产生2个后代
                    if (time % 30 == 0) {
                        fishNum += fishNum * 2;
                        printInfo("鱼执行动作! ");
                    }
                }
            }

        }
    }

    public class BirdThread extends Thread {
        @Override
        public void run() {
            // 循环
            while (true) {
                System.out.println("鸟已经就位,到达await!");
                try {
                    // 进入睡眠,等待所有子任务都进入睡眠,再继续
                    barrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
                synchronized (lock) {
                    // 鸟每10s要吃掉一条鱼
                    if (time % 10 == 0) {
                        fishNum = fishNum >= birdNum ? fishNum - birdNum : 0;
                        // 鸟每分钟产生一个后代
                        if (time % 60 == 0) {
                            birdNum += birdNum;
                        }
                        printInfo("鸟动作执行! ");
                    }
                }
            }
        }
    }

    private class TimeLine implements Runnable {

        @Override
        public void run() {
            System.out.println("TimeLine start!");
            if (fishNum <= 0) {
                System.exit(-1);
            }
            // 时间加10s
            time += 10;
            System.out.println("TimeLine end,时间加10s");
        }
    }

    public void printInfo(String source) {
        System.out.printf(source + "time[%d]:birNum[%d],fishNum[%d]\n", time, birdNum, fishNum);
    }
}

鱼已经就位,到达await!
鸟已经就位,到达await!
TimeLine start!
TimeLine end,时间加10s
鸟动作执行! time[10]:birNum[5],fishNum[15]
鱼已经就位,到达await!
鸟已经就位,到达await!
TimeLine start!
TimeLine end,时间加10s
鱼已经就位,到达await!
鸟动作执行! time[20]:birNum[5],fishNum[10]
鸟已经就位,到达await!
TimeLine start!
TimeLine end,时间加10s
鱼执行动作! time[30]:birNum[5],fishNum[30]
鱼已经就位,到达await!
鸟动作执行! time[30]:birNum[5],fishNum[25]
鸟已经就位,到达await!
TimeLine start!
TimeLine end,时间加10s
鱼已经就位,到达await!
鸟动作执行! time[40]:birNum[5],fishNum[20]
鸟已经就位,到达await!
TimeLine start!
TimeLine end,时间加10s
鱼已经就位,到达await!
鸟动作执行! time[50]:birNum[5],fishNum[15]
鸟已经就位,到达await!
TimeLine start!
TimeLine end,时间加10s
鸟动作执行! time[60]:birNum[10],fishNum[10]
鸟已经就位,到达await!
鱼执行动作! time[60]:birNum[10],fishNum[30]
鱼已经就位,到达await!
TimeLine start!
TimeLine end,时间加10s
鱼已经就位,到达await!
鸟动作执行! time[70]:birNum[10],fishNum[20]
鸟已经就位,到达await!
TimeLine start!
TimeLine end,时间加10s
鸟动作执行! time[80]:birNum[10],fishNum[10]
鸟已经就位,到达await!
鱼已经就位,到达await!
TimeLine start!
TimeLine end,时间加10s
鱼执行动作! time[90]:birNum[10],fishNum[30]
鱼已经就位,到达await!
鸟动作执行! time[90]:birNum[10],fishNum[20]
鸟已经就位,到达await!
TimeLine start!
TimeLine end,时间加10s
鸟动作执行! time[100]:birNum[10],fishNum[10]
鸟已经就位,到达await!
鱼已经就位,到达await!
TimeLine start!
TimeLine end,时间加10s
鱼已经就位,到达await!
鸟动作执行! time[110]:birNum[10],fishNum[0]
鸟已经就位,到达await!
TimeLine start!

Process finished with exit code -1

4.Semaphore

通过控制操作系统的信号量数目来控制并发，比控制线程并发数粒度更细。管理固定数值的信号量，用以控制并发的数量。把需要并发的代码放在acquire、release之间即可。acquire获取信号，release释放信号。如果Semaphore管理一个信号量，就是互斥锁。

package com.retail.juc;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

/**
 * @author Tom
 */
public class SemaphoreDemo {

    public static void main(String[] args) {
        // 线程池
        ExecutorService exec = Executors.newCachedThreadPool();

        // 只能5个线程同时访问
        final Semaphore semp = new Semaphore(5);

        // 模拟20个客户端同时访问
        for (int i = 0; i < 20; i++) {
            final int NO = i;
            Runnable run = () -> {
                try {
                    semp.acquire();
                    System.out.println("accessing: " + NO);
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // 释放
                    semp.release();
                    System.out.println("------------------------" + semp.availablePermits());
                }
            };
            exec.execute(run);
        }
        exec.shutdown();
    }
}

"C:\Program Files\Java\jdk1.8.0_111\bin\java.exe" "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2019.1.1\lib\idea_rt.jar=65069:C:\Program Files\JetBrains\IntelliJ IDEA 2019.1.1\bin" -Dfile.encoding=UTF-8 -classpath "C:\Program Files\Java\jdk1.8.0_111\jre\lib\charsets.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\deploy.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\access-bridge-64.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\cldrdata.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\dnsns.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\jaccess.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\jfxrt.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\localedata.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\nashorn.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\sunec.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\sunjce_provider.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\sunmscapi.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\sunpkcs11.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\zipfs.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\javaws.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\jce.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\jfr.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\jfxswt.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\jsse.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\management-agent.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\plugin.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\resources.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\rt.jar;D:\study\out\production\study" com.retail.juc.SemaphoreDemo
accessing: 0
accessing: 2
accessing: 3
accessing: 1
accessing: 4
------------------------5
accessing: 5
accessing: 9
accessing: 6
------------------------5
------------------------5
------------------------5
------------------------5
accessing: 8
accessing: 7
------------------------2
accessing: 10
------------------------2
accessing: 11
------------------------1
accessing: 12
------------------------1
accessing: 13
------------------------2
accessing: 14
------------------------1
accessing: 15
------------------------2
accessing: 16
accessing: 17
------------------------2
------------------------1
accessing: 18
------------------------1
accessing: 19
------------------------1
------------------------2
------------------------3
------------------------4
------------------------5

Process finished with exit code 0

5.Exchanger

用于两个线程之间进行数据交换，先执行exchanger.exchange()的线程等待后来的线程到达，然后交换数据，最后再继续向下执行。

package com.retail.juc;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Exchanger;

/**
 * @author Tom
 */
public class ExchangerDemo {

    public static void main(String[] args) {
        Exchanger<List<Integer>> exchanger = new Exchanger<>();
        new Thread(() -> {
            List<Integer> list = new ArrayList<>();
            list.add(1);
            list.add(2);
            try {
                list = exchanger.exchange(list);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread1 " + list);
        }).start();

        new Thread(() -> {
            List<Integer> list = new ArrayList<>();
            list.add(3);
            list.add(4);
            try {
                list = exchanger.exchange(list);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread2 " + list);
        }).start();
    }
}

Thread2 [1, 2]
Thread1 [3, 4]

Process finished with exit code 0

6.Future和FutrueTask

Future是接口，FutrueTask是接口实现类。场景：多线程并发执行，返回结果放进list.

package com.retail.juc;

import java.util.ArrayList;
import java.util.concurrent.*;

/**
 * @author Tom
 */
public class FutureDemo {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 结果集
        ArrayList<Integer> list = new ArrayList<>();

        // 开启线程池
        ExecutorService exec = Executors.newFixedThreadPool(3);
        ArrayList<Future<Integer>> futureList = new ArrayList<>();

        // 启动线程池,固定线程数3
        for (int i = 0; i < 3; i++) {
            // 提交任务,添加返回
            futureList.add(exec.submit(() -> 1));
        }

        // 结果归集
        for (Future<Integer> future : futureList) {
            list.add(future.get());
        }
        System.out.println("list=" + list);
    }
}

list=[1, 1, 1]

it_monkey_ali

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
高级JAVA必会系列一：常用线程池和调度类

一、常用线程池1.newCachedThreadPool (1)缓存型池子，先查看池中有没有以前建立的线程，如果有，就复用，如果没有，就建立一个新的线程加入池中； (2)缓存型池子，通常用于执行一些生存周期很短的异步型任务；因此一些面向连接的daemon型server中用得不多； (3)能复用的线程，缺省超时时间是60s,超过这个IDLE时长...
复制链接

扫一扫

专栏目录