【Java 基础篇】Java多线程编程详解：线程创建、同步、线程池与性能优化

news2025/6/5 19:19:21

在这里插入图片描述

Java是一门强大的编程语言，其中最引人注目的特性之一是多线程支持。多线程允许我们在同一程序中同时执行多个任务，这大大提高了应用程序的性能和响应能力。本文将深入介绍Java线程的基础知识，无论您是初学者还是有一些经验的开发人员，都将从中获益。

什么是线程？

在计算机科学领域，线程是指在一个进程内部执行的独立单元。一个进程可以包含多个线程，每个线程都有自己的执行路径，可以独立运行。线程是操作系统进行任务调度和分配的基本单位，它允许我们实现并发执行，使得程序能够更高效地利用计算机资源。

Java中的线程

Java是一门多线程编程语言，它内置了多线程支持的类库和API，使得开发人员可以轻松地创建和管理线程。在Java中，线程是通过java.lang.Thread类来表示的。您可以通过继承Thread类或实现Runnable接口来创建线程。

继承Thread类创建线程

要创建一个线程，您可以继承Thread类，并重写run()方法来定义线程的执行逻辑。以下是一个简单的示例：

class MyThread extends Thread {
    public void run() {
        // 线程的执行逻辑
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread: " + i);
        }
    }
}

然后，您可以创建线程对象并调用start()方法来启动线程：

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

实现Runnable接口创建线程

除了继承Thread类，您还可以通过实现Runnable接口来创建线程。这种方式更加灵活，因为一个类可以同时实现多个接口。以下是示例代码：

class MyRunnable implements Runnable {
    public void run() {
        // 线程的执行逻辑
        for (int i = 0; i < 10; i++) {
            System.out.println("Runnable: " + i);
        }
    }
}

然后，您需要将Runnable对象传递给Thread类的构造函数，并调用start()方法启动线程：

public class Main {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable); // 创建线程并传入Runnable对象
        thread.start(); // 启动线程
    }
}

Callable和Future

除了上述两种方式，还可以使用Callable和Future来创建线程，这是一种更高级的方法，允许线程执行完毕后返回结果。这在需要获取线程执行结果时非常有用。

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

class MyCallable implements Callable<Integer> {
    public Integer call() {
        int sum = 0;
        for (int i = 1; i <= 10; i++) {
            sum += i;
        }
        return sum;
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        MyCallable myCallable = new MyCallable();
        FutureTask<Integer> futureTask = new FutureTask<>(myCallable);

        Thread thread = new Thread(futureTask);
        thread.start();

        int result = futureTask.get(); // 获取线程执行结果
        System.out.println("线程执行结果：" + result);
    }
}

线程的生命周期

一个线程在其生命周期内会经历不同的状态。理解线程的生命周期有助于我们更好地管理和控制线程的行为。Java中的线程可以处于以下几种状态：

  1. 新建状态（New）： 当线程对象被创建但尚未启动时，线程处于新建状态。

  2. 就绪状态（Runnable）： 当线程获得CPU时间片并执行时，线程处于就绪状态。

  3. 阻塞状态（Blocked）： 当线程在等待某个条件的时候，会进入阻塞状态，直到条件满足。

  4. 终止状态（Terminated）： 线程执行完任务或发生异常后，线程处于终止状态，不再执行。

在接下来的部分，我们将深入探讨线程的创建与启动。

Java 线程的生命周期

一个Java线程可以处于以下几种状态：

  1. 新建状态（New）： 当线程对象被创建但尚未启动时，线程处于新建状态。

  2. 就绪状态（Runnable）： 当线程获得CPU时间片并执行时，线程处于就绪状态。

  3. 运行状态（Running）： 当线程获得CPU时间片并执行时，线程处于运行状态。

  4. 阻塞状态（Blocked）： 当线程在等待某个条件的时候，会进入阻塞状态，直到条件满足。

  5. 等待状态（Waiting）： 当线程等待某个条件的时候，会进入等待状态，直到条件满足。

  6. 超时等待状态（Timed Waiting）： 当线程等待某个条件的时候，可以设置一个超时时间，超过这个时间后线程会进入超时等待状态。

  7. 终止状态（Terminated）： 线程执行完任务或发生异常后，线程处于终止状态，不再执行。

了解线程的生命周期对于编写多线程程序非常重要，因为我们需要根据线程的状态来进行合适的操作和控制。

创建与启动线程

