A Practical Guide to the JAVA Core Concurrency Programming Model

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.

1. Thread Basics
   First, let’s take a look at the most basic concurrent programming element in JAVA: threads. Threads in JAVA are represented by the java.lang.Thread class. The following is a simple thread example:

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.

2. Runnable interface
   In addition to inheriting the Thread class, we can also implement the java.lang.Runnable interface to create threads. The following is an example of using the Runnable interface:

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.

3. Thread Pool
   In actual concurrent programming, frequent creation and destruction of threads will lead to large performance overhead. Therefore, JAVA provides a thread pool to manage and reuse threads. The following is a simple example of using a thread pool:

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.

4. Locks and synchronization
   In concurrent programming, locks and synchronization are very important concepts. JAVA provides the synchronized keyword and Lock interface to help us achieve synchronization between threads. The following is an example of using the synchronized keyword:

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.

5. Concurrent collection
   In order to safely share data in concurrent programming, JAVA provides some concurrency-safe collection classes, such as ConcurrentHashMap and CopyOnWriteArrayList. The following is an example of using ConcurrentHashMap:

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!