Shulou(Shulou.com)06/02 Report--

Java concurrent container J.U.C AQS how to use, many novices are not very clear about this, in order to help you solve this problem, the following editor will explain for you in detail, people with this need can come to learn, I hope you can gain something.

AbstractQueueSynchronizer (AQS)

J.U.C greatly improves the performance of java concurrency, and AQS is the core of J.U.C.

The underlying AQS uses bidirectional lists (an implementation of queues).

Use Node to implement FIFO queues, which can be used to build the basic framework of locks or other synchronization devices

An int type is used to represent the state. There is a member variable of status in AQS. Based on AQS, there is a synchronization component ReentrantLock. In this ReentrantLock, status represents the number of threads that have acquired the lock. For example, status=0 indicates that no thread has acquired the lock, status=1 indicates that a thread has acquired the lock, and status > 1 indicates the number of reentered locks.

How to use: inherit

A subclass manipulates its state by inheriting and managing its state {acquire and release} through the methods that implement it

Exclusive lock and shared lock mode can be implemented at the same time (exclusive, shared)

AQS synchronization component

CountdownLatch, locking, uses a count to ensure that the thread needs to be blocked all the time.

Semaphore, which controls the number of concurrent threads at the same time.

Cyclicbarrier, much like countdownlatch, can block processes.

Reentrantlock

Condition

Futuretask

Countdownlatch

Is a synchronization helper class through which you can implement functions similar to blocking the current thread. One or more threads wait until the other thread operation is complete, and countdownlatch is initialized with a given counter, which operates on an atomic operation, that is, only one thread can operate on the counter at a time. Calling the await () method of this class will remain blocked until other threads call the countdown () method, and each call to the countdown () method will subtract the value of the counter by 1. When the value of the counter decreases to 0, all threads that are waiting for the call to the await method will continue to execute. This state will only occur once, because the counter here cannot be reset, and if the business needs a version that can reset the count number of times, consider using cyclicbarrier.

Working with scen

In some business scenarios, program execution needs to wait until a certain condition is completed before continuing to perform subsequent operations. Typical applications such as parallel computing: when a processing has a large amount of computation, the computing task can be split into multiple sub-tasks. After waiting for all the sub-tasks to be completed, the parent task gets the running results of all the sub-tasks for summary.

Here is an example of the basic use of countdownlatch:

@ Slf4jpublic class CountDownLatchExample1 {private final static int threadCount = 200; public static void main (String [] args) throws InterruptedException {ExecutorService executorService = Executors.newCachedThreadPool (); final CountDownLatch countDownLatch = new CountDownLatch (threadCount); for (int I = 0; I

< threadCount; i++) { final int threadNum = i; executorService.execute(() ->

{try {test (threadNum);} catch (InterruptedException e) {log.error ("exception", e);} finally {countDownLatch.countDown ();}}) } / / all previous threads can be guaranteed to execute countDownLatch.await (); log.info ("finish"); executorService.shutdown ();} private static void test (int threadNum) throws InterruptedException {Thread.sleep; log.info ("{}", threadNum); Thread.sleep (100);}}

A complex scenario: we open many threads to complete a task, but the task needs to be completed within a specified time, and if it is not completed within a certain period of time, the task will be abandoned.

@ Slf4jpublic class CountDownLatchExample2 {private final static int threadCount = 200; public static void main (String [] args) throws InterruptedException {ExecutorService executorService = Executors.newCachedThreadPool (); final CountDownLatch countDownLatch = new CountDownLatch (threadCount); for (int I = 0; I

< threadCount; i++) { final int threadNum = i; executorService.execute(() ->

{try {test (threadNum);} catch (InterruptedException e) {log.error ("exception", e);} finally {countDownLatch.countDown ();}}) } / / you can ensure that all previous threads have finished executing countDownLatch.await (10, TimeUnit.MILLISECONDS); log.info ("finish"); / / all threads will not be destroyed at the first time, but the current thread pool will be destroyed after the existing thread has finished executing. ExecutorService.shutdown ();} private static void test (int threadNum) throws InterruptedException {Thread.sleep; log.info ("{}", threadNum);}} semaphore semaphore

You can control how many resources can be accessed at the same time, similar to countdownlatch, providing two core methods: aquire and release. Aquire means to obtain a license, if not, wait, and release means to release a license after the operation is completed. Semaphore maintains the current number of visits and provides a synchronization mechanism to control the number of visits.

Working with scen

Resources that can only provide limited access, such as the number of database connections, are limited, while the number of concurrent applications in the upper layer will be much greater than the number of connections. If you operate on the database at the same time, it may lead to exceptions due to the inability to obtain database connections. At this point, you can use semaphore semaphore to control concurrent access. When semaphore controls the number of concurrency to 1, it is very similar to running in a single thread.

