Java多线程及通信方式详解

Memory_2020

关注

原创 2024-01-01 08:45:33 1.7k 阅读 AI 写同款· GEO 优化 ›

Java多线程（五）：线程之间的通讯执行结果：线程1调用wait方法后，线程1进行等待，并未执行后面代码。阅读详情

1. 什么是Java 多线程

在讨论这个问题之前，首先要知道什么是Java多线程，我们拿个生活中的例子来说，例如在手机上使用软件，你可以同时运行多个应用程序或功能。你可以同时打开浏览器、音乐播放器和社交媒体应用。每个应用程序都在后台独立运行，就像多线程能够同时执行多个任务一样。

但是有时候你需要等待某些操作完成才能继续进行。比如当你在等待一个应用加载数据时，你可以同时切换到另一个应用。但是直到数据加载完成，你才能够进行下一步操作。这种等待和切换类似于多线程中的线程间同步和等待操作。

手机上的多个应用程序并行运行，并且有时需要等待或者进行切换，这可以帮助理解多线程环境中的并行执行和线程间的协作关系。

概念

多线程是指利用多个线程实现并发执行的能力。多线程允许程序同时执行多个任务，充分利用计算机的多核处理器和资源，提高程序的并发性和性能。线程是轻量级的子进程，可以独立执行并共享相同的内存空间。

在Java中，线程是轻量级的子进程，可以独立执行并共享相同的内存空间。Java提供了丰富的API来支持多线程编程，主要包括以下方面：

2. Java 线程的特点

Thread类和Runnable接口：Java中的线程通常由Thread类或实现了Runnable接口的类创建。通过继承Thread类或实现Runnable接口，可以定义线程的执行代码，并通过调用start()方法启动线程。
线程的生命周期：线程在Java中有不同的状态，如新建状态、就绪状态、运行状态、阻塞状态和终止状态。线程的生命周期由其不同状态之间的转换组成。
线程同步和通信：Java提供了synchronized关键字、Lock接口、synchronized块、wait()、notify()、notifyAll()等机制来实现线程的同步和通信，确保线程安全性并避免竞争条件和死锁等问题。
线程池：通过Executor框架和线程池可以管理和复用线程，提高线程的利用率和效率。
并发集合类：Java提供了线程安全的集合类，如ConcurrentHashMap、ConcurrentLinkedQueue等，用于在多线程环境下操作数据结构。

3. Java 多线程使用场景

Java多线程在许多场景下都可以发挥作用，以下是一些常见的使用场景：

并行处理任务：当需要同时处理多个相似或独立的任务时，可以使用多线程并行处理，提高任务处理效率。
网络编程：在网络通信中，每个客户端连接可以使用一个线程来处理，从而实现并发处理多个客户端请求。
后台任务处理：在后台执行一些耗时的操作，比如数据处理、文件下载、数据同步等，以保持主线程的响应性。
图形界面(GUI)程序：保持UI界面的响应性，使用多线程处理后台逻辑，如数据加载、图像处理等，避免阻塞UI线程。
并行算法：在一些算法和计算密集型任务中，可以使用多线程并行处理以提高计算效率。
服务器开发：在服务器端处理多个客户端请求，提高服务器的并发处理能力，如Web服务器、消息队列等。
并发数据结构：Java提供了一些并发安全的数据结构（如ConcurrentHashMap、ConcurrentLinkedQueue等），可以在多线程环境下安全地操作数据。
定时任务：定时执行的任务，如定时器等，可以使用线程池来管理定时任务的执行。
多核处理：充分利用多核处理器的优势，将任务分解成多个子任务并使用多线程并行处理。
异步编程：使用多线程来实现异步操作，比如Future、CompletableFuture等，提高系统的并发性和性能。

Java多线程适用于需要同时处理多个任务、提高系统并发性能、利用多核处理器等方面，但在使用多线程时需要注意线程安全问题，避免出现数据竞争和死锁等并发问题。

4. 线程间通信的基本方式

在并发编程中，线程之间通信的基本方式包括：

