多线程案例ThreadPoolsExecutor

关注

原创最新推荐文章于 2026-04-30 13:23:16 发布 297 阅读 AI 写同款· GEO 优化 ›

养龙虾经验：OpenClaw用户必看的3个“省token”救命配置本文分享了3个优化OpenClaw使用成本的配置方案：1）启用上下文压缩功能，可选择全局或单个代理设置，支持safeguard/adaptive两种压缩模式；2）修改SOUL.md提示词，要求模型回答简洁直接；3）限制对话历史长度。方案一效果最佳，可减少长对话的token消耗，但可能影响连贯性。三种方案可单独或组合使用，需根据实际场景调整参数。文章最后邀请读者分享使用痛点，将针对高频问题撰写解决方案。阅读详情

package com.dream.web;

import org.apache.commons.lang3.SystemUtils;
import org.apache.commons.lang3.time.DateFormatUtils;
import org.apache.commons.lang3.time.DateUtils;

import java.util.Date;
import java.util.concurrent.*;


/**
 * Created by test on 2019/5/30.
 */
public class ThreadPoolsTest {
    public static void main(String[] args) throws Exception {
       /* for(int i=0;i<5;i++) {

            MyThread myThread = new MyThread(i);
            new Thread(myThread).start();

        }*/

        //selfThreadPools();

        //cachedThreadPools();

        singleThreadPools();
    }

    /**
     *
     * @throws Exception
     */
    public static void singleThreadPools() throws Exception{
        ExecutorService threadPools = Executors.newSingleThreadExecutor();
        try {
            for (int i = 0; i < 1000; i++) {
                if(i%10==0){
                    Thread.sleep(1000);
                }
                final int j = i;
                threadPools.execute(new Runnable() {
                    @Override
                    public void run() {
                        //打印正在执行的缓存线程信息
                        System.out.println("-->" + Thread.currentThread().getName() + "正在被执行-->" + j);
                    }
                });
            }
        }catch (Exception e){
            e.printStackTrace();
            threadPools.shutdownNow();
        }finally {
            if(!threadPools.isShutdown()){
                threadPools.shutdown();
            }
        }
    }


    /**
     * 缓存线程池
     * @throws Exception
     */
   public static void cachedThreadPools() throws Exception{
       ExecutorService threadPools = Executors.newCachedThreadPool();
       try {
           for (int i = 0; i < 1000; i++) {
               final int j = i;
               threadPools.execute(new Runnable() {
                   @Override
                   public void run() {
                       //打印正在执行的缓存线程信息
                       System.out.println("-->" + Thread.currentThread().getName() + "正在被执行-->" + j);
                   }
               });
           }
       }catch (Exception e){
           e.printStackTrace();
           threadPools.shutdownNow();
       }finally {
           if(!threadPools.isShutdown()){
               threadPools.shutdown();
           }
       }
   }

    /**
     * 固定长线程池
     */
    public static void fixedThreadPools(final int n) throws Exception{
        System.out.println("==================>"+n);
        ExecutorService threadPools = Executors.newFixedThreadPool(3);
        threadPools.awaitTermination(5l, TimeUnit.SECONDS);
        for(int i=0;i<10;i++) {
            final int j=i;


            threadPools.execute(
                    new Runnable() {
                        @Override
                        public void run() {
                            //打印正在执行的缓存线程信息
                            System.out.println(n+"-->"+Thread.currentThread().getName() + "正在被执行-->"+j);
                        }
                    }
            );
        }

        if(!threadPools.isShutdown()){
            threadPools.shutdown();
        }
    }

    /**
     * 自定义线程池
     */
    public static void selfThreadPools(){
        ExecutorService threadPools = new ThreadPoolExecutor(2,4,0,TimeUnit.SECONDS,new LinkedBlockingDeque<Runnable>(100));
        try {
            for (int i = 0; i < 100; i++) {
                final int j = i;
                threadPools.execute(new Runnable() {
                    @Override
                    public void run() {
                        //打印正在执行的缓存线程信息
                        System.out.println("-->" + Thread.currentThread().getName() + "正在被执行-->" + j);
                    }
                });
            }
        }catch (Exception e){
            e.printStackTrace();
            threadPools.shutdownNow();
        }finally {
            if(!threadPools.isShutdown()){
                threadPools.shutdown();
            }
        }


    }
}


class  MyThread implements Runnable{
    private int j=0;
    public MyThread(int j){
        this.j = j;
    }
    public MyThread(){

    }
    @Override
    public void run() {
        try {
            System.out.println( "发起正在被执行-->"+j);
            ThreadPoolsTest.fixedThreadPools(j);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

收录于