Examples are as follows:

@ Slf4jpublic class SemaphoreExample1 {private final static int threadCount = 20; public static void main (String [] args) throws InterruptedException {ExecutorService executorService = Executors.newCachedThreadPool (); / / allowed concurrency final Semaphore semaphore = new Semaphore (3); for (int I = 0; I

< threadCount; i++) { final int threadNum = i; executorService.execute(() ->

{try {/ / obtain a license semaphore.acquire (); test (threadNum); / / release a license semaphore.release () } catch (InterruptedException e) {log.error ("exception", e);}});} log.info ("finish"); executorService.shutdown ();} private static void test (int threadNum) throws InterruptedException {log.info ("{}", threadNum); Thread.sleep (1000);}}

The running result shows that three threads are executing at the same time.

You can also obtain multiple licenses:

@ Slf4jpublic class SemaphoreExample2 {private final static int threadCount = 20; public static void main (String [] args) throws InterruptedException {ExecutorService executorService = Executors.newCachedThreadPool (); / / allowed concurrency final Semaphore semaphore = new Semaphore (3); for (int I = 0; I

< threadCount; i++) { final int threadNum = i; executorService.execute(() ->

{try {/ / obtain multiple licenses semaphore.acquire (3); test (threadNum); / / release multiple licenses semaphore.release (3) } catch (InterruptedException e) {log.error ("exception", e);}});} log.info ("finish"); executorService.shutdown ();} private static void test (int threadNum) throws InterruptedException {log.info ("{}", threadNum); Thread.sleep (1000);}}

Get three licenses at a time, but only three concurrency is allowed at the same time, which is equivalent to a single thread running.

@ Slf4jpublic class SemaphoreExample3 {private final static int threadCount = 20; public static void main (String [] args) throws InterruptedException {ExecutorService executorService = Executors.newCachedThreadPool (); / / allowed concurrency final Semaphore semaphore = new Semaphore (3); for (int I = 0; I

< threadCount; i++) { final int threadNum = i; executorService.execute(() ->

{try {/ / attempt to obtain a license if (semaphore.tryAcquire ()) {test (threadNum); / / release a license semaphore.release () } catch (InterruptedException e) {log.error ("exception", e);}});} log.info ("finish"); executorService.shutdown ();} private static void test (int threadNum) throws InterruptedException {log.info ("{}", threadNum) Thread.sleep (1000);}}

Output result:

15 pool-1-thread-2 24 pool-1-thread-2 21.098 [pool-1-thread-1] INFO com.vincent.example.aqs.SemaphoreExample3-015 14 INFO com.vincent.example.aqs.SemaphoreExample3-015 24 pool-1-thread-2 21.098 [main] INFO com.vincent.example.aqs.SemaphoreExample3-finish15:24:21.098 [pool-1-thread-3] INFO com.vincent.example.aqs.SemaphoreExample3-2

Because we put 20 requests into the thread pool, 20 requests will try to execute at the same time, semaphore will try to get each thread to get permission, and our concurrency at the same time is 3, that is, only three threads have permission, while the test method has Thread.sleep (1000), so the remaining 17 threads cannot get permission and end directly.

Semaphore.tryAcquire (3, TimeUnit.SECONDS)

It means you can wait 3 seconds. If you don't get permission within 3 seconds, it will end.

CyclicBarrier

It is also a synchronization helper class that allows a group of threads to wait for each other until a common barrier point is reached. It is possible for multiple threads to wait for each other, and only when each thread is ready can each continue to perform the operation of the meeting. It is similar to countdownlatch in that it is implemented through counters. When a thread calls the await () method, the thread enters a waiting state. When the value of the loop counter reaches the set initial value, the thread that enters the waiting state will be awakened to continue with the subsequent operation. Because CyclicBarrier can be reused after releasing waiting threads, it is called a loop barrier.

The usage scenario of CyclicBarrier is similar to that of countdownlatch. CyclicBarrier can be used for multithreaded computing data and finally merging the results.

The difference between CyclicBarrier and Countdownlatch:

Counters for countdownlatch can only be used once, and CyclicBarrier can be reused using the reset method

Countdownlatch mainly implements that one or n threads need to wait for another thread to complete an operation before continuing to execute. It describes the relationship between one or n threads waiting for other threads. On the other hand, CyclicBarrier mainly realizes that multiple threads wait for each other and can not continue to perform subsequent operations until all threads meet the conditions. it describes the relationship between threads waiting for each other. So CyclicBarrier can handle more complex business scenarios, such as when a counter error occurs, you can reset the counter and let the thread execute it again.

Is it helpful for you to read the above content? If you want to know more about the relevant knowledge or read more related articles, please follow the industry information channel, thank you for your support.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.