【JavaSE】一文搞懂Java多线程，代码示例，清晰明了（上）

已于 2022-11-07 22:49:17 修改
阅读量3.2k 收藏 12
点赞数 11
分类专栏： JavaSE 文章标签： java
于 2022-09-23 11:00:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42146402/article/details/127005486
版权

Java多线程

前言

本文为Java多线程相关知识，Java全栈学习路线可参考：【Java全栈学习路线】最全的Java学习路线及知识清单，Java自学方向指引，内含最全Java全栈学习技术清单~

一、Java多线程简要概述

1.线程的核心概念

  1. 线程就是独立执行的路径
  2. 在程序运行时，即使没有自己创建线程，后台也会有多个线程，比如 主线程，gc线程
  3. main()称之为主线程，为系统的入口，用于执行整个程序
  4. 在一个进程中，如果避开了多个线程，现成的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的
  5. 对同一份资源进行操作时，会存在资源抢夺的问题，需要加入并发控制
  6. 线程会带来额外的开销，如cpu调度时间，并发控制开销
  7. 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

二、线程的创建

1.继承Thread

  1. 继承Thread类，重写run方法，调用Start()方法开启线程
  2. 不建议使用：为了避免OOP单继承的局限性

代码展示：

package com.wang.多线程;
// 创建线程方法一：继承Thread类，重写run方法，调用Start()方法开启线程
public class ThreadTest1 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 1200; i++) {
            System.out.println("Thread多线程" + i);
        }
    }
    public static void main(String[] args) {
        ThreadTest1 threadTest = new ThreadTest1(); // 创建一个线程对象
        threadTest.start(); // 调用start()方法开启线程
        for (int i = 0; i < 1200; i++) {
            System.out.println("main主线程" + i);
        }
    }
}


// 打印结果
main主线程0
Thread多线程0
Thread多线程1
Thread多线程2
Thread多线程3
Thread多线程4
main主线程1
Thread多线程5
.....
可以看得出来，这两个线程是同时在进行的

2.实现Runnable接口

  1. 重写run方法，执行线程需要丢入runnable接口实现类。调用start()方法
  2. 推荐使用：很好的避免了单继承的局限性，灵活方便，同一个对象被多个线程使用

代码展示

package com.wang.多线程;
public class RunnableTest implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1200; i++) {
            System.out.println("Runnable线程:" + i);
        }
    }
    public static void main(String[] args) {
        RunnableTest runnableTest = new RunnableTest();
        new Thread(runnableTest).start();
        for (int i = 0; i < 1200; i++) {
            System.out.println("main方法：" + i);
        }
    }
}


// 打印结果
main方法：0
Runnable线程:0
Runnable线程:1
Runnable线程:2
main方法：1
main方法：2
main方法：3
main方法：4
Runnable线程:3
....

3.实现Callable接口

  1. 创建一个实现Callable接口的类，实现call方法。将操作声明在call里。
  2. 创建Callable接口实现类的对象。然后创建执行服务，在提交服务，最后记得要关闭服务

代码展示：

package com.wang.多线程;
import java.util.concurrent.*;
public class CallableTest1 implements Callable<Boolean> {
    @Override
    public Boolean call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "Callable:" + i);
        }
        return true;
    }
    public static void main(String[] args) throws Exception{
        CallableTest1 callableTest1 = new CallableTest1();
        CallableTest1 callableTest2 = new CallableTest1();
        CallableTest1 callableTest3 = new CallableTest1();
        // 创建执行服务
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        // 提交执行
        Future<Boolean> future1 = executorService.submit(callableTest1);
        Future<Boolean> future2 = executorService.submit(callableTest2);
        Future<Boolean> future3 = executorService.submit(callableTest3);
        // 获取结果
        boolean b1 = future1.get();
        boolean b2 = future2.get();
        boolean b3 = future3.get();
        System.out.println(b1);
        System.out.println(b2);
        System.out.println(b3);
        // 关闭服务
        executorService.shutdownNow();
    }
}
// 打印
pool-1-thread-3Callable:2
pool-1-thread-3Callable:3
pool-1-thread-3Callable:4
pool-1-thread-3Callable:5
pool-1-thread-3Callable:6
pool-1-thread-3Callable:7
pool-1-thread-1Callable:0
pool-1-thread-2Callable:0
pool-1-thread-2Callable:1
看这个3Callable和1Callable还有2Callable同时在输出

