Java多线程编程：从基础到进阶的实战指南-CSDN博客

本文链接：https://blog.csdn.net/weixin_45422364/article/details/143460961

Java多线程编程

引言

在当今的多核处理器环境下，充分利用并发编程可以大大提升应用的性能。Java作为面向对象的编程语言，内置了丰富的多线程支持，从基础的线程创建到高级的并发工具类，为开发者提供了强大的并发编程能力。本文将详细介绍Java的多线程机制，帮助你掌握多线程的基础和进阶知识，并解决实际开发中的多线程问题。

1. 什么是多线程编程？

多线程编程是指在一个程序中运行多个线程，以实现并行处理的编程技术。在Java中，每个线程都是一个独立的执行路径，彼此共享同一个进程的内存空间。这种并行处理能够提高程序的响应速度和处理能力，但也带来了线程同步、数据竞争等复杂问题。

2. Java中的线程创建

Java中创建线程有多种方法，以下是最常用的两种：

1. 继承Thread类：

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

public class Main {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        thread1.start();
    }
}

2. 实现Runnable接口

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

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
    }
}

继承Thread类和实现Runnable接口的主要区别在于，继承Thread无法再继承其他类，而实现Runnable可以实现多个接口，因此Runnable更加灵活。

3. 多线程中的重要方法

start()：启动线程，使线程进入就绪状态，等待CPU调度。
sleep(long millis)：使当前线程休眠指定的毫秒数，暂停执行。
join()：等待线程结束，再继续执行当前线程。
yield()：提示调度器释放当前线程的CPU资源，但不一定会生效。

这些方法为线程的控制提供了灵活的操作，使得我们能够更好地管理线程的执行时序。

4. 线程同步和数据竞争

在多线程编程中，多个线程可以共享同一资源（如对象或变量），这就导致了数据竞争问题。Java提供了同步机制来控制线程对共享资源的访问，防止数据竞争。

示例：同步方法

class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread t1 = new Thread(counter::increment);
        Thread t2 = new Thread(counter::increment);

        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println("计数值：" + counter.getCount());
    }
}

通过increment()方法中的synchronized关键字，确保了同一时刻只有一个线程能够执行该方法，从而避免了数据竞争问题。

5. 线程同步的高级工具

Java的java.util.concurrent包提供了多种线程同步工具，方便开发者更高效地实现多线程控制。以下是几个常用工具：

1. ReentrantLock

提供显式的锁机制，支持公平锁和非公平锁，可以替代synchronized。

import java.util.concurrent.locks.ReentrantLock;

class Counter {
    private int count = 0;
    private ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        return count;
    }
}

2. CountDownLatch

用于等待多个线程完成，适用于多线程协作任务的场景。

import java.util.concurrent.CountDownLatch;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3);

        Runnable task = () -> {
            System.out.println(Thread.currentThread().getName() + " 执行任务");
            latch.countDown();
        };

        new Thread(task).start();
        new Thread(task).start();
        new Thread(task).start();

        latch.await(); // 等待所有任务完成
        System.out.println("所有任务完成");
    }
}

3. CyclicBarrier

让一组线程在某个公共屏障点上等待，适合需要多个线程同步执行的场景。

import java.util.concurrent.CyclicBarrier;

public class Main {
    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(3, () -> System.out.println("所有线程已到达屏障，继续执行"));

        Runnable task = () -> {
            System.out.println(Thread.currentThread().getName() + " 到达屏障");
            try {
                barrier.await();
            } catch (Exception e) {
                e.printStackTrace();
            }
        };

        new Thread(task).start();
        new Thread(task).start();
        new Thread(task).start();
    }
}

6. 线程池

在并发编程中，创建和销毁线程会耗费大量资源。使用线程池可以复用线程，避免频繁创建和销毁线程，提升程序性能。
示例：使用Executors创建线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        for (int i = 0; i < 5; i++) {
            executorService.execute(() -> {
                System.out.println("线程 " + Thread.currentThread().getName() + " 执行任务");
            });
        }

        executorService.shutdown();
    }
}