请看以下内容。

Java多线程并发执行demo代码实例

介绍

Java多线程编程是Java编程中一个非常重要的话题，当我们需要进行大量或者耗时的计算操作时，多线程并发执行可以提高程序的运行效率。而Java的线程机制使得多线程编程变得简单易用。

本篇文章主要通过示例讲解Java多线程的基本概念和使用方法。

创建线程

Java中创建线程有两种方式：一种是继承Thread类，一种是实现Runnable接口。

继承Thread类

使用这种方式需要重写run()方法，将需要执行的代码放入其中，并通过start()方法启动线程。

示例代码：

public class MyThread extends Thread {
    public void run() {
        System.out.println("线程" + Thread.currentThread().getName() + "正在执行");
    }
}

在主方法中创建并启动线程：

public class Test {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            MyThread thread = new MyThread();
            thread.start();
        }
    }
}

实现Runnable接口

使用这种方式需要实现run()方法，将需要执行的代码放入其中，并通过new Thread(Runnable r).start()方法启动线程。

示例代码：

public class MyRunnable implements Runnable {
    public void run() {
        System.out.println("线程" + Thread.currentThread().getName() + "正在执行");
    }
}

在主方法中创建并启动线程：

public class Test {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            MyRunnable runnable = new MyRunnable();
            new Thread(runnable).start();
        }
    }
}

Callable和Future

Java5以后，新增了一种创建线程的方式：实现Callable接口并返回结果，通过FutureTask来包装Callable对象。可以通过FutureTask的get()方法获取返回结果。

示例代码：

public class MyCallable implements Callable<String> {
    public String call() throws Exception {
        return "线程" + Thread.currentThread().getName() + "正在执行";
    }
}

在主方法中创建并启动线程：

public class Test {
    public static void main(String[] args) throws Exception {
        MyCallable callable = new MyCallable();
        FutureTask<String> futureTask = new FutureTask<>(callable);
        new Thread(futureTask).start();
        System.out.println(futureTask.get());
    }
}

线程状态

Java中的线程有6个状态：New、Runnable、Blocked、Waiting、Timed Waiting、Terminated。

New

当线程对象被创建时，它处于New状态。

Thread thread = new Thread();

Runnable

当调用线程对象的start()方法后，线程处于Runnable状态，表示它可以运行。

Thread thread = new Thread();
thread.start();

Blocked

当线程处于Blocked状态时，它被阻塞，等待另一个线程释放一个锁或者执行完毕。

synchronized(obj) {
    // 这里代码执行时，线程处于Blocked状态
}

Waiting

当线程处于Waiting状态时，它正在等待另一个线程执行某些操作。

synchronized(obj) {
    obj.wait(); // 这里代码执行时，线程处于Waiting状态
}

Timed Waiting

当线程处于Timed Waiting状态时，它正在等待另一个线程执行某些操作，但是有超时时间。

synchronized(obj) {
    obj.wait(timeout); // 这里代码执行时，线程处于Timed Waiting状态
}

Terminated

当线程完成了工作或者发生了异常，它进入Terminated状态。

示例说明

以下是一个使用多线程并发执行的示例：

我们需要统计一个Array中所有偶数的和。

单线程统计

首先我们来看单线程统计的代码：

public int sum(int[] nums) {
    int result = 0;
    for (int num : nums) {
        if (num % 2 == 0) {
            result += num;
        }
    }
    return result;
}

多线程统计

使用多线程，我们可以将Array拆成多个部分交给多个线程进行处理，然后汇总结果即可。以下是示例代码：

public int sum(int[] nums) throws InterruptedException {
    int numThreads = Runtime.getRuntime().availableProcessors(); // 获取可用的处理器个数
    int step = nums.length / numThreads;
    List<Thread> threads = new ArrayList<Thread>(numThreads);
    List<Integer> results = new ArrayList<Integer>(numThreads);
    for (int i = 0; i < numThreads; i++) {
        final int start = i * step;
        final int end = (i == numThreads - 1) ? nums.length : (i + 1) * step;
        Thread thread = new Thread(new Runnable() {
            public void run() {
                int result = 0;
                for (int j = start; j < end; j++) {
                    if (nums[j] % 2 == 0) {
                        result += nums[j];
                    }
                }
                results.add(result);
            }
        });
        threads.add(thread);
        thread.start();
    }
    for (Thread thread : threads) {
        thread.join(); // 等待所有线程执行完毕
    }
    int result = 0;
    for (Integer i : results) {
        result += i;
    }
    return result;
}

上面的代码将Array拆成numThreads个部分，每个部分对应一个线程，每个线程统计自己对应部分的偶数和，然后把结果保存在results列表中。最后再将results列表的结果汇总计算得到最终结果。

以上示例说明了多线程并发执行的基本原理和方法。当我们有大量或者耗时的计算操作时，能够合理地使用多线程将大大提高程序的运行效率，同时处理大量数据时也可以有效地减少内存使用。