在Java中，有两种常见的方式来创建和启动线程：

  1. 继承Thread类： 您可以创建一个继承自Thread类的子类，并重写run()方法来定义线程的执行逻辑。然后，创建线程对象并调用start()方法来启动线程。

  2. 实现Runnable接口： 您可以创建一个实现Runnable接口的类，并重写run()方法来定义线程的执行逻辑。然后，创建线程对象，并将Runnable对象传递给线程的构造函数，并调用start()方法来启动线程。

下面是两种方式的示例代码：

// 继承Thread类创建线程
class MyThread extends Thread {
    public void run() {
        // 线程的执行逻辑
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread: " + i);
        }
    }
}

// 实现Runnable接口创建线程
class MyRunnable implements Runnable {
    public void run() {
        // 线程的执行逻辑
        for (int i = 0; i < 10; i++) {
            System.out.println("Runnable: " + i);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建并启动继承Thread类的线程
        MyThread myThread = new MyThread();
        myThread.start();

        // 创建并启动实现Runnable接口的线程
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
    }
}

线程的状态转换

一个线程在其生命周期内会经历不同的状态，这些状态之间可以相互转换。以下是线程可能的状态转换：

  1. 新建（New） -> 就绪（Runnable）： 当线程对象被创建后，线程处于新建状态，但尚未启动。通过调用start()方法，线程将转换为就绪状态。

  2. 就绪（Runnable） -> 运行（Running）： 当线程获得CPU时间片并开始执行时，线程从就绪状态转换为运行状态。

  3. 运行（Running） -> 就绪（Runnable）： 当线程的时间片用完，或者主动调用yield()方法，线程将从运行状态转换为就绪状态。

  4. 运行（Running） -> 阻塞（Blocked）： 当线程在等待某个条件时，例如等待I/O操作完成，线程将从运行状态转换为阻塞状态。

  5. 运行（Running） -> 终止（Terminated）： 当线程的run()方法执行完毕，线程将从运行状态转换为终止状态。

  6. 就绪（Runnable） -> 终止（Terminated）： 当线程的run()方法执行完毕，线程将从就绪状态直接转换为终止状态。

  7. 阻塞（Blocked） -> 就绪（Runnable）： 当线程等待的条件满足时，线程将从阻塞状态转换为就绪状态。

  8. 阻塞（Blocked） -> 终止（Terminated）： 当线程等待的条件不再满足，或者等待超时，线程将从阻塞状态转换为终止状态。

  9. 等待（Waiting） -> 就绪（Runnable）： 当线程等待的条件满足时，线程将从等待状态转换为就绪状态。

  10. 等待（Waiting） -> 终止（Terminated）： 当线程等待的条件不再满足，或者等待超时，线程将从等待状态转换为终止状态。

  11. 超时等待（Timed Waiting） -> 就绪（Runnable）： 当线程等待的条件满足时，线程将从超时等待状态转换为就绪状态。

  12. 超时等待（Timed Waiting） -> 终止（Terminated）： 当线程等待的条件不再满足，或者等待超时，线程将从超时等待状态转换为终止状态。

理解这些状态的转换非常重要，因为我们需要根据线程的当前状态来决定如何操作线程，以实现我们想要的并发行为。

线程的优先级

Java线程可以具有不同的优先级，用于告诉操作系统在竞争CPU时间片时应该优先考虑哪个线程。线程的优先级范围从1到10，默认优先级是5。您可以使用setPriority()方法设置线程的优先级，范围从1（最低优先级）到10（最高优先级）。

Thread thread = new Thread();
thread.setPriority(8); // 设置线程优先级为8

请注意，线程的优先级只是一个建议，操作系统可以选择是否遵守它。因此，不要过分依赖线程优先级来控制程序的行为。

线程的同步与互斥

在多线程编程中，经常会涉及到多个线程访问共享资源的情况，这可能会导致数据不一致或竞态条件。为了避免这些问题，我们需要使用线程的同步和互斥机制来确保线程安全。

synchronized关键字

synchronized关键字可以用于方法或代码块，它可以确保在同一时间只有一个线程可以访问被synchronized修饰的方法或代码块。这可以有效地避免多个线程同时访问共享资源。

public synchronized void synchronizedMethod() {
    // 线程安全的代码
}

或者使用synchronized代码块：

public void nonSynchronizedMethod() {
    // 非线程安全的代码

    synchronized (lockObject) {
        // 线程安全的代码
    }
    // 非线程安全的代码
}

volatile关键字

volatile关键字用于修饰变量，它可以确保一个线程对变量的修改对其他线程可见。当一个线程修改了一个volatile变量的值，其他线程将立即看到这个修改。

private volatile boolean flag = false;

public void setFlagTrue() {
    flag = true;
}

public boolean isFlag() {
    return flag;
}

Lock和Condition

除了synchronized和volatile，Java还提供了更灵活的锁机制，可以使用Lock接口和Condition接口来实现。

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

Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();

public void await() {
    lock.lock();
    try {
        condition.await();
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        lock.unlock();
    }
}

public void signal() {
    lock.lock();
    try {
        condition.signal();
    } finally {
        lock.unlock();
    }
}

使用Lock和Condition可以实现更复杂的线程同步和互斥逻辑，适用于更复杂的多线程应用程序。

线程池

在实际开发中，经常需要创建和管理大量的线程。如果每次都手动创建和销毁线程，会带来较大的开销。为了提高线程的创建和管理效率，可以使用线程池。

线程池是一组预先创建好的线程，可以重复使用来执行任务。Java提供了java.util.concurrent包，其中包含了线程池的相关类，例如ThreadPoolExecutor。通过使用线程池，可以更好地管理系统中的线程，提高性能和资源利用率。

以下是一个简单的线程池示例：

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

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建一个固定大小的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(5);