三、线程状态

1.五大状态

  1. 创建状态
  2. 就绪状态
  3. 运行状态
  4. 阻塞状态
  5. 死亡状态

如图所示：
在这里插入图片描述

2.停止线程

  1. 使用标志位方式

代码展示：

package com.wang.多线程;
public class StopThread_04 implements Runnable{
    // 设置标志位
    private boolean stop = true;
    @Override
    public void run() {
        int i = 0;
        while (stop) {
            System.out.println("Run...." + i);
        }
    }
    // 写一个标志位，用来停止某个线程
    public void stop() {
        this.stop = false;
    }
    public static void main(String[] args) {
        StopThread_04 stopThread = new StopThread_04();
        new Thread(stopThread).start();
        for (int i = 0; i < 500; i++) {
            System.out.println("main...." + i);
            if (i == 490) {
                // 调用stop方法停止线程
                stopThread.stop();
                System.out.println("run线程停止了");
            }
        }
    }
}
// 打印
main....0
Run....0
main....1
Run....0
main....2
Run....0
...
main....490
Run....0
run线程停止了

3.线程休眠（阻塞状态）

  1. PS:每一个对象都有一把锁，sleep不会释放锁
  2. sleep()的作用是让当前线程休眠，即当前线程会从“运行状态”进入到“休眠(阻塞)状态”。sleep()会指定休眠时间，线程休眠的时间会大于/等于该休眠时间；在线程重新被唤醒时，它会由“阻塞状态”变成“就绪状态”，从而等待cpu的调度执行。

代码展示：

package com.wang.多线程;
import java.text.SimpleDateFormat;
import java.util.Date;
// 线程休眠
public class ThreadSleep_05 {
    public static void main(String[] args) throws InterruptedException {
//        ThreadSleep_05.tenDown();  // 这个方法是模拟倒计时
        // 模拟打印系统当前时间
        Date Time = new Date(); // 获取当前时间
        while (true) {
            Thread.sleep(1000); // 休眠1秒
            long time = Time.getTime(); // 将时间转换为long类型
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HH:mm:ss"); // 将获取的时间格式化
            String format = simpleDateFormat.format(time); // 将long类型的时间转换为字符串形式
            System.out.println(format);
            Time = new Date(); // 从新获取时间起到更新时间的作用
        }
    }
    // 模拟倒计时
    public static void tenDown() throws InterruptedException {
        int num = 30;
        while (true) {
            Thread.sleep(1000);
            System.out.println(num--);
            if (num <= 0) {
                break;
            }
        }
    }
}
// 打印
14:05:04
14:05:05
14:05:06
14:05:07
14:05:08
14:05:09
14:05:10
14:05:11
即休眠一秒

4.线程礼让

  1. 首先礼让是不一定成功的
  2. 礼让线程，让当前正在执行的线程暂停，但不阻塞
  3. 将线程从运行状态转为就绪状态

代码展示：

package com.wang.多线程;
public class ThreadYield_06 implements Runnable{
    public static void main(String[] args) {
        ThreadYield_06 threadYield = new ThreadYield_06();
        new Thread(threadYield, "轿车").start();
        new Thread(threadYield, "货车").start();
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "线程开始");
        Thread.yield(); // 线程礼让方法
        System.out.println(Thread.currentThread().getName() + "线程结束");
    }
}
// 打印情况1：礼让成功
货车线程开始
轿车线程开始
货车线程结束
轿车线程结束
// 礼让不成功
轿车线程开始
轿车线程结束
货车线程开始
货车线程结束

5.合并线程(插队)

  1. 顾名思义插队就是有些线程它需要优先去执行

代码展示：