共享内存：多个线程共享同一块内存区域，在共享变量上进行读写操作。
消息传递：通过消息队列、管道等方式进行线程之间的信息传递。

5. Java 中线程间通信的方法

Java 提供了多种方式来实现线程间通信：

wait() 和 notify() / notifyAll() 方法：通过 wait()、notify()、notifyAll() 方法实现线程之间的等待和唤醒机制。等待的线程可以通过 wait() 进入等待状态，其他线程可以通过 notify() 或 notifyAll() 唤醒等待的线程。

示例代码：

class SharedObject {
    boolean flag = false;

    synchronized void waitForFlagChange() throws InterruptedException {
        while (!flag) {
            wait();
        }
    }

    synchronized void setFlag() {
        flag = true;
        notify(); // 或者使用 notifyAll()
    }
}

public class ThreadCommunicationExample {
    public static void main(String[] args) {
        SharedObject sharedObj = new SharedObject();

        Thread waitingThread = new Thread(() -> {
            try {
                sharedObj.waitForFlagChange();
                System.out.println("Flag has been changed!");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread changingThread = new Thread(() -> {
            sharedObj.setFlag();
            System.out.println("Flag has been set to true!");
        });

        waitingThread.start();
        changingThread.start();
    }
}

使用阻塞队列（BlockingQueue）：通过阻塞队列实现线程之间的数据传递。阻塞队列提供了线程安全的操作，可以方便地进行数据的生产和消费。

示例代码：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class ThreadCommunicationExample {
    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);

        Thread producer = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    queue.put(i);
                    System.out.println("Produced: " + i);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread consumer = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    int value = queue.take();
                    System.out.println("Consumed: " + value);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        producer.start();
        consumer.start();
    }
}

6. 其他通信方式

管道（Pipes）

在Java中，管道（Pipes）通常指的是PipedInputStream和PipedOutputStream，这两个类允许一个线程向另一个线程发送数据。下面是使用管道进行线程通信的Java示例：

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

public class PipeExample {
    public static void main(String[] args) {
        try {
            // 创建管道输入输出流
            PipedInputStream inputStream = new PipedInputStream();
            PipedOutputStream outputStream = new PipedOutputStream();

            // 将输入流与输出流连接起来
            inputStream.connect(outputStream);

            // 创建发送数据的线程
            Thread senderThread = new Thread(() -> {
                try {
                    String message = "Hello, Receiver!";
                    // 向输出流写入数据
                    outputStream.write(message.getBytes());
                    outputStream.close(); // 关闭输出流
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });

            // 创建接收数据的线程
            Thread receiverThread = new Thread(() -> {
                try {
                    byte[] buffer = new byte[1024];
                    // 从输入流读取数据
                    int bytesRead = inputStream.read(buffer);
                    System.out.println("Received message: " + new String(buffer, 0, bytesRead));
                    inputStream.close(); // 关闭输入流
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });

            // 启动线程
            senderThread.start();
            receiverThread.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例中，PipedInputStream和PipedOutputStream分别用于数据的读取和写入。两个线程通过这两个流进行数据的传输，一个线程向输出流写入数据，另一个线程从输入流读取数据。

注意使用管道进行通信时需要处理异常情况，例如输入流或输出流的关闭以及数据读取的异常处理，避免死锁等问题，确保线程的启动顺序和关闭顺序正确。

管道这种线程通信在实际开发中可能不太常用。

信号量（Semaphore）

Semaphore（信号量）是多线程并发控制中的一种同步工具，用于控制同时访问特定资源的线程数量。下面是一个使用Semaphore的Java代码示例以及使用场景：

import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    public static void main(String[] args) {
        int totalThreads = 5; // 总线程数
        Semaphore semaphore = new Semaphore(2); // 设置信号量的许可数量为2

        for (int i = 0; i < totalThreads; i++) {
            Thread thread = new Thread(() -> {
                try {
                    System.out.println("Thread " + Thread.currentThread().getName() + " is trying to acquire semaphore.");
                    semaphore.acquire(); // 获取信号量的许可
                    System.out.println("Thread " + Thread.currentThread().getName() + " has acquired semaphore.");
                    Thread.sleep(2000); // 模拟线程处理
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release(); // 释放信号量的许可
                    System.out.println("Thread " + Thread.currentThread().getName() + " has released semaphore.");
                }
            });
            thread.start();
        }
    }
}

使用场景

资源访问控制：Semaphore可用于限制对共享资源的并发访问，比如数据库连接池、线程池等。
流量控制：当系统面临高并发请求时，Semaphore可以控制同时处理的请求数量，避免系统资源耗尽。
有限资源的并发访问：当有多个线程需要访问某一有限资源（如打印机、文件句柄等）时，可以使用Semaphore限制并发访问的数量。
任务并行处理：控制并行执行的任务数量，如在并行处理数据时，限制同时进行的处理线程数量。

Semaphore是一种非常实用的并发控制机制，在需要限制并发访问数量的场景下非常有用。通过控制许可的获取和释放，Semaphore可以有效地管理并发线程的资源使用。

CountDownLatch

CountDownLatch是一种多线程同步工具，用于等待一个或多个线程完成操作。它通过一个计数器来实现，计数器的初始值设置为线程完成操作所需的数量。下面是一个使用CountDownLatch的Java代码示例和常见的使用场景：

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    public static void main(String[] args) throws InterruptedException {
        int totalTasks = 3; // 总任务数
        CountDownLatch latch = new CountDownLatch(totalTasks); // 设置计数器为任务总数

        for (int i = 0; i < totalTasks; i++) {
            Thread task = new Thread(() -> {
                // 模拟任务执行
                try {
                    Thread.sleep(2000);
                    System.out.println("Task completed by " + Thread.currentThread().getName());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    latch.countDown(); // 任务完成后将计数器减一
                }
            });
            task.start();
        }

        latch.await(); // 主线程等待计数器归零
        System.out.println("All tasks have been completed!");
    }
}

上面代码中创建了一个CountDownLatch，并将计数器初始值设置为3（即总任务数）。然后创建了3个任务线程，每个线程完成任务后，都会将CountDownLatch的计数器减1。主线程通过latch.await()等待计数器归零，一旦所有任务完成，主线程继续执行。

使用场景

主线程等待多个任务完成：在主线程需要等待多个子线程完成任务后再执行下一步操作的场景下，CountDownLatch非常有用。
并发控制：控制多个线程同时开始执行某项操作。
协调多个线程的操作：在某些场景下需要协调多个线程执行的顺序或时机，CountDownLatch可以帮助线程之间实现同步。
测试场景：在测试中，用于确保多个异步任务完成后再进行断言和检验。

CountDownLatch适用于一些需要线程同步的场景，能够有效地控制线程的执行顺序和等待。它能让主线程等待所有子线程完成任务后再继续执行，从而实现线程间的协作和同步。

CyclicBarrier等同步工具类

CyclicBarrier（循环屏障）是Java多线程同步工具之一，用于让一组线程在达到某个公共屏障点前等待彼此。当所有线程都到达屏障点后，所有线程才能继续执行。下面是一个使用CyclicBarrier的Java代码示例和一些常见的使用场景：

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierExample {
    public static void main(String[] args) {
        int totalThreads = 3; // 总线程数
        CyclicBarrier barrier = new CyclicBarrier(totalThreads, () -> {
            System.out.println("All threads have reached the barrier point!");
        });

        for (int i = 0; i < totalThreads; i++) {
            Thread thread = new Thread(() -> {
                try {
                    System.out.println("Thread " + Thread.currentThread().getName() + " is waiting at the barrier point.");
                    barrier.await(); // 线程等待到达屏障点
                    System.out.println("Thread " + Thread.currentThread().getName() + " has crossed the barrier point and continued execution.");
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            });
            thread.start();
        }
    }
}

在示例中，创建了一个CyclicBarrier，当三个线程都调用await()方法后会进入等待状态。一旦所有线程都到达屏障点，barrier的构造函数中定义的回调函数将执行，然后所有线程继续执行。

使用场景