Concurrent tool set for concurrent programming

One 、CountDownLatch

Counter tool .
await
countDown

1.1 CountDownLatch Simple application

CountDownExample.java

import java.util.concurrent.CountDownLatch;

public class CountDownExample {
    

    static CountDownLatch countDownLatch=new CountDownLatch(1);

    static class Thread1 extends Thread{
    

        @Override
        public void run(){
    
            //TODO
            try {
    
                Thread.sleep(500);
                countDownLatch.await();
            } catch (InterruptedException e) {
    
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+" end of execution ");
            // Means I'm done 
        }
    }
    static class Thread2 extends Thread{
    

        @Override
        public void run(){
    
            try {
    
                Thread.sleep(500);
                countDownLatch.await();
            } catch (InterruptedException e) {
    
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+" end of execution ");
        }
    }
    static class Thread3 extends Thread{
    
        @Override
        public void run(){
    
            try {
    
                Thread.sleep(500);
                countDownLatch.await();
            } catch (InterruptedException e) {
    
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+" end of execution ");
        }
    }

    public static void main(String[] args) throws InterruptedException {
    
        Thread1 t1=new Thread1();
        t1.start();
        Thread2 t2=new Thread2();
        t2.start();
        Thread3 t3=new Thread3();
        t3.start();
        System.out.println(" End of main thread execution ");
        countDownLatch.countDown();
    }
}

1.2 CountDownLatch Business applications for

When you start the application , To do health testing for third-party applications
BaseHealthChecker.java

public abstract class BaseHealthChecker implements Runnable{
    

    private String serviceName; // The service name 

    private boolean serviceUp;

    public BaseHealthChecker(String serviceName) {
    
        this.serviceName = serviceName;
    }

    @Override
    public void run() {
    
        try {
    
            verifyService();
            serviceUp=true;
        }catch (Exception e){
    
            serviceUp=false;
        }finally {
    

        }
    }

    /**
     *  Check the health of the service 
     */
    public abstract void verifyService() throws Exception;

    public String getServiceName() {
    
        return serviceName;
    }

    public boolean isServiceUp() {
    
        return serviceUp;
    }
}

CacheHealthChecker.java

import java.util.concurrent.CountDownLatch;

public class CacheHealthChecker extends BaseHealthChecker{
    

    private CountDownLatch countDownLatch;

    public CacheHealthChecker(CountDownLatch countDownLatch) {
    
        super("CacheHealthChecker");
        this.countDownLatch=countDownLatch;
    }

    @Override
    public void verifyService() throws Exception {
    
        System.out.println("Checking:"+this.getServiceName());
        try {
    
            Thread.sleep(1000);
            //  If the check fails ,throw RuntimeException()
        } catch (Exception e) {
    
            throw e;
        }
        countDownLatch.countDown();
        System.out.println(this.getServiceName()+"  Healthy ");
    }
}

DatabaseHealthChecker.java

import java.util.concurrent.CountDownLatch;

public class DatabaseHealthChecker extends BaseHealthChecker{
    
    private CountDownLatch countDownLatch;


    public DatabaseHealthChecker(CountDownLatch countDownLatch) {
    
        super("DatabaseHealthChecker");
        this.countDownLatch=countDownLatch;
    }

    @Override
    public void verifyService() throws Exception {
    
        System.out.println("Checking:"+this.getServiceName());
        try {
    
            Thread.sleep(1000);
        } catch (Exception e) {
    
            throw e;
        }
        countDownLatch.countDown();
        System.out.println(this.getServiceName()+"  Healthy ");
    }

}

ApplicationStartup.java

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;

public class ApplicationStartup {
    

    private static List<BaseHealthChecker> services;
    private static CountDownLatch countDownLatch=new CountDownLatch(2);

    static{
    
        services=new ArrayList<>();
        services.add(new CacheHealthChecker(countDownLatch));
        services.add(new DatabaseHealthChecker(countDownLatch));
    }

    private final static ApplicationStartup INSTANCE=new ApplicationStartup();

    private ApplicationStartup(){
    }

    public static ApplicationStartup getInstance(){
    
        return INSTANCE;
    }

    public static boolean checkExternalServices() throws InterruptedException {
    
        for(BaseHealthChecker bh:services){
    
            new Thread(bh).start(); // For each service, threads are used to execute 
        }
        countDownLatch.await();
        return true;
    }
}

StartupMain.java

public class StartupMain {
    
    public static void main(String[] args) {
    
        try {
    
            ApplicationStartup.checkExternalServices();
        } catch (InterruptedException e) {
    
            // There's a problem .
        }
        System.out.println(" Service started successfully ");
    }
}

1.3 CountDownLatch Implementation principle of

It allows a thread to block
You can also block multiple threads
Implementation of shared lock . Multiple threads can be allowed to preempt locks at the same time , Then wait until the counter returns to zero , Wake up at the same time .
state Record counter .
countDown When , It's actually state–

Two 、Semaphore

2.1 semaphore Introduce

Signal lamp .
Current limiter , Restrict access to resources .
Essentially : Seize a token , If you grab the token , Just go through , otherwise , Just block !
acquire() Seize a token
release() Release a token .
Semaphore semaphore=new Semaphore(10);
acquire = 10 - 1
by 0 When , Blocking , It is possible to block at the same time N Threads
release = token +1
There's a token , Wake up the . Wake up from blocked threads .
Why use shared locks ？
Because multiple tokens can be released at the same time , That means that multiple threads can preempt the lock at the same time .

2.2 semaphore application

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class SemaphoreExample {
    

    public static void main(String[] args) {
    
        // Limit the number of concurrent resources .
        Semaphore semaphore=new Semaphore(10);
        for (int i = 0; i < 20; i++) {
    
            new Car(i,semaphore).start();
        }
    }
    static class Car extends  Thread{
    
        private int num;
        private Semaphore semaphore;

        public Car(int num, Semaphore semaphore) {
    
            this.num = num;
            this.semaphore = semaphore;
        }
        @Override
        public void run(){
    
            try {
    
                semaphore.acquire(); // Get a token 
                System.out.println(" The first  "+num+" Two cars grab a parking space ");
                TimeUnit.SECONDS.sleep(2);
                System.out.println(" The first  "+num+" Let's go ~");
            } catch (InterruptedException e) {
    
                e.printStackTrace();
            }finally {
    
                semaphore.release(); // Release a token 
            }
        }
    }
}

3、 ... and 、CyclicBarrier

Repeatable fence . The implementation is equivalent to multiple threads passing CountDownLatch Of await, Then another thread uses countDown Method to wake up .

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierExample {
    

    public static void main(String[] args) {
    
        int n = 4;
        CyclicBarrier barrier = new CyclicBarrier(4, () -> {
    
            System.out.println(" All threads are written , Continue with other tasks ");
        });  // 4
        for (int i = 0; i < n; i++) {
    
            new Writer(barrier).start();
        }
    }

    static class Writer extends Thread {
    
        private CyclicBarrier cyclicBarrier;

        public Writer(CyclicBarrier barrier) {
    
            this.cyclicBarrier = barrier;
        }

        @Override
        public void run() {
    
            try {
    
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName() + " Write data completed , Wait for other threads ");
                cyclicBarrier.await();  //-1 The action of 
            } catch (InterruptedException e) {
    
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
    
                e.printStackTrace();
            }

        }
    }
}