【学习总结|DAY021】Java 多线程

多线程是Java编程中非常重要的概念，它允许程序同时执行多个任务，提高程序的执行效率。本文将详细介绍多线程的创建方式、常用方法、线程安全、线程同步、线程池以及并发和并行的概念，并结合代码案例进行讲解。

一、线程的创建方式

Java中创建线程主要有三种方式：

方式一：继承Thread类

class MyThread extends Thread {
    @Override
    public void run() {
        // 线程执行的任务
    }
}

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

方式二：实现Runnable接口

class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 线程执行的任务
    }
}

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

方式三：实现Callable接口

import java.util.concurrent.*;

class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        // 线程执行的任务
        return 1; // 返回结果
    }
}

public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<Integer> future = executor.submit(new MyCallable());
        Integer result = future.get(); // 获取线程执行结果
        executor.shutdown(); // 关闭线程池
    }
}

二、线程的常用方法

start(): 启动线程
run(): 线程执行的任务
getName(): 获取线程名称
setName(String name): 设置线程名称
currentThread(): 获取当前线程对象
sleep(long time): 使当前线程休眠指定时间
join(): 等待线程执行完毕

三、线程安全

当多个线程同时访问同一个共享资源时，可能会出现线程安全问题，导致程序出现错误。解决线程安全问题主要有三种方式：

同步代码块: 使用synchronized关键字对访问共享资源的代码块进行加锁，确保同一时间只有一个线程可以访问该代码块。

synchronized (lock) {
    // 访问共享资源的代码
}

同步方法: 使用synchronized关键字修饰方法，将整个方法体作为一个同步代码块。

public synchronized void method() {
    // 访问共享资源的代码
}

Lock锁: 使用Lock接口及其实现类ReentrantLock创建锁对象，进行加锁和解锁操作。

Lock lock = new ReentrantLock();
lock.lock(); // 加锁
try {
    // 访问共享资源的代码
} finally {
    lock.unlock(); // 解锁
}

四、线程池

线程池可以复用线程，避免频繁创建和销毁线程的开销，提高程序的执行效率。Java中创建线程池主要有两种方式：

方式一：通过ThreadPoolExecutor创建线程池

ExecutorService executor = new ThreadPoolExecutor(
    3, // 核心线程数
    5, // 最大线程数
    60, // 临时线程存活时间
    TimeUnit.SECONDS, // 时间单位
    new LinkedBlockingQueue<Runnable>(), // 任务队列
    Executors.defaultThreadFactory(), // 线程工厂
    new ThreadPoolExecutor.AbortPolicy() // 任务拒绝策略
);

方式二：通过Executors创建线程池

ExecutorService executor = Executors.newFixedThreadPool(3); // 创建固定大小的线程池
ExecutorService executor = Executors.newSingleThreadExecutor(); // 创建单线程的线程池
ExecutorService executor = Executors.newCachedThreadPool(); // 创建可缓存的线程池

五、并发和并行

并发: 多个线程在同一时间段内交替执行。
并行: 多个线程在同一时刻同时执行。

六、代码案例

以下是一个使用线程池执行任务的示例：

import java.util.concurrent.*;

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

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 10; i++) {
            executor.execute(new MyRunnable());
        }
        executor.shutdown();
    }
}

输出结果：

线程 pool-1-thread-1 执行任务
线程 pool-1-thread-2 执行任务
线程 pool-1-thread-3 执行任务
线程 pool-1-thread-1 执行任务
线程 pool-1-thread-2 执行任务
线程 pool-1-thread-3 执行任务
线程 pool-1-thread-1 执行任务
线程 pool-1-thread-2 执行任务
线程 pool-1-thread-3 执行任务
线程 pool-1-thread-1 执行任务