package com.wang.多线程;
public class ThreadJoin_07 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("vip插队" + i);
        }
    }
    public static void main(String[] args) {
        ThreadJoin_07 threadJoin = new ThreadJoin_07();
        Thread thread = new Thread(threadJoin);
        thread.start();
        for (int i = 0; i < 500; i++) {
            if (i == 150) { // 当i= 150 时，开始插队，插队线程执行完另一个才会继续
                try {
                    thread.join(); // 插队方法
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("main" + i);
        }
    }
}
// 打印
main149
vip插队64
vip插队65
vip插队66
vip插队67
....
vip插队997
vip插队998
vip插队999
main150
main151

6.观察状态

代码展示：

package com.wang.多线程;
public class StateThread_08 {
    public static void main(String[] args) {
        Thread thread = new Thread( () -> {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(">>>>>>>>>>>>>");
        });
        // 观察状态
        Thread.State state = thread.getState();
        System.out.println(state);  // NEW 尚未启动的线程处于此状态。
        // 观察启动后
        thread.start(); // 启动线程
        state = thread.getState();
        System.out.println(state); // RUNNABLE 在Java虚拟机中执行的线程处于此状态。
        while (state != Thread.State.TERMINATED) { // 只要线程不终止，就一直输出
            try {
                Thread.sleep(100);
                state = thread.getState(); // 更新线程状态
                System.out.println(state);  //  TIMED_WAITING  线程处于阻塞（等待）状态
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

四、线程优先级

1.线程优先级

  1. 优先级一共分为1-10 越大级别越高 默认情况下为5
  2. 最重要的一点，并不是一定高的就执行快。线程的优先级和执行顺序无关

代码展示：

package com.wang.多线程;
public class ThreadPriority implements Runnable{
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName() +
                "--->" + Thread.currentThread().getPriority());
        ThreadPriority threadPriority = new ThreadPriority();
        Thread thread1 = new Thread(threadPriority);
        Thread thread2 = new Thread(threadPriority);
        Thread thread3 = new Thread(threadPriority);
        Thread thread4 = new Thread(threadPriority);
        Thread thread5 = new Thread(threadPriority);
        Thread thread6 = new Thread(threadPriority);
        // 设置优先级
        thread1.start();
        thread2.setPriority(5);
        thread2.start();
        thread3.setPriority(9);
        thread3.start();
        thread4.setPriority(10);
        thread4.start();
        thread5.setPriority(2);
        thread5.start();
        thread6.setPriority(3);
        thread6.start();
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() +
                "--->" + Thread.currentThread().getPriority());
    }
}
// 打印
main--->5
Thread-0--->5
Thread-2--->9
Thread-1--->5
Thread-3--->10
Thread-5--->3
Thread-4--->2
由此可以看出10级并没有第一个执行完

后记

本文下接：【多线程】一文搞懂Java多线程，代码示例，清晰明了（下）
Java全栈学习路线可参考：【Java全栈学习路线】最全的Java学习路线及知识清单，Java自学方向指引，内含最全Java全栈学习技术清单~

小新要变强
关注
  • 11
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java|Java多线程案例
Autovy blog
05-04 2474
线程的创建及状态 1.线程的生命周期 2.创建一个线程 import java.util.concurrent.TimeUnit; public class ThreadStateTest { public static void main(String[] args) throws InterruptedException { // 创建一个线程对象 Thread thread = new Thread(); System.out.println
Java多线程的使用，一篇文章带你理解多线程，手把手的代码实现案例
D1561691的博客
04-02 420
线程安全的单例懒汉式线程的死锁问题========方法三：Lock锁synchronized 与 Lock 的对比线程的通信=====wait() 与 notify() 和 notifyAll()sleep()和wait()线程通信的经典案例：创建多线程的方式三=========实现Callable接口创建多线程的方式四=========自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
Java多线程-黑马阿玮
qq_67786627的博客
09-19 161
任务拒绝策略说明默认策略：丢弃任务并抛出RejectedExecutionException异常丢弃任务，但是不抛出异常，这是不推荐的做法抛弃队列中等待时间最久的任务，然后把当前任务加入队列中调用任务的run()方法绕过线程池直接执行/*(核心线程数量，最大线程数量，空闲线程最大存活时间，任务队列，创建线程工厂，任务的拒绝策略)参数一：核心线程数量 不能小于0参数二：最大线程数 不能小于等于0，最大数量》=核心线程数量参数三：空闲线程最大存活时间 不能小于0。
java多线程
最新发布
qq_64376339的博客
05-18 751
首先，什么是线程安全问题呢？线程安全问题指的是，多个线程同时操作同一个共享资源的时候，可能会出现业务安全问题。下面通过一个取钱的案例给同学们演示一下。案例需求如下场景：小明和小红是一对夫妻，他们有一个共享账户，余额是10万元，小红和小明同时来取钱，并且2人各自都在取钱10万元，可能出现什么问题呢？如下图所示，小明和小红假设都是一个线程，本类每个线程都应该执行完三步操作，才算是完成的取钱的操作。但是真实执行过程可能是下面这样子的。
编程必备：JAVA多线程详解
拾一二的博客
06-14 7885
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
JAVA多线程实现案例
weixin_52014130的博客
07-22 3621
1.继承Thread类实现多线程的格式权限修饰符类名extendsThread{}2.实现Runnable接口实现多线程的格式权限修饰符类名implementsRunnable{}1.通过继承Thread类本身。2.通过实现Runnable接口。3.通过Callable和Future创建线程池。Thread类本身也是实现了Runnable接口来达到开启线程的目的。.........
Java多线程示例，包括错误案例以及正确案例
10-28
Java多线程示例，包括错误案例
javaSE多线程的案例源代码
04-01
本文将深入探讨Java多线程的核心概念，包括如何创建线程、线程优先级、线程组、线程同步以及线程间的通信，这些都是基于提供的源代码案例进行的讲解。 首先，创建线程主要有两种方式：通过实现Runnable接口或继承...
Java多线程批量数据导入的方法详解
08-25
Java多线程批量数据导入的方法详解 在数据处理中，遇到大量数据导入时，为了提高处理的速度，可以选择使用多线程来批量处理这些处理。常见的场景有大文件导入数据库、数据同步等。在这些场景中，数据导入的过程可以...
javase之多线程技术
10-16
Java中的多线程技术是Java进阶学习的重要组成部分，它涉及到并发编程的理论与实践，旨在提高程序的执行效率和响应速度。以下是对多线程技术的详细解释： 1. **CPU调度算法原理** - **先来先服务（FCFS）**：按照...
JavaSE多线程
09-15
JavaSE的多线程特性是其强大的功能之一，它允许开发者编写能够同时处理多个任务的程序，从而提高程序的效率和响应性。在Java中，线程是程序执行的最小单位，而进程则是资源分配的基本单位。每个Java应用程序至少有一...
java多线程经典案例
01-15
java多线程经典案例，线程同步、线程通信、线程阻塞等经典案例
java 多线程示例
08-17
一个很完整的例子来介绍java的多线程，对初学者有不错的借鉴意义
Java多线程 线程组原理及实例详解
08-25
主要介绍了Java多线程 线程组原理及实例详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java创建多线程的五种写法
qq_62718027的博客
06-21 2169
其实就是在Thread里面多了一个new Runnable。(线程和主程序运行结果可能会调换顺序)​​​​​​​。(线程和主程序运行结果可能会调换顺序)​​​​​​​。(线程和主程序运行结果可能会调换顺序)​​​​​​​。(线程和主程序运行结果可能会调换顺序)​​​​​​​。(线程和主程序运行结果可能会调换顺序)
通过代码简单而深入的了解多线程的意义和使用
高新富的博客
06-12 272
文章目录并发概述影响并发的因素硬件层面软件层面多线程如何影响服务端的并发数量并行概述线程线程的特点同步异步线程的构建方式继承Thread类案例举例实现Runnable接口案例举例Callable/Future 带返回值概述案例举例线程的生命周期/状态state线程的启动概述源码分析Thread.start()线程的停止线程什么时候会停止线程停止的方式 并发 概述 1.这里的并发，主要是针对同一个服务实体或者应用，能否承载的请求数量 比如:我们说，京东的出单，对于京东的服务器应用来讲，并发数量10万，就是
【Java之多线程篇】——吐血整理Java多线程详解（知识点+代码）
qq_50497708的博客
03-25 6176
目录： 线程基本概念 并行\并发的区别 多线程优点和何时使用多线程 多线程创建的两种方式：继承Thread类、实现Runnable接口（代码） 线程的生命周期 线程的同步 用线程同步解决线程安全问题的方式（一）：同步代码快、同步方法、Lock锁（代码） 死锁 线程通信的例子——涉及wait()、notify()、notifyAll()） 面试题：sleep()和wait()的异同 生产者和消费者例题 用线程同步解决线程安全问题的方式（二）：实现Callable()接口、线程池 基本
Java多线程编程
chenmi123321的博客
10-19 998
java
Java多线程具体代码实战
菜根檀的博客
11-16 681
Java中的多线程通过继承Thread创建一个线程守护进程线程池join() 首先，我们需要明白在Java中，多线程就是一个类或者一个程序执行或者管理多个线程执行任务的能力，线程总是处于5种状态之中，分别是：创建，可运行，运行中，阻塞，死亡。 创建：使用 new 运算符后，该线程仅仅是一个空对象，系统没有分配资源，该线程处于创建状态（new thread） 可运行：使用start()方法启动一个线程后，系统为该线程分配了除了CPU外的所需资源，该线程处于可运行状态（Runnable） 运行：Java运行系统
用java输出学生信息表代码_学生信息管理系统JAVASE版
05-31
以下是一个简单的Java学生信息管理系统的代码示例，包括添加学生、查询学生和删除学生三个基本功能。您可以根据需要进行修改和完善。 ```java import java.util.ArrayList; import java.util.Scanner; public class StudentInfoSystem { private ArrayList<Student> students; public StudentInfoSystem() { students = new ArrayList<Student>(); } public void addStudent(Student student) { students.add(student); } public void removeStudent(int id) { for (int i = 0; i < students.size(); i++) { if (students.get(i).getId() == id) { students.remove(i); System.out.println("删除成功！"); return; } } System.out.println("未找到该学生！"); } public void queryStudent(int id) { for (int i = 0; i < students.size(); i++) { if (students.get(i).getId() == id) { System.out.println(students.get(i).toString()); return; } } System.out.println("未找到该学生！"); } public void showAllStudents() { for (int i = 0; i < students.size(); i++) { System.out.println(students.get(i).toString()); } } public static void main(String[] args) { StudentInfoSystem sis = new StudentInfoSystem(); Scanner scanner = new Scanner(System.in); while (true) { System.out.println("请选择操作：1.添加学生 2.删除学生 3.查询学生 4.显示所有学生 5.退出"); int choice = scanner.nextInt(); switch (choice) { case 1: System.out.println("请输入学生ID："); int id = scanner.nextInt(); System.out.println("请输入学生姓名："); String name = scanner.next(); System.out.println("请输入学生年龄："); int age = scanner.nextInt(); System.out.println("请输入学生性别："); String gender = scanner.next(); Student student = new Student(id, name, age, gender); sis.addStudent(student); System.out.println("添加成功！"); break; case 2: System.out.println("请输入要删除的学生ID："); int id2 = scanner.nextInt(); sis.removeStudent(id2); break; case 3: System.out.println("请输入要查询的学生ID："); int id3 = scanner.nextInt(); sis.queryStudent(id3); break; case 4: sis.showAllStudents(); break; case 5: System.exit(0); default: System.out.println("输入有误，请重新输入！"); break; } } } } class Student { private int id; private String name; private int age; private String gender; public Student(int id, String name, int age, String gender) { this.id = id; this.name = name; this.age = age; this.gender = gender; } public int getId() { return id; } public String getName() { return name; } public int getAge() { return age; } public String getGender() { return gender; } public String toString() { return "ID：" + id + " 姓名：" + name + " 年龄：" + age + " 性别：" + gender; } } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小新要变强

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

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

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

打赏作者

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

抵扣说明：

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

余额充值