Java多线程编程详解

程序员秋天

已于 2024-07-25 10:14:23 修改

阅读量772

点赞数 22

CC 4.0 BY-SA版权

文章标签： java python 开发语言

于 2024-07-25 08:19:58 首次发布

本文链接：https://blog.youkuaiyun.com/yll_358918552/article/details/140678877

这篇文章将详细介绍java多线程的基础知识。帮助你更好的了解多线程的概念、状态以及应用。

本文已收录于，我的技术网站 java-broke.site，有大厂完整面经，工作技术，架构师成长之路，等经验分享

Java 作为一种面向对象的编程语言，在处理并发和多线程编程方面提供了强大的支持。多线程可以让程序更高效地利用系统资源，提高程序的执行效率。本文将深入探讨 Java 多线程编程的基础知识、常用技术和实际应用。

一、多线程的基本概念

1、什么是线程

线程是程序执行的最小单元，一个程序可以包含多个线程，每个线程并行执行不同的任务。例如，一个文本编辑器可以同时进行输入、拼写检查和自动保存，这些任务可以由不同的线程来完成。

2、进程与线程的区别

进程是资源分配的基本单位，而线程是 CPU 调度的基本单位。同一进程内的线程共享进程的资源，但每个线程有自己的栈、程序计数器和局部变量。

二、创建线程的方式

Java 提供了多种创建线程的方法，主要包括继承 Thread 类和实现 Runnable 接口。

1、继承 Thread 类

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

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

2、实现 Runnable 接口

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

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

3、使用 Callable 和 Future

相比于 Runnable 接口，Callable 接口可以返回一个结果，并且可以抛出异常。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "Callable Result";
    }

    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(new MyCallable());
        try {
            System.out.println(future.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        executor.shutdown();
    }
}

三、线程的生命周期

线程的生命周期主要包括五个状态：新建、就绪、运行、阻塞和死亡。

1、新建 (New)

当一个线程对象被创建后，它就进入了新建状态。

2、就绪 (Runnable)

当调用 start() 方法后，线程进入就绪状态，等待 CPU 调度。

3、运行 (Running)

线程获得 CPU 时间片后，进入运行状态，执行 run() 方法中的代码。

4、阻塞 (Blocked)

线程由于某种原因（如等待资源）进入阻塞状态，当条件满足后重新进入就绪状态。

5、死亡 (Dead)

线程执行完 run() 方法或因异常退出 run() 方法，线程进入死亡状态。

四、线程同步与通信

多线程编程中，线程间的同步与通信是非常重要的，Java 提供了多种机制来实现线程同步和通信。

1、同步代码块和同步方法

使用 synchronized 关键字可以实现线程同步，避免多个线程同时访问共享资源，导致数据不一致。

public class Counter {
    private int count = 0;

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

    public synchronized int getCount() {
        return count;
    }
}

2、显式锁 Lock

java.util.concurrent.locks 包提供了更灵活的锁机制，如 ReentrantLock。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

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

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

    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

3、线程间通信

Java 提供了 wait()、notify() 和 notifyAll() 方法来实现线程间通信。这些方法必须在同步代码块中使用。

public class WaitNotifyExample {
    private static final Object lock = new Object();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("Thread 1 waiting...");
                    lock.wait();
                    System.out.println("Thread 1 resumed");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 2 notifying...");
                lock.notify();
            }
        });

        thread1.start();
        thread2.start();
    }
}

五、线程池

使用线程池可以有效地管理和复用线程资源，避免频繁创建和销毁线程带来的开销。Java 提供了 Executor 框架来简化线程池的使用。

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

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

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

        executor.shutdown();
    }
}