CountDownLatch的高并发与顺序执行

待我称王封你为后i 2022-05-16 15:25 164阅读 0赞

一、高并发：

@Service  
public class ConcurrentTest \{

/\*\*  
     \* 线程数量  
     \*/  
    public static final int THREAD\_NUM = 100;

/\*\*  
     \* 开始时间  
     \*/  
    private static long startTime = 0L;

@PostConstruct  
    public void init() \{  
        try \{  
            startTime = System.currentTimeMillis();  
            System.out.println("CountDownLatch started at: " + startTime);  
            // 初始化计数器为1  
            CountDownLatch countDownLatch = new CountDownLatch(1);  
            for (int i = 0; i < THREAD\_NUM; i ++) \{  
                new Thread(new Run(countDownLatch)).start();  
            \}  
            // 启动多个线程  
            countDownLatch.countDown();  
        \} catch (Exception e) \{  
            System.out.println("Exception: " + e);  
        \}  
    \}

/\*\*  
     \* 线程类  
     \*/  
    private class Run implements Runnable \{  
        private final CountDownLatch startLatch;  
        public Run(CountDownLatch startLatch) \{  
            this.startLatch = startLatch;  
        \}  
        @Override  
        public void run() \{  
            try \{  
                // 线程等待  
                startLatch.await();  
                // 执行操作  
                System.out.println("当前线程："+Thread.currentThread().getName()+"执行自己的方法");  
                long endTime = System.currentTimeMillis();  
                System.out.println(Thread.currentThread().getName() + " ended at: " + endTime + ", cost: " + (endTime - startTime) + " ms.");  
            \} catch (Exception e) \{  
                e.printStackTrace();  
            \}  
        \}  
    \}  
      
    public static void main(String\[\] args) \{  
        ConcurrentTest test = new ConcurrentTest();  
        test.init();  
    \}  
\}

二、顺序执行

public class Test1 \{

public static void main(String\[\] args) \{      
        CountDownLatch c0 = new CountDownLatch(0);   
        CountDownLatch c1 = new CountDownLatch(1);   
        CountDownLatch c2 = new CountDownLatch(1);

Thread t1 = new Thread(new Work(c0, c1));  
        //c0为0，t1可以执行。t1的计数器减1

Thread t2 = new Thread(new Work(c1, c2));  
        //t1的计数器为0时，t2才能执行。t2的计数器c2减1

Thread t3 = new Thread(new Work(c2, c2));  
        //t2的计数器c2为0时，t3才能执行

t2.start();  
        t1.start();  
        t3.start();

\}  
    //定义Work线程类，需要传入开始和结束的CountDownLatch参数  
    static class Work implements Runnable \{  
        CountDownLatch c1;  
        CountDownLatch c2;  
        Work(CountDownLatch c1, CountDownLatch c2)\{  
            super();  
            this.c1=c1;  
            this.c2=c2;  
        \}  
        public void run() \{  
            try \{  
                c1.await();//前一线程为0才可以执行  
                System.out.println("开始执行线程:"+ Thread.currentThread().getName());  
                c2.countDown();//本线程计数器减少  
            \} catch (InterruptedException e) \{                
            \}

\}  
    \}