JAVA Core Concurrency Programming Model Practical Guide
In today's software development field, multi-core processors and distributed systems have become mainstream. In order to make full use of hardware resources, we need to write concurrent programs to achieve parallel processing and improve performance. As a mainstream programming language, JAVA provides a rich set of concurrent programming models and tools. This article will lead you to have an in-depth understanding of JAVA's core concurrent programming models through some specific code examples, and learn how to use these models to practice concurrent programming.
public class MyThread extends Thread { @Override public void run() { System.out.println("Hello, this is my thread!"); } public static void main(String[] args) { MyThread myThread = new MyThread(); myThread.start(); } }
In this example, we create a custom thread class MyThread that inherits from Thread, and rewrite the run method to output a paragraph in the run method Simple message. In the main method, we create an instance of MyThread and start the thread through the start method.
public class MyRunnable implements Runnable { @Override public void run() { System.out.println("Hello, this is my runnable!"); } public static void main(String[] args) { Thread myThread = new Thread(new MyRunnable()); myThread.start(); } }
In this example, we created a custom class MyRunnable that implements the Runnable interface, and overridden the run method. In the main method, we create a Thread object, pass in the instance of MyRunnable as a parameter, and start the thread through the start method.
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class ThreadPoolExample { public static void main(String[] args) { ExecutorService executor = Executors.newFixedThreadPool(3); for (int i = 0; i < 5; i++) { Runnable worker = new WorkerThread("" + i); executor.execute(worker); } executor.shutdown(); while (!executor.isTerminated()) { } System.out.println("Finished all threads"); } } class WorkerThread implements Runnable { private String message; public WorkerThread(String s) { this.message = s; } public void run() { System.out.println(Thread.currentThread().getName() + " (Start) message = " + message); processMessage(); System.out.println(Thread.currentThread().getName() + " (End)"); } private void processMessage() { try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } } }
In this example, we use the Executors tool class to create a thread pool with a fixed size of 3. Then, we created 5 instances of WorkerThread and submitted them to the thread pool. The thread pool will be responsible for managing the execution of these threads.
public class Counter { private int count = 0; public synchronized void increment() { count++; } public synchronized void decrement() { count--; } public synchronized int getCount() { return count; } }
In this example, we created a Counter class, in which the increment, decrement and getCount methods all use the synchronized keyword to achieve synchronization. This ensures that calls to these methods from multiple threads are safe.
In addition, JAVA's concurrency package also provides a variety of lock implementations, such as ReentrantLock and ReadWriteLock. The following is an example of using ReentrantLock:
import java.util.concurrent.locks.ReentrantLock; public class ReentrantLockExample { private final ReentrantLock lock = new ReentrantLock(); public void performTask() { lock.lock(); try { // 执行需要同步的代码块 } finally { lock.unlock(); } } }
In this example, we create an instance of ReentrantLock and use lock and unlock to lock and unlock the critical section. This method is more flexible than the synchronized keyword and can manually control the acquisition and release of locks.
import java.util.concurrent.ConcurrentHashMap; public class ConcurrentMapExample { private ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>(); public void addKeyValuePair(String key, String value) { map.put(key, value); } public String getValueByKey(String key) { return map.get(key); } }
In this example, we create a ConcurrentHashMap instance and use the put and get methods to safely manipulate the data in the Map without requiring additional synchronization operate.
Through the above examples, we have an in-depth understanding of the core concurrent programming model of JAVA, including thread basics, thread pools, locks and synchronization, and concurrent collections. In actual projects, reasonable use of these concurrent programming models can improve program performance and stability. I hope this article can help readers better master the knowledge of concurrent programming in JAVA and write efficient concurrent programs in practice.
The above is the detailed content of A Practical Guide to the JAVA Core Concurrency Programming Model. For more information, please follow other related articles on the PHP Chinese website!