Java并发编程之常用的多线程实现方式分析

介绍

Java作为一门历史悠久的编程语言，其并发编程支持非常完善。在实际的开发过程中，多线程技术经常用于提高程序的性能和处理能力。本文将对Java中多线程常用的几种实现方式进行分析，并给出两个示例介绍。

多线程实现方式

继承Thread类

继承Thread类是Java中非常基本的多线程实现方式之一。具体步骤如下：

1. 定义一个类继承Thread类，并重写run方法，在run方法中实现需要执行的代码逻辑。

java
class MyThread extends Thread {
public void run() {
// 实现需要执行的代码逻辑
}
}

1. 创建对象并调用start方法启动线程。

java
MyThread myThread = new MyThread();
myThread.start();

实现Runnable接口

实现Runnable接口是另外一种常用的多线程实现方式，相对于继承Thread类，该方式更加灵活，也更加容易维护，具体步骤如下：

1. 定义一个类实现Runnable接口，并重写run方法，在run方法中实现需要执行的代码逻辑。

java
class MyRunnable implements Runnable {
public void run() {
// 实现需要执行的代码逻辑
}
}

1. 创建线程对象并将实现了Runnable接口的对象作为参数传递给Thread构造方法，最后再调用start方法启动线程。

java
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();

实现Callable接口

相对于Runnable接口，Callable接口更加强大，可以在执行完成后返回值或抛出异常，具体步骤如下：

1. 定义一个类实现Callable接口，并重写call方法，在call方法中实现需要执行的代码逻辑。

java
class MyCallable implements Callable<String> {
public String call() {
// 实现需要执行的代码逻辑
return "执行完成";
}
}

1. 创建线程池对象并使用submit方法提交Callable实例，这个方法会返回一个Future对象，可用于获取执行结果。

java
MyCallable myCallable = new MyCallable();
ExecutorService executorService = Executors.newFixedThreadPool(1);
Future<String> future = executorService.submit(myCallable);
System.out.println(future.get()); // 获取执行结果
executorService.shutdown(); // 关闭线程池

示例

下面通过两个示例进一步说明多线程的实现和用法：

示例一

需求：创建10个线程，每个线程输出自己的线程名称。

实现步骤：

1. 定义Thread子类MyThread，重写run方法，输出当前线程的名称。

java
class MyThread extends Thread {
@Override
public void run() {
System.out.println("线程名称：" + Thread.currentThread().getName());
}
}

1. 在主函数中创建MyThread对象，并依次调用start方法启动线程。

java
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
MyThread myThread = new MyThread();
myThread.start();
}
}

执行结果：

线程名称：Thread-0
线程名称：Thread-1
线程名称：Thread-2
线程名称：Thread-3
线程名称：Thread-4
线程名称：Thread-5
线程名称：Thread-6
线程名称：Thread-7
线程名称：Thread-8
线程名称：Thread-9

示例二

需求：计算1~100的和，使用三个线程分别计算1~33、34~67、68~100的和，最后将三个线程计算的结果相加得到最终结果。

实现步骤：

1. 定义Callable子类MyCallable，重写call方法，计算整数数组中指定区间的和。

java
class MyCallable implements Callable<Integer> {
private int[] arr;
private int begin;
private int end;
public MyCallable(int[] arr, int begin, int end) {
this.arr = arr;
this.begin = begin;
this.end = end;
}
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = begin; i <= end; i++) {
sum += arr[i];
}
System.out.println(Thread.currentThread().getName() + "计算结果：" + sum);
return sum;
}
}

1. 在主函数中，创建长度为100的整数数组，将数组分为三段并分别创建MyCallable对象，使用ExecutorService线程池来执行Runnable对象，并将三个结果相加得到最终结果。

```java
public static void main(String[] args) throws ExecutionException, InterruptedException {
int[] arr = new int[100];
for (int i = 0; i < 100; i++) {
arr[i] = i + 1;
}

   ExecutorService executorService = Executors.newFixedThreadPool(3);
   List<Future<Integer>> list = new ArrayList<>();
   list.add(executorService.submit(new MyCallable(arr, 0, 33)));
   list.add(executorService.submit(new MyCallable(arr, 34, 67)));
   list.add(executorService.submit(new MyCallable(arr, 68, 99)));

   int result = 0;
   for (Future<Integer> future : list) {
       result += future.get();
   }
   System.out.println("总计算结果：" + result);

   executorService.shutdown();

}
```

执行结果：

pool-1-thread-1计算结果：561
pool-1-thread-2计算结果：1736
pool-1-thread-3计算结果：3183
总计算结果：5479

结论

Java中有多种多线程实现方式，使用继承Thread类、实现Runnable接口或实现Callable接口等方式都可以实现多线程编程。在实际编码过程中，要根据实际需要选择合适的方式实现多线程应用，合理地利用多线程技术可以在一定程度上提高程序的性能和响应速度。