多线程 -- Java

已于 2024-08-26 13:48:43 修改
阅读量156 收藏 2
点赞数 4
分类专栏： SpringBoot 文章标签： java jvm 开发语言
于 2024-08-26 12:09:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53839898/article/details/141558154
版权

1  线程的基础概念

1.1  什么是线程？

定义：线程是程序执行的最小单元。一个进程可以包含多个线程，这些线程共享进程的内存空间，但他们可以独立执行。

线程与进程的区别：线程是进程的一个子集，进程是一个独立的运行环境，而线程是在进程内部执行的多个任务

1.2  示例代码

public class BasicThreadExample {
    public static void main(String[] args) {
        // 主线程
        System.out.println("Main thread is running");

        // 创建一个新线程
        Thread thread = new Thread(() -> System.out.println("New thread is running"));
        thread.start(); // 启动新线程

        System.out.println("Main thread is finishing");
    }
}

1.3  输出

Main thread is running
New thread is running
Main thread is finishing

 解释：这里的 Thread 是一个独立的线程，它与主线程并行运行。

2  创建线程

2.1  方式一：继承 Thread 类

class MyThread extends Thread {
    @Override
    public void run() {
        // 线程执行的代码
        System.out.println("线程正在运行: " + Thread.currentThread().getName());
    }
}

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

2.2  方式二：实现 Runnable 接口

class MyRunnable implements Runnable {
    @Override
    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();  // 启动线程
    }
}

3  管理线程的生命周期

线程的生命周期包括创建、运行、等待（sleep）、阻塞（block）、终止等。你可以使用 start() 方法启动线程，sleep() 方法让线程休眠一段时间，join() 方法等待线程完成。

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> { //创建一个线程
            try {
                Thread.sleep(1000);  // 线程休眠1秒
                System.out.println("线程完成");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        thread.start();  // 启动线程

        try {
            thread.join();  // 等待线程结束
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("主线程继续执行");
    }
}

4   线程同步

当多个线程访问共享资源时，可能会发生数据不一致的问题。可以使用 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 thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

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

        thread1.join();
        thread2.join();

        System.out.println("计数器的值: " + counter.getCount());
    }
}

5  使用线程池

如果需要创建和管理大量的线程，可以使用 ExecutorService 提供的线程池。

package com.czq.utils.test;

import com.czq.utils.PerformanceTester;

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

public class test {
    public void serveCustomer(){

        ExecutorService executor = Executors.newFixedThreadPool(5);  // 创建一个有3个线程的线程池

        executor.submit(this::takeOrder);
        executor.submit(this::cookFood);
        executor.submit(this::serveFood);
        executor.submit(this::billCustomer);

        executor.shutdown(); // 关闭线程池，等待所有任务完成

        // 等待所有任务完成
        while (!executor.isTerminated()) {
            // 可以执行一些其他的操作或仅仅等待
        }

//        if (executor.awaitTermination(60, TimeUnit.SECONDS)) {
//            System.out.println("所有任务完成！");
//        } else {
//            System.out.println("仍有任务未完成！");
//        }  
//        60：表示你希望最多等待 60 个时间单位。在这里是 60 秒。
//        TimeUnit.SECONDS：指定了时间单位为秒。TimeUnit 是一个枚举，提供了多种时间单位，如秒 (SECONDS)、毫秒 (MILLISECONDS)、分钟 (MINUTES) 等。

        System.out.println("所有任务完成！");
    }

