线程池简单实用及其JVM简单参数

秃头侠客

已于 2022-04-13 17:33:08 修改

阅读量499

点赞数

分类专栏： JVM 文章标签： java 开发语言

于 2022-03-17 20:43:55 首次发布

本文链接：https://blog.csdn.net/qq_44620773/article/details/123555916

版权

JVM 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

Callable

接口只有一个方法 call与run方法功能一致，但有返回值，可以用future接受处理此接口为函数式接口可以使用lambda

此处配合Fature 统计100位随机数之和

call实现类

public class CallTest implements Callable {
    static ThreadLocalRandom current = ThreadLocalRandom.current();

    public static Integer getInteger() {
        current = ThreadLocalRandom.current();
        return current.ints().limit(10).map(x -> x % 100).max().getAsInt();
    }

    @Override
    public Object call() throws Exception {
        return getInteger();
    }
}

功能实现

public class TaskTest {
    public void addRandomNum()  {

        System.out.println("100位数同时相加");
        FutureTask<Integer>[] randomNumberTasks = new FutureTask[100];
        Integer num = 0;
        for (int i = 0; i < 100; i++) {
            randomNumberTasks[i] = new FutureTask<Integer>(new CallTest());
            new Thread(randomNumberTasks[i]).start();
        }

        for (FutureTask<Integer> futureTask:randomNumberTasks){
            while(!futureTask.isDone()){}
            try {
                num+=futureTask.get();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
        System.out.println("结果为" + num);

    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        new TaskTest().addRandomNum();
    }
}

##线程池
不建议使用Executor工具类创建线程，建议手动创建ThreadPoolExecutor.

public ThreadPoolExecutor(int corePoolSize,  
                              int maximumPoolSize,  
                              long keepAliveTime,  
                              TimeUnit unit,  
                              BlockingQueue<Runnable> workQueue,  
                              ThreadFactory threadFactory,  
                              RejectedExecutionHandler handler)

在这里插入图片描述

handler的拒绝策略：有四种：
第一种AbortPolicy:不执行新任务，直接抛出异常，提示线程池已满
第二种DisCardPolicy:不执行新任务，也不抛出异常
第三种DisCardOldSetPolicy:将消息队列中的第一个任务替换为当前新进来的任务执行
第四种CallerRunsPolicy:直接调用execute来执行当前任务

执行和提交execute参数是runnable没有返回值。submit参数可以使callable有返回值。

run实例

public class PoolTest {
    /**
     * 不建议使用Executors
     * 建议通过ThreadPoolExecutor手动创建线程
     */
    public void executors() {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        Future submit = executorService.submit(new CallTest());
        try {
            System.out.println("10个随机数的和为" + submit.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

    public void pool() {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 200, TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<Runnable>(5));

        for (int i = 0; i < 15; i++) {
            MyTask myTask = new MyTask(i);
            executor.execute(myTask);
            System.out.println("线程池中线程数目：" + executor.getPoolSize() + "，队列中等待执行的任务数目：" +
                    executor.getQueue().size() + "，已执行玩别的任务数目：" + executor.getCompletedTaskCount());
        }
        executor.shutdown();
    }

    public static void main(String[] args) {
        PoolTest poolTest = new PoolTest();
        poolTest.executors();
        poolTest.pool();
    }
}

功能实现

public class PoolTest {
    /**
     * 不建议使用Executors
     * 建议通过ThreadPoolExecutor手动创建线程
     */
    public void executors() {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        Future submit = executorService.submit(new CallTest());
        try {
            System.out.println("10个随机数的和为" + submit.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

    public void pool() {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 200, TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<Runnable>(5));

        for (int i = 0; i < 15; i++) {
            MyTask myTask = new MyTask(i);
            executor.execute(myTask);
            System.out.println("线程池中线程数目：" + executor.getPoolSize() + "，队列中等待执行的任务数目：" +
                    executor.getQueue().size() + "，已执行玩别的任务数目：" + executor.getCompletedTaskCount());
        }
        executor.shutdown();
    }

    public static void main(String[] args) {
        PoolTest poolTest = new PoolTest();
        poolTest.executors();
        poolTest.pool();
    }
}

CountDownLatch是一个同步工具类

CountDownLatch是一个同步工具类，CountDownLatch是一个同步工具类，用来协调多个线程之间的同步，或者说起到线程之间的通信（而不是用作互斥的作用）。

CountDownLatch能够使一个线程在等待另外一些线程完成各自工作之后，再继续执行。使用一个计数器进行实现。计数器初始值为线程的数量。当每一个线程完成自己任务后，计数器的值就会减一。当计数器的值为0时，表示所有的线程都已经完成一些任务，然后在CountDownLatch上等待的线程就可以恢复
执行接下来的任务。
参考·

JVM参数

常用参数

-XX:+PrintGCDetails：打印GC的详细信息（冒号之后的+表示打印，-表示不打印）
-XX:+UseSerialGC : 使用串行回收器
-Xmx4000m ：指定堆最大值为4000M（等价于-XX：MaxHeapSize）。默认物理内存的1/4
-Xms4000m ：指定堆初始化值为4000M（等价于-XX：initialHeapSize）。默认物理内存的1/64
-Xmn2000m ：设置新生代大小为2000M。
-Xss512k：设置栈大小为512k
设置栈大小
-Xss

设置单个线程栈的大小，一般默认为 512-1024k
等价于 -XX:ThreadStackSize
设置新生代大小
-Xmn ：设置年轻代大小。

整个JVM内存大小=年轻代大小 + 年老代大小 + 持久代大小。持久代一般固定大小为64m，所以增大年轻代后，将会减小年老代大小。

此值对系统性能影响较大，Sun官方推荐配置为整个堆的3/8。
设置元空间大小元空间的本质和永久代类似，都是对 JVM 规范中的方法区的实现。

不过元空间于永久代之间最大区别在于，元空间并不在虚拟中，而是使用本地内存，因此默认情况下，元空间的大小仅受本地内存限制。

元空间的默认大小在20m左右，通常会调大一点。
-XX：MetaspaceDetails=1024m
新生代和老年代比例配置
-XX:NewRatio=2 新生代和老年代的占比为1：2 （default）
-XX:MaxTenuringThreshold=15（default）
新生代对象经过15次的回收就会进入老年代