多线程的写法

第一种

public static void main(String[] args) {
    ExecutorService executorService = Executors.newFixedThreadPool(2); //线程,有2个厨师

    //下单
    System.out.println("点两个菜");
    long l = System.currentTimeMillis();  //记录一下当前时间
    //结果记录
    HashMap<String, Future<Map<String, String>>> fs = new HashMap<>();
    //提交
    for (int i = 0; i < 10; i++) {    //调用两次
        int finalI = i+1;
        Future<Map<String, String>> future = executorService.submit(new Callable<Map<String, String>>() {
            @Override
            public Map<String, String> call() throws Exception {
                Thread.sleep(5000);  //在做菜，实际业务中不是固定的时长
                HashMap<String, String> map = new HashMap<>();
                map.put("厨师" + Thread.currentThread().getName(), "----做好了");
                System.out.println("thread--");
                return map;
            }
        });
        fs.put("菜" + finalI,future);
    }
    System.out.println(fs);
    //给用户反馈
    if (fs.containsKey("菜1") && fs.containsKey("菜2")){
        //都有了future结果，说明下单成功了
        System.out.println("下单成功，用时：");
        //记录一下用时
        System.out.println(System.currentTimeMillis() - l + "ms");
    }
}

第二种

	public static void main(String[] args) {
    ExecutorService executorService1 = Executors.newFixedThreadPool(10);
    List<Future<Integer>> futures1 = new ArrayList<Future<Integer>>(10);
    List<String> list = new ArrayList<>();
    list.add("1");
    list.add("2");
    list.add("3");
    list.add("4");
    list.add("5");

    for (int i = 0;i<list.size();i++) {
        final int finalI = i;
        Callable<Integer> task2 = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println();

                return 1;
            }
        };
        futures1.add(executorService1.submit(task2));
    }
    executorService1.shutdown();
}

第三种

class MyTask implements Runnable {
    @Override
    public void run() {
        // 执行任务代码
        System.out.println("=========run========");
    }
	}
	public class MapTest {
	    public static void main(String[] args) throws Exception{
	        // 创建一个线程池
	        ExecutorService executor = Executors.newCachedThreadPool();
	        LinkedBlockingQueue<Future<Void>> completionQueue = new LinkedBlockingQueue<>();
	        List<Future<?>> list = new ArrayList<>();
	        // 提交任务给线程池执行
	        for (int i = 0; i < 10; i++) {
	            //list.add(executor.submit(new Runnable() {
	            //    @Override
	            //    public void run() {
	            //
	            //    }
	            //}));
	            executor.submit(new Callable<Void>() {
	                @Override
	                public Void call() throws Exception{

                    return null;
                }
            }).get();
            completionQueue.add(executor.submit(new Callable<Void>() {
                @Override
                public Void call() throws Exception {
                    return null;
                }
            }));
        }

        // 关闭线程池
        executor.shutdown();
        //for(Future<?> future:list){
        //    future.get();
        //}
        System.out.println("=========end========");
    }
}

第四种

public class ExecutorServiceExample {

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(5); // 创建一个固定大小为5的线程池
        LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<>(10); // 创建一个容量为10的队列

        // 将任务添加到队列中
        for (int i = 1; i <= 20; i++) {
            try {
                queue.put(i);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 提交任务到线程池
        for (int i = 0; i < 5; i++) {
            executor.submit(() -> {
                try {
                    while (true) {
                        int value = queue.take(); // 从队列中取出任务，如果队列为空则会阻塞
                        processTask(value);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        executor.shutdown(); // 关闭线程池

        // 等待所有任务执行完成后关闭线程池
        if(executor.awaitTermination(5, TimeUnit.SECONDS)){
            System.out.println("所有任务执行完成，线程池已关闭");
        } else {
            System.out.println("等待超时，部分任务可能还在执行，线程池未完全关闭");
            executor.shutdownNow(); // 强制关闭所有任务
        }
    }

    private static void processTask(int value) {
        System.out.println("处理任务: " + value);
        // 此处添加处理任务的逻辑
    }
}