高薪程序员必修课-java为什么要用并发编程

目录

前言

1. 提高性能和效率

2. 更好地响应用户

3. 优化I/O操作

具体示例

示例1：提高性能和效率

示例2：更好地响应用户

示例3：优化I/O操作

总结

---

前言

        并发编程允许多个线程在同一时间执行任务。下面我们从多个原理角度来解释为什么Java需要并发编程，并提供适当的示例。

1. 提高性能和效率

• 原理：在多核处理器上，并发编程可以让程序利用多个CPU核同时运行多个任务，从而提高整体性能。
• 示例：处理大量数据时，可以将数据分成多个部分，并行处理每个部分。

2. 更好地响应用户

• 原理：在GUI应用程序中，并发编程允许用户界面线程保持响应，同时其他线程处理后台任务。
• 示例：在一个图形界面应用中，用户可以在后台执行文件下载的同时，继续使用界面而不冻结。

3. 优化I/O操作

• 原理：I/O操作（如文件读写、网络通信）通常是阻塞的。使用并发编程，可以在等待I/O操作完成时执行其他任务。
• 示例：一个服务器程序可以使用多个线程同时处理多个客户端请求。

具体示例

示例1：提高性能和效率

假设我们需要对一个大型数组进行求和操作，可以将数组分成多个部分并行处理：

public class ParallelSum {
    private static final int THREAD_COUNT = 4;

    public static void main(String[] args) throws InterruptedException {
        int[] array = new int[1000000];
        // 初始化数组
        for (int i = 0; i < array.length; i++) {
            array[i] = i + 1;
        }

        // 创建并启动线程
        SumThread[] threads = new SumThread[THREAD_COUNT];
        int length = array.length / THREAD_COUNT;
        for (int i = 0; i < THREAD_COUNT; i++) {
            threads[i] = new SumThread(array, i * length, (i + 1) * length);
            threads[i].start();
        }

        // 等待所有线程完成
        int totalSum = 0;
        for (SumThread thread : threads) {
            thread.join();
            totalSum += thread.getSum();
        }

        System.out.println("Total sum: " + totalSum);
    }
}

class SumThread extends Thread {
    private int[] array;
    private int start;
    private int end;
    private int sum;

    public SumThread(int[] array, int start, int end) {
        this.array = array;
        this.start = start;
        this.end = end;
    }

    public void run() {
        sum = 0;
        for (int i = start; i < end; i++) {
            sum += array[i];
        }
    }

    public int getSum() {
        return sum;
    }
}

示例2：更好地响应用户

在一个GUI应用程序中，通过使用SwingWorker来执行耗时任务，使界面保持响应：

import javax.swing.*;
import java.awt.*;

public class ResponsiveUI {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Responsive UI");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(400, 200);
        frame.setLayout(new FlowLayout());

        JButton button = new JButton("Start Task");
        JLabel label = new JLabel("Task not started");
        frame.add(button);
        frame.add(label);

        button.addActionListener(e -> {
            SwingWorker<Void, Void> worker = new SwingWorker<Void, Void>() {
                @Override
                protected Void doInBackground() {
                    // 模拟长时间任务
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException interruptedException) {
                        interruptedException.printStackTrace();
                    }
                    return null;
                }

                @Override
                protected void done() {
                    label.setText("Task completed");
                }
            };
            worker.execute();
            label.setText("Task started");
        });

        frame.setVisible(true);
    }
}

示例3：优化I/O操作

在一个服务器程序中，使用多线程处理多个客户端连接：

import javax.swing.*;
import java.awt.*;

public class ResponsiveUI {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Responsive UI");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(400, 200);
        frame.setLayout(new FlowLayout());

        JButton button = new JButton("Start Task");
        JLabel label = new JLabel("Task not started");
        frame.add(button);
        frame.add(label);

        button.addActionListener(e -> {
            SwingWorker<Void, Void> worker = new SwingWorker<Void, Void>() {
                @Override
                protected Void doInBackground() {
                    // 模拟长时间任务
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException interruptedException) {
                        interruptedException.printStackTrace();
                    }
                    return null;
                }

                @Override
                protected void done() {
                    label.setText("Task completed");
                }
            };
            worker.execute();
            label.setText("Task started");
        });

        frame.setVisible(true);
    }
}

总结

并发编程在Java中有以下几个主要原因：

1. 提高性能和效率，通过充分利用多核处理器。
2. 保持用户界面响应，提高用户体验。
3. 优化I/O操作，避免等待时间浪费。

通过这些示例，可以更好地理解为什么Java中需要使用并发编程，以及如何使用并发编程提高应用程序的性能和响应能力。