메인 스레드가 조기에 종료되는 것을 방지하기 위해 Java에서 멀티스레딩을 사용하는 방법은 무엇입니까?

CountDownLatch

• CountDownLatch(잠금이라고도 함)는 다른 스레드가 일련의 작업을 완료할 때까지 하나 이상의 스레드가 대기할 수 있도록 하는 동기화 도우미 클래스입니다. CountDownLatch（也叫闭锁）是一个同步协助类，允许一个或多个线程等待，直到其他线程完成操作集。

• CountDownLatch

CountDownLatch는 주어진 카운트 값(count)으로 초기화됩니다. wait 메서드는 현재 카운트 값(count)이 0에 도달할 때까지 차단됩니다. countDown 메서드에 대한 호출이 0이 되면 대기 중인 모든 스레드가 해제되고 이후의 wait 메서드 호출이 즉시 반환됩니다.

구성 방법:

//参数count为计数值
public CountDownLatch(int count) {};

일반적인 방법

// 调用 await() 方法的线程会被挂起，它会等待直到 count 值为 0 才继续执行
public void await() throws InterruptedException {};
 
// 和 await() 类似，若等待 timeout 时长后，count 值还是没有变为 0，不再等待，继续执行
public boolean await(long timeout, TimeUnit unit) throws InterruptedException {};
 
// 会将 count 减 1，直至为 0
public void countDown() {};

• 사용 사례

• 먼저 인스턴스를 만듭니다. CountDownLatch countDown = new CountDownLatch(2)

• 동기화해야 할 스레드가 실행된 후, 개수는 -1입니다. countDown.countDown();

• 실행 전에 다른 스레드의 실행이 완료될 때까지 기다려야 하는 스레드는 차단 동기화를 달성하기 위해 countDown.await()를 호출합니다.

다음과 같습니다.

애플리케이션 시나리오

CountDownLatch는 일반적으로 멀티 스레드의 카운트다운 카운터로 사용되어 다른 작업 세트의 실행이 완료될 때까지 기다리도록 합니다(CountDownLatch의 초기화 결정).

CountDownLatch의 두 가지 사용 시나리오:
• 여러 스레드가 대기하고 동시성을 시뮬레이션하도록 합니다.

단일 스레드를 기다리다가 여러 스레드(작업)가 완료된 후 요약하고 병합합니다.

시나리오 1: 동시성 시뮬레이션

import java.util.concurrent.CountDownLatch;
 
/**
 * 让多个线程等待：模拟并发，让并发线程一起执行
 */
public class CountDownLatchTest {
    public static void main(String[] args) throws InterruptedException {
 
        CountDownLatch countDownLatch = new CountDownLatch(1);
        
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                try {
                    // 等待
                    countDownLatch.await();
                    String parter = "【" + Thread.currentThread().getName() + "】";
                    System.out.println(parter + "开始执行……");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
 
        Thread.sleep(2000);
       
        countDownLatch.countDown();
    }
}

시나리오 2: 여러 스레드가 완료된 후 요약 및 병합

동시 작업에는 종속성이 있는 경우가 많습니다. 예를 들어 데이터 세부 정보 페이지는 동시에 여러 인터페이스를 호출해야 합니다. 데이터를 얻는 시간, 동시 요청이 데이터를 얻은 후 결과를 병합해야 하거나 여러 데이터 작업이 완료된 후 데이터 확인이 필요합니다. 이는 실제로 여러 스레드(작업)가 완료된 후 요약 및 병합이 수행되는 시나리오입니다.

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CountDownLatch;
 
/**
 * 让单个线程等待：多个线程(任务)完成后，进行汇总合并
 */
public class CountDownLatchTest3 {
 
    //用于聚合所有的统计指标
    private static Map map = new ConcurrentHashMap();
    //创建计数器，这里需要统计4个指标
    private static CountDownLatch countDownLatch = new CountDownLatch(4);
 
    public static void main(String[] args) throws Exception {
 
        //记录开始时间
        long startTime = System.currentTimeMillis();
 
        Thread countUserThread = new Thread(() -> {
            try {
                System.out.println("正在统计新增用户数量");
                Thread.sleep(3000);//任务执行需要3秒
                map.put("userNumber", 100);//保存结果值
                System.out.println("统计新增用户数量完毕");
                countDownLatch.countDown();//标记已经完成一个任务
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread countOrderThread = new Thread(() -> {
            try {
                System.out.println("正在统计订单数量");
                Thread.sleep(3000);//任务执行需要3秒
                map.put("countOrder", 20);//保存结果值
                System.out.println("统计订单数量完毕");
                countDownLatch.countDown();//标记已经完成一个任务
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
 
        Thread countGoodsThread = new Thread(() -> {
            try {
                System.out.println("正在商品销量");
                Thread.sleep(3000);//任务执行需要3秒
                map.put("countGoods", 300);//保存结果值
                System.out.println("统计商品销量完毕");
                countDownLatch.countDown();//标记已经完成一个任务
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
 
        Thread countmoneyThread = new Thread(() -> {
            try {
                System.out.println("正在总销售额");
                Thread.sleep(3000);//任务执行需要3秒
                map.put("countMoney", 40000);//保存结果值
                System.out.println("统计销售额完毕");
                countDownLatch.countDown();//标记已经完成一个任务
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        
        //启动子线程执行任务
        countUserThread.start();
        countGoodsThread.start();
        countOrderThread.start();
        countmoneyThread.start();
 
        try {
            //主线程等待所有统计指标执行完毕
            countDownLatch.await();
            long endTime = System.currentTimeMillis();//记录结束时间
            System.out.println("------统计指标全部完成--------");
            System.out.println("统计结果为：" + map);
            System.out.println("任务总执行时间为" + (endTime - startTime) + "ms");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
 
    }
}

본론으로 들어가겠습니다

for 루프 대신 멀티스레딩을 사용하여 쿼리 효율성을 높이고 메인 스레드가 일찍 종료되어 다른 스레드에서 데이터 오류가 발생하는 것을 방지하세요🎜🎜코드로 직접 이동하세요:🎜

@Override
    public AppResponse getLocations() throws InterruptedException {
        List<GetLocationVO> vos = new ArrayList<>();
        vos = projectDao.getLocationOne();    
//      原来的代码
//        for (GetLocationVO vo : vos) {
//            List<LocationVO> children = projectDao.getLocationChildren(vo.getId());
//            vo.setChildren(children);
//        }
        //改造后的代码
        Thread(vos,10);
        return AppResponse.success("查询成功",vos);
    }
 
    //此处有加锁
    public synchronized void Thread(List<GetLocationVO> list, int nThread) throws InterruptedException {
        if (CollectionUtils.isEmpty(list) || nThread <= 0 || CollectionUtils.isEmpty(list)) {
            return;
        }
        CountDownLatch latch = new CountDownLatch(list.size());//创建一个计数器（大小为当前数组的大小，确保所有执行完主线程才结束）
        ExecutorService pool = Executors.newFixedThreadPool(nThread);//创建一个固定的线程池
        for (GetLocationVO vo : list) {
            pool.execute(() -> {
                //处理的业务
                List<LocationVO> children = projectDao.getLocationChildren(vo.getId());
                vo.setChildren(children);
                latch.countDown();
            });
        }
        latch.await();
        pool.shutdown();
    }

위 내용은 메인 스레드가 조기에 종료되는 것을 방지하기 위해 Java에서 멀티스레딩을 사용하는 방법은 무엇입니까?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!