The application of Therm Concurrency framework in the Java class library
Concurrent is a very important concept in modern computer systems, especially for multi -core processor systems.Concurrent framework is a tool and class library that provides concurrent programming support, and there are many such frameworks in Java.This article will introduce some application scenarios that use concurrent frameworks in the Java library and provide the corresponding Java code example.
1. Executor framework:
The Executor framework is one of the core frameworks of concurrent programming in Java.It provides a high -level task scheduling and execution model.Under normal circumstances, we need to perform some independent tasks, and we can use the Executor framework to manage the execution of the task.Below is an example code of the Executor framework:
ExecutorService executor = Executors.newFixedThreadPool(5);
for (int i = 0; i < 10; i++) {
Runnable worker = new WorkerThread("" + i);
executor.execute(worker);
}
executor.shutdown();
while (!executor.isTerminated()) {
// Waiting for all tasks to complete
}
System.out.println ("" All tasks are completed ");
In the above code, we created a fixed -size thread pool, and then submitted 10 tasks to the thread pool execution.Using the Executor framework can easily manage the execution of the task and the management of the thread pool.
2. Fork/Join framework:
The Fork/Join framework is a framework for parallel programming introduced by Java SE 7.It can divide large tasks into many small tasks, assign them to multiple processors to perform simultaneously, and then merge the results.The Fork/Join framework uses the work stealing algorithm to achieve the assignment of the task and the merger of the results.The following is an example code of the Fork/Join framework:
class MyRecursiveTask extends RecursiveTask<Integer> {
private int start;
private int end;
public MyRecursiveTask(int start, int end) {
this.start = start;
this.end = end;
}
@Override
protected Integer compute() {
if (end - start <= 2) {
// Execute small tasks
return start + end;
} else {
// Divide the big task into two small tasks
int mid = start + (end - start) / 2;
MyRecursiveTask leftTask = new MyRecursiveTask(start, mid);
MyRecursiveTask rightTask = new MyRecursiveTask(mid + 1, end);
leftTask.fork();
rightTask.fork();
// Merge results
return leftTask.join() + rightTask.join();
}
}
}
public class Main {
public static void main(String[] args) {
ForkJoinPool pool = new ForkJoinPool();
MyRecursiveTask task = new MyRecursiveTask(1, 10);
int result = pool.invoke(task);
System.out.println ("Result:" + Result);
}
}
In the above code, we define a task that can calculate all numbers within a given range.During the calculation process of the task, if the range is too large, divide the task into two small tasks, and submit it to the thread pool to perform parallel execution through the FORK () method, and finally merge the calculation results through the Join () method.
3. Parallel collection:
The Java class library also provides a variety of concurrent sets to solve the thread security problem when reading and writing operations in the concurrent environment.For example, ConcurrenThashMap can ensure the consistency of data when reading and writing at the same time; ConcurrenTlinkedQueue can achieve efficient unbounded concurrency and arranging queue.Below is a sample code of ConcurrenThashMap:
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
map.put("A", 1);
map.put("B", 2);
map.put("C", 3);
map.forEach((key, value) -> {
System.out.println(key + "：" + value);
});
In the above code, we created a ConcurrenThashMap and added three pairs of key values to it at the same time.Through the Foreach () method, we can traverse and output all elements in the set in the concurrent environment.
Summarize:
The application of concurrent framework in the Java library is very widely used, which can easily perform concurrent programming.This article introduces several common concurrent frameworks such as Executor framework, FORK/JOIN framework and concurrent collection, and provides related Java code examples.Through reasonable use of these concurrent frameworks, the performance of the multi -core processor system can be used to improve the complicated processing capacity of the application.