        // 提交任务给线程池
        for (int i = 0; i < 10; i++) {
            Runnable task = new MyTask(i);
            executorService.submit(task);
        }

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

class MyTask implements Runnable {
    private int taskId;

    public MyTask(int taskId) {
        this.taskId = taskId;
    }

    public void run() {
        System.out.println("Task " + taskId + " is running.");
    }
}

线程安全的集合

在多线程编程中，经常需要使用集合来存储和管理数据。然而，传统的集合类（如ArrayList和HashMap）不是线程安全的，如果多个线程同时访问这些集合，可能会导致数据不一致或异常。

为了解决这个问题，Java提供了线程安全的集合类，例如ConcurrentHashMap和CopyOnWriteArrayList。这些集合类使用了各种锁和同步机制，以确保多线程访问时的线程安全性。

import java.util.concurrent.ConcurrentHashMap;

public class ThreadSafeCollectionExample {
    public static void main(String[] args) {
        ConcurrentHashMap<Integer, String> map = new ConcurrentHashMap<>();

        // 线程安全地添加元素
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");

        // 线程安全地遍历元素
        map.forEach((key, value) -> {
            System.out.println(key + ": " + value);
        });
    }
}

线程间通信

在多线程编程中，不同线程之间需要进行通信和协作。Java提供了多种线程间通信的机制，包括wait()、notify()、notifyAll()等方法，以及java.util.concurrent包中的Lock和Condition。

以下是一个使用wait()和notify()实现线程间通信的示例：

class SharedResource {
    private int data;
    private boolean newData = false;

    public synchronized void produce(int value) {
        while (newData) {
            try {
                wait(); // 等待消费者消费数据
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        data = value;
        newData = true;
        notify(); // 唤醒消费者线程
    }

    public synchronized int consume() {
        while (!newData) {
            try {
                wait(); // 等待生产者生产数据
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        newData = false;
        notify(); // 唤醒生产者线程
        return data;
    }
}

public class Main {
    public static void main(String[] args) {
        SharedResource sharedResource = new SharedResource();

        // 生产者线程
        Thread producer = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                sharedResource.produce(i);
                System.out.println("Produced: " + i);
            }
        });

        // 消费者线程
        Thread consumer = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                int value = sharedResource.consume();
                System.out.println("Consumed: " + value);
            }
        });

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

线程安全与性能

在多线程编程中，线程安全是一个重要的考虑因素，但同时也需要关注性能。过多的锁和同步可能会导致性能下降，因此需要在线程安全和性能之间进行权衡。

一些常见的性能优化技巧包括：

