In addition to locks the Concurrenc

In addition to locks the Concurrency API also supports counting semaphores. Whereas locks usually grant exclusive access to variables or resources, a semaphore is capable of maintaining whole sets of permits. This is useful in different scenarios where you have to limit the amount concurrent access to certain parts of your application.

Here's an example how to limit access to a long running task simulated by sleep(5):

ExecutorService executor = Executors.newFixedThreadPool(10);

Semaphore semaphore = new Semaphore(5);

Runnable longRunningTask = () -> {
boolean permit = false;
try {
permit = semaphore.tryAcquire(1, TimeUnit.SECONDS);
if (permit) {
System.out.println("Semaphore acquired");
sleep(5);
} else {
System.out.println("Could not acquire semaphore");
}
} catch (InterruptedException e) {
throw new IllegalStateException(e);
} finally {
if (permit) {
semaphore.release();
}
}
}

IntStream.range(0, 10)
.forEach(i -> executor.submit(longRunningTask));

stop(executor);
The executor can potentially run 10 tasks concurrently but we use a semaphore of size 5, thus limiting concurrent access to 5. It's important to use a try/finally block to properly release the semaphore even in case of exceptions.

Executing the above code results in the following output:

Semaphore acquired
Semaphore acquired
Semaphore acquired
Semaphore acquired
Semaphore acquired
Could not acquire semaphore
Could not acquire semaphore
Could not acquire semaphore
Could not acquire semaphore
Could not acquire semaphore
The semaphores permits access to the actual long running operation simulated by sleep(5) up to a maximum of 5. Every subsequent call to tryAcquire() elapses the maximum wait timeout of one second, resulting in the appropriate console output that no semaphore could be acquired.

This was the second part out of a series of concurrency tutorials. More parts will be released in the near future, so stay tuned. As usual you find all code samples from this article on GitHub, so feel free to fork the repo and try it by your own.

Kết quả (Việt) 1:

Ngoài khóa Concurrency API cũng hỗ trợ tính semaphores. Trong khi khóa thường cấp quyền truy cập độc quyền để biến hoặc tài nguyên, một semaphore có khả năng duy trì toàn bộ giấy phép. Điều này là hữu ích trong các tình huống khác nhau mà bạn phải giới hạn truy cập đồng thời số tiền để một số phần của ứng dụng của bạn.Dưới đây là một ví dụ làm thế nào để hạn chế quyền truy cập vào một nhiệm vụ chạy dài mô phỏng bởi sleep(5):Chấp hành ExecutorService = Executors.newFixedThreadPool(10);Semaphore semaphore = mới Semaphore(5);Runnable longRunningTask = () -> {} giấy phép boolean = false; cố gắng {} cho phép = semaphore.tryAcquire (1, TimeUnit.SECONDS); Nếu (giấy phép) {} System.out.println ("Semaphore mua"); Sleep(5); } {} khác System.out.println ("có thể không có được semaphore"); } } bắt (InterruptedException e) {} ném IllegalStateException(e) mới; } {} cuối cùng Nếu (giấy phép) {} semaphore.Release(); } }}IntStream.range (0, 10) .forEach (tôi -> executor.submit(longRunningTask));Stop(Executor);Chấp hành viên có thể có khả năng chạy 10 nhiệm vụ đồng thời, nhưng chúng tôi sử dụng một semaphore kích thước 5, do đó hạn chế các truy cập đồng thời đến 5. Nó là quan trọng để sử dụng một try/cuối cùng khối để đúng cách phát hành semaphore thậm chí trong trường hợp ngoại lệ.Thực hiện kết quả mã ở trên vào đầu ra sau đây:Semaphore đã muaSemaphore đã muaSemaphore đã muaSemaphore đã muaSemaphore đã muaCó thể không có được semaphoreCó thể không có được semaphoreCould not acquire semaphoreCould not acquire semaphoreCould not acquire semaphoreThe semaphores permits access to the actual long running operation simulated by sleep(5) up to a maximum of 5. Every subsequent call to tryAcquire() elapses the maximum wait timeout of one second, resulting in the appropriate console output that no semaphore could be acquired.This was the second part out of a series of concurrency tutorials. More parts will be released in the near future, so stay tuned. As usual you find all code samples from this article on GitHub, so feel free to fork the repo and try it by your own.

Kết quả (Việt) 2:

Ngoài khóa API truy cập đồng thời cũng hỗ trợ Cột đếm. Trong khi đó, ổ khóa thường cấp quyền truy cập độc quyền cho các biến hoặc các nguồn lực, một semaphore là khả năng duy trì toàn bộ giấy phép. Điều này rất hữu ích trong các tình huống khác nhau, nơi bạn có để hạn chế số lượng truy cập đồng thời vào một số phần của ứng dụng của bạn. Dưới đây là một ví dụ làm thế nào để hạn chế quyền truy cập vào một nhiệm vụ dài chạy mô phỏng bằng giấc ngủ (5): ExecutorService thi hành = Executors.newFixedThreadPool (10) ; semaphore semaphore = new semaphore (5); Runnable longRunningTask = () -> { boolean giấy phép = false; try { giấy phép = semaphore.tryAcquire (1, TimeUnit.SECONDS); if (giấy phép) { System.out.println ( " semaphore mua lại "); giấc ngủ (5); } else { System.out.println (" không thể có được semaphore "); } } catch (InterruptedException e) { ném IllegalStateException mới (e); } finally { if (giấy phép) { semaphore.release (); } } } IntStream.range (0, 10) .forEach (i -> executor.submit (longRunningTask)); stop (thi hành); các chấp hành viên tiềm năng có thể chạy 10 nhiệm vụ đồng thời nhưng chúng tôi sử dụng một semaphore của kích thước 5, do đó hạn chế truy cập đồng thời đến 5. Điều quan trọng là phải sử dụng một thử / cuối cùng khối để phát hành đúng các semaphore ngay cả trong trường hợp ngoại lệ. Thực hiện các kết quả mã trên trong các kết quả sau: semaphore mua semaphore mua semaphore mua semaphore mua semaphore mua không thể có được semaphore không thể có được semaphore không thể có được semaphore không thể có được semaphore không thể có được semaphore các Cột phép truy cập tới các hoạt động chạy dài thực tế mô phỏng bằng giấc ngủ (5) lên đến tối đa là 5. Mỗi cuộc gọi tiếp theo để tryAcquire () trôi qua thời gian chờ đợi tối đa của một thứ hai, kết quả đầu ra giao diện điều khiển thích hợp mà không có semaphore có thể được mua lại. Đây là phần thứ hai trong một loạt các hướng dẫn đồng thời. Nhiều phần sẽ được phát hành trong tương lai gần, vì vậy hãy chờ đợi. Như thường lệ, bạn tìm thấy tất cả các mẫu mã từ bài viết này trên GitHub, vì vậy cảm thấy tự do để ngã ba repo và thử nó bằng cách riêng của bạn.