Common tool classes under JUC package

Catalog

juc Common tool classes under package

Semaphore ——Semaphore 

Counter ——CountDownLatch

---

juc Common tool classes under package

1. Semaphore ——Semaphore
2. Counter ——CountDownLatch

3. Recycling fence ——CyclicBarrier

4. Switch between two threads ——Exchanger

Semaphore ——Semaphore 

Semaphore Semaphore It's a counter , Indicates the number of currently available resources .

About semaphores Semaphore There are two core operations
P- Apply for resource operation
V- Release resource operation

Semaphore Of PV Addition and subtraction operations are atomic , It can be used directly in multi-threaded scenarios

import java.util.concurrent.Semaphore;

/**
 *  Use of semaphores   No arguments 
 */
public class SemaphoreTest {
    public static void main(String[] args) {
        //  Pass in the number of available resources in the construction parameters 
        //  Available resources are 5
        Semaphore semaphore = new Semaphore(5);
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println(Thread.currentThread().getName() + " Prepare to apply for resources ");
                    // P operation , Every time you apply 1 A resource 
                    //  Currently, if the available resources are 0, call acquire Your thread will block , Until the occupying thread releases resources 
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + " Resource acquisition success ");
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread().getName() + " Release resources ");
                    // V operation , Every release 1 A resource 
                    semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        for (int i = 0; i < 10; i++) {
            Thread t = new Thread(runnable, String.valueOf(i + 1));
            t.start();
        }
    }
}

The current number of available resources is 5, At this time only 5 Threads got resources successfully . Other threads will block in acquire method ,
Wait for the occupying thread to release resources .

---

import java.util.concurrent.Semaphore;

/**
 *  Use of semaphores   Ginseng 
 **/
public class SemaphoreTest2 {
    public static void main(String[] args) {
        //  Pass in the number of available resources in the construction parameters 
        //  Available resources are 6 individual 
        Semaphore semaphore = new Semaphore(6);
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println(Thread.currentThread().getName() + " Prepare to apply for resources ");
                    // P operation , Apply for two resources at a time 
                    semaphore.acquire(2);
                    System.out.println(Thread.currentThread().getName() + " Resource acquisition success ");
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread().getName() + " Release resources ");
                    // V operation , Default release 2 Resources occupied 
                    semaphore.release(2);
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        for (int i = 0; i < 10; i++) {
            Thread t = new Thread(runnable,String.valueOf(i + 1));
            t.start();
        }
    }
}

 

Counter ——CountDownLatch

CountDownLatch - Large size join Method
call await Method thread , You need to wait for other threads to reduce the counter to 0, To resume execution .

import java.util.Random;
import java.util.concurrent.CountDownLatch;

/**
 *  Use CountDownLatch.await The thread of method will block , Until all waiting threads finish executing 
 *  Large advanced version join Method 
 */
public class CountDownLatchTest {
    public static void main(String[] args) throws InterruptedException {
        //  The number of threads to wait for , Must wait for this 10 After all the sub threads are executed, the execution will be resumed 
        CountDownLatch latch = new CountDownLatch(10);
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(new Random().nextInt(1000));
                    System.out.println(Thread.currentThread().getName() + " Reach the end point ");
                    //  Counter  - 1
                    latch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        for (int i = 0; i < 10; i++) {
            Thread t = new Thread(runnable, " Athletes " + i);
            t.start();
        }
        // main Threads are referee threads , Need to wait for all athletes to finish before resuming execution 
        //  Until all threads call countdown Method decrements the counter to 0 Carry on 
        latch.await();
        System.out.println(" The game is over ");
    }
}