  • 减小锁的粒度：只在必要的地方使用锁，避免过多的同步。
  • 使用线程池：重用线程可以减少线程创建和销毁的开销。
  • 使用线程安全的集合：选择合适的线程安全集合来减少同步开销。
  • 使用无锁数据结构：例如java.util.concurrent包中的ConcurrentHashMap和ConcurrentLinkedQueue，它们使用了无锁算法来提高性能。

结论

多线程编程是Java中的一个重要主题，它可以帮助我们充分利用多核处理器和提高应用程序的性能。但多线程编程也会带来复杂性和潜在的问题，因此需要谨慎使用。

在本文中，我们介绍了Java线程的基础知识，包括线程的创建与启动、线程的生命周期、线程的同步与互斥、线程池、线程安全的集合、线程间通信等内容。希望本文可以帮助您更好地理解和应用多线程编程，提高Java应用程序的性能和可靠性。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1027269.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Qt5开发及实例V2.0-第八章-Qt模型/视图结构

Qt5开发及实例V2.0-第八章-Qt模型/视图结构

Qt5开发及实例V2.0-第八章-Qt模型/视图结构 第8章 Qt 5模型/视图结构8.1 概述8.1.1 基本概念8.1.2 【实例】&#xff1a;模型/视图类使用 8.2 模型&#xff08;Model&#xff09;8.3 视图&#xff08;View&#xff09;8.4 代理&#xff08;Delegate&#xff09; 本章相关例程源…
阅读更多...
2023.9.19 关于 数据链路层 和 DNS 协议 基本知识

2023.9.19 关于 数据链路层 和 DNS 协议 基本知识

目录 数据链路层 MTU DNS 协议 补充 DHCP协议 数据链路层 基本概念&#xff1a; 考虑相邻两个节点之间的传输&#xff08;通过 网线 / 光纤 / 无线 直接相连的两个设备&#xff09;以太网协议 规定了 数据链路层 和 物理层 的内容 IP地址 与 mac地址 的相互配合 IP地址 描…
阅读更多...
ardupilot的编译过程

ardupilot的编译过程

环境 树莓派4b ubuntu20.04 git 2.25.1 python3.8.10 pixhawk2.4.8 下载源码 &#xff08;已经配置好git环境和ssh&#xff09; git clone --recurse-submodules gitgithub.com:ArduPilot/ardupilot.gitcd ardupilotgit status使用git status检查是否下载完整 如果不完整&a…
阅读更多...
Nuxt 菜鸟入门学习笔记：路由

Nuxt 菜鸟入门学习笔记：路由

文章目录 路由 Routing页面 Pages导航 Navigation路由参数 Route Parameters路由中间件 Route Middleware路由验证 Route Validation Nuxt 官网地址&#xff1a; https://nuxt.com/ 路由 Routing Nuxt 的一个核心功能是文件系统路由器。pages/目录下的每个 Vue 文件都会创建一…
阅读更多...
hadoop测试环境sqoop使用

hadoop测试环境sqoop使用

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 Sqoop看这篇文章就够了_must contain $conditions in where clause._SoWhat1412的博客-CSDN博客 大数据环境 C:\Windows\System32\drivers\etc 修改ip和hostname的对应关系 1…
阅读更多...
将本地项目上传至Github详解

将本地项目上传至Github详解

目录 1 前言2 本地代码上传2.1 命令行方法2.2 图形界面法2.3 结果 1 前言 GitHub是一个面向开源及私有软件项目的托管平台&#xff0c;因为只支持Git作为唯一的版本库格式进行托管&#xff0c;故名GitHub 。开发者常常将github作为代码管理平台&#xff0c;方便代码存储、版本…
阅读更多...
统计物理学复习----热力学的基本规律

统计物理学复习----热力学的基本规律

General Laws of thermodynamics 热力学系统常识 单位制 1大气压强 101325 Pa 基本概念与专业英语 状态参量 pressurevolumetemperature Extensive quantityIntensive quantityMechanicalVPThermal ST Helmholtz Free EnergyEnthalpyInternal EnergyGibbs Free Energy 准…
阅读更多...
ChunJun(OldNameIsFlinkX)

ChunJun(OldNameIsFlinkX)

序言 ChunJun主要是基于Flink实时计算框架,封装了不同数据源之间的数据导入与导出功能.我们只需要按照ChunJun的要求提供原始与目标数据源的相关信息给Chunjun,然后它会帮我们生成能运行与Flink上的算子任务执行,这样就避免了我们自己去根据不同的数据源重新编辑读入与读出的方…
阅读更多...
模块化开发_php中使用redis

模块化开发_php中使用redis

redis 介绍和安装 redis数据库&#xff0c;支持数据持久化&#xff0c;常用与分布式锁&#xff0c;支持事务&#xff0c;持久化&#xff0c;非关心型数据库 区别&#xff1a; 关系型数据库&#xff1a;硬盘&#xff0c;安全&#xff0c;结构简单&#xff0c;易于理解,浪费空间…
阅读更多...
Mac环境下jupyter添加nbextension插件

Mac环境下jupyter添加nbextension插件

1、没有插件的状态 2、在窗口运行命令 pip install jupyter_contrib_nbextensions 安装成功 3、添加 jupyter contrib nbextension install --user 运行后 报错 No module named notebook.base 更新版本后再添加 pip install jupyter notebook6.1.0 jupyter contrib nb…
阅读更多...
vim缓存-交换文件

vim缓存-交换文件

Catf1agCTF靶场 web swp 题目链接&#xff1a;http://catf1ag.cn/ 个人博客&#xff1a;https://sword-blogs.com/ 题目考点&#xff1a; vim在编辑文档的过程中如果异常退出&#xff0c;会产生缓存文件 vim 交换文件名 参考文章&#xff1a;vim手册 https://yianwillis.…
阅读更多...
从零学习开发一个RISC-V操作系统（二）丨GCC编译器和ELF格式

从零学习开发一个RISC-V操作系统（二）丨GCC编译器和ELF格式

本篇文章的内容 一、GCC&#xff08;GUN Compiler Collection&#xff09;1.1 GCC的命令格式1.2 GCC的主要执行步骤1.3 GCC涉及的文件类型 二、ELF简介2.1 ELF文件格式图2.2 ELF文件处理的相关工具2.3 练习 本系列是博主参考B站课程学习开发一个RISC-V的操作系统的学习笔记&…
阅读更多...
只需4步使用Redis缓存优化Node.js应用

只需4步使用Redis缓存优化Node.js应用

介绍 通过API获取数据时&#xff0c;会向服务器发出网络请求&#xff0c;收到响应数据。但是&#xff0c;此过程可能非常耗时&#xff0c;并且可能会导致程序响应时间变慢。 我们使用缓存来解决这个问题&#xff0c;客户端程序首先向API发送请求&#xff0c;将返回的数据存储…
阅读更多...
数据库：Hive转Presto（一）

数据库：Hive转Presto（一）

本人因为工作原因&#xff0c;经常使用hive以及presto&#xff0c;一般是编写hive完成工作&#xff0c;服务器原因&#xff0c;presto会跑的更快一些&#xff0c;所以工作的时候会使用presto验证结果&#xff0c;所以就要频繁hive转presto&#xff0c;为了方便&#xff0c;我用…
阅读更多...
Shader实战（2）：在unity中实现物体材质随时间插值渐变

Shader实战（2）：在unity中实现物体材质随时间插值渐变

目录 前言 一、shader代码 二、材质准备 三、控制代码 前言 最近想做一个物体两套材质随时间插值渐变的效果&#xff0c;本以为可以通过unity自带的Material.Lerp()实现&#xff0c;后来发现这个方法只适用于纯色的情况&#xff0c;其实与Color.Lerp()是同样的效果&#xf…
阅读更多...
深度分析Oracle中的NULL

深度分析Oracle中的NULL

【squids.cn】 全网zui低价RDS&#xff0c;免费的迁移工具DBMotion、数据库备份工具DBTwin、SQL开发工具等 关键点 特殊值NULL意味着没有数据&#xff0c;它声明了该值是未知的事实。默认情况下&#xff0c;任何类型的列和变量都可以取这个值&#xff0c;除非它们有一个NOT N…
阅读更多...
阿里云产品试用系列-云桌面电脑

阿里云产品试用系列-云桌面电脑

无影云电脑&#xff08;WUYING Workspace&#xff09;&#xff0c;是一种易用、安全、高效的云上桌面服务。它支持快速便捷的桌面环境创建、部署、统一管控与运维。无需前期传统硬件投资&#xff0c;帮您快速构建安全、高性能、低成本的企业桌面办公体系。可广泛应用于具有高数…
阅读更多...
[Linux入门]---文本编辑器vim使用

[Linux入门]---文本编辑器vim使用

文章目录 1.Linux编辑器-vim使用2.vim的基本概念4.vim正常模式命令集从正常模式进入插入模式从插入模式转换为命令模式移动光标删除文字复制替换撤销更改跳至指定行 5.vim末行模式命令集5.总结 1.Linux编辑器-vim使用 vi/vim作为Linux开发工具之一&#xff0c;从它的键盘操作图…
阅读更多...
（VS报错）已在 xxxxx.exe 中执行断点指令(__debugbreak()语句或类似调用)-解决方法C++创建对象四种方式

（VS报错）已在 xxxxx.exe 中执行断点指令(__debugbreak()语句或类似调用)-解决方法C++创建对象四种方式

上述报错困扰了我好几天&#xff0c;在网上搜了一天&#xff0c;到最后还是没有解决问题 试过通过项目属性->C/C>代码生成->启用增强指令集->选择AVX&#xff0c;这种方法也没用 但问题出现在创建对象时内存分配问题上 方法一&#xff1a; 如果是这样创建对象&a…
阅读更多...
Linux学习-HIS系统（1）

Linux学习-HIS系统（1）

Git安装 #安装中文支持&#xff08;选做&#xff09; [rootProgramer ~]# echo $LANG #查看当前系统语言及编码 en_US.UTF-8 [rootProgramer ~]# yum -y install langpacks-zh_CN.noarch #安装中文支持 [rootProgramer ~]# vim /etc/locale.co…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023