java并发编程和多线程

原创

mob64ca12e95b2b 2024-10-12 05:16:29 ©著作权

文章标签 Java 多线程线程池 文章分类 Java 后端开发

©著作权归作者所有：来自51CTO博客作者mob64ca12e95b2b的原创作品，请联系作者获取转载授权，否则将追究法律责任

Java并发编程与多线程

在现代软件开发中，性能和效能至关重要。而并发编程，尤其是多线程编程，是实现高效应用程序的核心。Java作为一种强大的编程语言，提供了丰富的工具来支持并发和多线程。

什么是多线程？

多线程是指在一个程序中同时运行多个线程的能力。线程是程序执行的基本单元，它使得多个任务可以并行执行，从而提高程序的效率。例如，在一个多线程的应用程序中，UI线程可以处理用户输入，而后台线程可以下载数据。

Java中的线程

在Java中，线程主要有两种创建方式：

继承 Thread 类：
- 你可以创建一个新的类，继承 Thread，并重写它的 run() 方法。

下面是一个示例：

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread " + getName() + " is running.");
    }
}

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

实现 Runnable 接口：
- 这是一种更常用的方式，因为它允许你的类继承其他类。

示例代码如下：

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable " + Thread.currentThread().getName() + " is running.");
    }
}

public class Main {
    public static void main(String[] args) {
        Thread thread2 = new Thread(new MyRunnable());
        thread2.start();  // 启动线程
    }
}

线程的生命周期

Java中的线程有几个不同的状态，包括：

新建状态：刚创建，但还未启动。
就绪状态：线程已启动，等待 CPU 调度。
运行状态：线程获得 CPU，正在执行。
阻塞状态：线程由于I/O操作等原因被阻塞。
死亡状态：线程执行完毕，无法再次启动。

一个简单的状态转移图如下：

journey
    title 线程生命周期
    section 状态转移
      新建状态 -> 就绪状态: 创建并调用start()
      就绪状态 -> 运行状态: CPU调度
      运行状态 -> 阻塞状态: 等待I/O完成
      运行状态 -> 死亡状态: run()方法结束

线程同步

在多线程环境中，多个线程可能会试图同时访问同一个资源，造成数据不一致的问题。为了防止这种情况，Java提供了同步机制。

使用 `synchronized`

可以通过在方法或代码块前加上 synchronized 关键字来确保同一时间只有一个线程可以访问该方法或块。例如：

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[] threads = new Thread[10];

        for (int i = 0; i < 10; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    counter.increment();
                }
            });
            threads[i].start();
        }

        for (Thread thread : threads) {
            thread.join();  // 等待所有线程完成
        }

        System.out.println("Final count: " + counter.getCount());
    }
}

在这个例子中，10个线程并行执行，每个线程对 Counter 对象的 increment() 方法进行调用，通过 synchronized 关键字，确保每次只有一个线程能执行此方法，避免了数据竞争。

线程池

在Java中，线程池是通过 Executor 框架实现的，它管理着一定数量的线程，减少了线程的创建和销毁成本，提高了性能。以下是如何使用 ExecutorService 创建一个线程池的例子：

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

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

        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executor.submit(() -> {
                System.out.println("Task " + taskId + " is running on " + Thread.currentThread().getName());
            });
        }

        executor.shutdown(); // 关闭线程池
    }
}

在上面的代码中，我们创建了一个固定大小的线程池，并提交了10个任务。线程池有效地管理了这些线程，使得系统资源得到更好的利用。