    private void takeOrder() {
        try {
            System.out.println("我已经开始工作啦   ---   点餐");
            Thread.sleep(1000); // 模拟点餐时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("点餐完成！");
    }

    private void cookFood() {
        try {
            System.out.println("我已经开始工作啦   ---   做菜");
            Thread.sleep(3000); // 模拟做菜时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("做菜完成！");
    }

    private void serveFood() {
        try {
            System.out.println("我已经开始工作啦   ---   上菜");
            Thread.sleep(1000); // 模拟上菜时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("上菜完成！");
    }

    private void billCustomer() {
        try {
            System.out.println("我已经开始工作啦   ---   结账");
            Thread.sleep(500); // 模拟结账时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("结账完成！");
    }

    public static void main(String[] args) {

        test t = new test();

        Runnable testTask = () -> {

//            System.out.println("服务员接受点餐...");
//            t.takeOrder();
//            System.out.println("服务员传递订单到厨房...");
//            t.cookFood();
//            System.out.println("服务员上菜...");
//            t.serveFood();
//            System.out.println("服务员结账...");
//            t.billCustomer();

            t.serveCustomer();
        };
        // 测试代码的执行时间，进行10次测试取平均值
        PerformanceTester.testPerformance(testTask, 1);
    }
}

6  运行示例

6.1  顺序执行

package com.czq.utils.test;

import com.czq.utils.PerformanceTester;

public class test {
    public void serveCustomer() {
        Thread orderThread = new Thread(this::takeOrder);
        Thread cookThread = new Thread(this::cookFood);
        Thread serveThread = new Thread(this::serveFood);
        Thread billThread = new Thread(this::billCustomer);

        orderThread.start();  // 接受点餐
        cookThread.start();   // 做菜
        serveThread.start();  // 上菜
        billThread.start();   // 结账

        try {
            orderThread.join();
            cookThread.join();
            serveThread.join();
            billThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("所有任务完成！");
    }

    private void takeOrder() {
        try {
            System.out.println("我已经开始工作啦   ---   点餐");
            Thread.sleep(1000); // 模拟点餐时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("点餐完成！");
    }

    private void cookFood() {
        try {
            System.out.println("我已经开始工作啦   ---   做菜");
            Thread.sleep(3000); // 模拟做菜时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("做菜完成！");
    }

    private void serveFood() {
        try {
            System.out.println("我已经开始工作啦   ---   上菜");
            Thread.sleep(1000); // 模拟上菜时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("上菜完成！");
    }

    private void billCustomer() {
        try {
            System.out.println("我已经开始工作啦   ---   结账");
            Thread.sleep(500); // 模拟结账时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("结账完成！");
    }

    public static void main(String[] args) {

        test t = new test();

        Runnable testTask = () -> {

            System.out.println("服务员接受点餐...");
            t.takeOrder();
            System.out.println("服务员传递订单到厨房...");
            t.cookFood();
            System.out.println("服务员上菜...");
            t.serveFood();
            System.out.println("服务员结账...");
            t.billCustomer();

//            t.serveCustomer();
        };
        // 测试代码的执行时间，进行10次测试取平均值
        PerformanceTester.testPerformance(testTask, 1);
    }
}

输出：

服务员接受点餐...
我已经开始工作啦   ---   点餐
点餐完成！
服务员传递订单到厨房...
我已经开始工作啦   ---   做菜
做菜完成！
服务员上菜...
我已经开始工作啦   ---   上菜
上菜完成！
服务员结账...
我已经开始工作啦   ---   结账
结账完成！
Average operation took 5524 milliseconds.

6.2  多线程

package com.czq.utils.test;

import com.czq.utils.PerformanceTester;

public class test {
    public void serveCustomer() {
        Thread orderThread = new Thread(this::takeOrder);
        Thread cookThread = new Thread(this::cookFood);
        Thread serveThread = new Thread(this::serveFood);
        Thread billThread = new Thread(this::billCustomer);

        orderThread.start();  // 接受点餐
        cookThread.start();   // 做菜
        serveThread.start();  // 上菜
        billThread.start();   // 结账

        try {
            orderThread.join();
            cookThread.join();
            serveThread.join();
            billThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("所有任务完成！");
    }

    private void takeOrder() {
        try {
            System.out.println("我已经开始工作啦   ---   点餐");
            Thread.sleep(1000); // 模拟点餐时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("点餐完成！");
    }

    private void cookFood() {
        try {
            System.out.println("我已经开始工作啦   ---   做菜");
            Thread.sleep(3000); // 模拟做菜时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("做菜完成！");
    }

    private void serveFood() {
        try {
            System.out.println("我已经开始工作啦   ---   上菜");
            Thread.sleep(1000); // 模拟上菜时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("上菜完成！");
    }

    private void billCustomer() {
        try {
            System.out.println("我已经开始工作啦   ---   结账");
            Thread.sleep(500); // 模拟结账时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("结账完成！");
    }

    public static void main(String[] args) {

        test t = new test();

        Runnable testTask = () -> {

//            System.out.println("服务员接受点餐...");
//            t.takeOrder();
//            System.out.println("服务员传递订单到厨房...");
//            t.cookFood();
//            System.out.println("服务员上菜...");
//            t.serveFood();
//            System.out.println("服务员结账...");
//            t.billCustomer();

            t.serveCustomer();
        };
        // 测试代码的执行时间，进行10次测试取平均值
        PerformanceTester.testPerformance(testTask, 1);
    }
}

输出：

我已经开始工作啦   ---   点餐
我已经开始工作啦   ---   结账
我已经开始工作啦   ---   上菜
我已经开始工作啦   ---   做菜
结账完成！
上菜完成！
点餐完成！
做菜完成！
所有任务完成！
Average operation took 3012 milliseconds.

颜回.
关注
专栏目录
JAVA-多线程 所有文件
01-09
这个“JAVA-多线程 所有文件”压缩包很可能包含了一系列关于Java多线程学习的源代码示例和相关文档。下面我们将深入探讨Java多线程的相关知识点。 1. **线程的概念**：线程是操作系统分配CPU时间的基本单位，一个...
Java多线程-Socket编程
01-27
Java 多线程-Socket 编程 Java 多线程-Socket 编程是指在 Java 语言中使用多线程技术来实现网络编程，特别是使用 Socket 编程来实现客户端和服务器端的通信。在 Java 中，多线程可以使用 Thread 类和 Runnable 接口...
java线程-Java内存模型
06-17
Java提供了synchronized和java.util.concurrent包下的原子类（如AtomicInteger）来保证某些操作的原子性，确保多线程环境下的数据完整性。 3. 有序性问题：JVM为了优化性能，可能会对指令进行重排序，但这可能导致...
Java多线程-多功能演示系统.zip
02-02
Java多线程-多功能演示系统，连接MySQL数据库利用多线程实现信息交流，为教师提供教学服务，便于教师整理教学资料，整合所需知识内容，更好的为学生提供生动形象的理解方式，加强教师与学生之间的互动沟通。
java多线程-新.xmind
03-02
一个自己整理的多线程相关知识梳理思维导图，里面若有不正确的还望指出
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 882
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
JDK1.0主要特性
FoolRabbit的专栏
10-06 285
JDK1.0主要特性。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 489
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring依赖注入和注解驱动详解和案例示范
J老熊
10-01 1000
在 Spring 框架中，依赖注入（Dependency Injection, DI）和注解驱动（Annotation-Driven）是其核心机制，它们为 Spring 应用提供了灵活性和可扩展性。依赖注入简化了对象间的依赖管理，而注解驱动则通过简洁的注解配置取代了繁琐的 XML 配置。本文将详细分析这两个机制，并通过示例加深理解。
字符函数和字符串函数和内存函数
Java_fenxiang的博客
10-05 628
strtok函数原型与功能概述在 C 语言中，strtok函数的原型为char *strtok(char *str, const char *delim)。它的主要功能是将字符串str按照delim中指定的分隔符进行分割，返回被分割出来的子字符串。工作原理首次调用：当第一次调用strtok时，需要将待分割的字符串str作为...
Springboot人才求职招聘系统源码（前台+后台）
最新发布
10-06 459
项目技术：springboot运行环境：jdk1.8+idea/eclipse+maven3+mysql5.6。
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 1443
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
Java内存布局
阿呆的专栏
10-01 824
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
Java中的break、continue和return语句
weixin_73230994的博客
10-05 351
break语句用于终止某个语句块的执行，一般使用在switch或者循环【for, while ,do-while】（提前退出或结束循环不是终止程序）1.continue语句用于结束本次循环，继续执行下一次循环2.continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环，这个和前面的标签的使用规则一样。
【RocketMQ】RocketMQ应用难点
记录一名在读研究生的学习笔记、感悟、开发产物
09-30 931
本文探讨了RocketMQ中消息重复消费的问题及其解决方案，尤其是在CLUSTERING模式下的扩容影响。文章分析了重复消费的原因，如广播模式、负载均衡模式下的多consumerGroup消费、消费者组内的动态变化及网络延迟等，并提出了利用唯一标识进行去重的方法。此外，还讨论了如何选择合适的存储机制以高效处理大量消息标识，如HashMap、MySQL、Redis以及推荐的布隆过滤器等方案。对于防止消息堆积与确保消息不丢失，也给出了相应的策略和技术措施。
11.2 Linux_线程_同步与互斥
Fresh_man111的博客
10-03 183
同一时刻只允许一个任务访问的共享资源。比如写入文件，就是一个临界资源，当写入文件时，不允许两个任务同时往里面写。如果A写入abc，B写入def，同时写的情况下文件中的值不一定为abcdef，这时就需要在某一时刻只允许A写入abc，在另一时刻只允许B写入def。
【hot100-java】【合并两个有序链表】
m0_73629042的博客
09-30 402
记忆中，两个指针合并即可。
SpringBoot线程问题
juanmiao的专栏
10-04 493
程序，线程，线程池进程是资源分配最小单位，线程是程序执行的最小单位。计算机在执行程序时，会为程序创建相应的进程，进行资源分配时，是以进程为单位进行相应的分配，每个进程都有相应的线程，在执行程序是，实际上是执行相应的一系列线程。线程：程序执行流的最小执行单位，是行程中实际运作单位，经常容易和进程这个概念混淆简单来说，一个应用程序的运行就可以被看做是一个进程。是运行中实际的执行任务者，可以说，进程中包含了多个可以同时运行的线程。线程的生命周期。
Python并发编程(1)——Python并发编程的几种实现方式
一点
10-03 1059
Python 并发编程是指在 Python 中编写能够同时执行多个任务的程序。并发编程在任何一门语言当中都是比较难的，因为会涉及各种各样的问题，在Python当中也不例外。Python 提供了多种方式来实现并发，包括多线程（threading）、多进程（multiprocessing）、异步编程（asyncio），以及一些高级用法concurrent.futures和第三方库如gevent。
jmu-java-07多线程-thread
03-16
JMU Java 07 多线程 (Thread) 是指在 Java 语言中使用多个线程来同时执行多个任务的技术。通过使用多线程，可以提高程序的并行处理能力，加快程序的执行速度，提高程序的效率。在 Java 中，多线程可以通过继承 java.lang.Thread 类或实现 java.lang.Runnable 接口来实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

颜回.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值