JavaEE 多线程

最新推荐文章于 2024-10-07 10:57:45 发布
最新推荐文章于 2024-10-07 10:57:45 发布
阅读量551 收藏 6
点赞数 4
分类专栏： JavaEE 文章标签： java-ee java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mwt258/article/details/134770861
版权

JavaEE 多线程

文章目录

引子

当进入多线程这一块内容时，我们之前对代码的逻辑认知可能会被颠覆！

为什么这么说？让我们看看下面这段代码：

package demo1;

public class Test1 {
    public static void main(String[] args) {

        boolean judge = true;
        while (judge) {
            System.out.println("你出不去了!!");
        }
        judge = false;
        System.out.println("我出来了!!");

    }
}

从单线程的角度，这是一个逻辑闭环，死循环后面的代码无法被执行，它"永远都出不去"！代码会一直陷入循环之中：在这里插入图片描述

但对于多线程来说，死循环也阻止不了它:

在这里插入图片描述

为什么能够做到这一点？这就涉及到多线程的特性了！

多线程

1. 特性

  • 每个线程都是一个独立的执行流
  • 多个线程之间是“并发”执行的

线程的调用方法我们使用lambda表达式(之前的文章有对其进行讲解)，看看下面的代码：

package demo1;

import static java.lang.Thread.sleep;

public class Test3 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (true) {
                System.out.println("你好！");
                try {
                    sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            
        });
        t.start(); // 在这里才开始创建线程
        while (true) {
            System.out.println("你也好！！");
            sleep(1000);
        }
    }
}

在这里插入图片描述

从上述执行结果可以看出，两个线程都在并发执行，大大提高了程序整体的运行效率！！

注：

  1. main函数本身为主线程

  2. 仔细观察可以发现，两个线程执行的先后顺序是不确定的，这和线程的"随机调度"有关：

    • 一个线程，什么时候被调度到cpu执行是不确定的
    • 一个线程，什么时候从cpu上下来，给其它线程让位是不确定的

    这种“随机调度”的特性很可能会造成"抢占式执行"，从而造成线程安全问题

  3. 只有调用start()方法后t线程才会被创建

  4. **sleep()**方法可以对线程进行休眠，参数以毫秒为单位

2. Thread类

2.1 概念

Thread类是JVM用来管理线程的一个类，且每个线程都有一个唯一的Thread对象与之关联

每个执行流需要有一个对象来描述，而Thread类的对象就是用来描述一个线程执行流的，JVM会将这些Thread对象组织起来，用于线程调度，线程管理。

2.2 Thread的常见构造方法
方法说明
Thread()创建线程对象
Thread(Runnable target)使用Runnable创建线程对象
Thread(String name)创建线程对象，并命名
Thread(Runnable target, String name)使用Runnable创建线程对象，并命名
Runnable runnable = new Runnable() {
    @Override
    public void run() {
    }
};
Thread t1 = new Thread();
Thread t2 = new Thread(runnable);
Thread t3 = new Thread("线程3");
Thread t4 = new Thread(runnable, "线程4");
2.3 Thread的几个常见属性
属性获取方法
IDgetId()
名称getName()
状态getState()
优先级getPriority()
是否后台进程isDaemon()
是否存活isAlive()
是否被中断isInterrupted()

  • ID是线程的唯一标识，不同线程不会重复

  • 优先级高的线程理论上来说更容易被调度到

  • 是否存活，可以理解为run方法是否运行结束了

  • JVM会在一个进程的所有非后台线程结束后，才会结束运行：

    // 默认线程t为前台线程，前台线程未结束时，整个进程不会结束
package demo2;

public class Test5 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
           for (int i = 0;i < 10;i++) {

               try {
                   System.out.println(Thread.currentThread().getName() +  "：本线程还活着");
                   Thread.sleep(1000);

               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
           }
           System.out.println(Thread.currentThread().getName() + "：本线程将消失");
        });


        System.out.println("ID-" + t.getId());
        System.out.println("名称-" + t.getName());
        System.out.println("状态-" + t.getState());
        System.out.println("优先级-" + t.getPriority());
        System.out.println("后台线程-" + t.isDaemon());

        t.start();

        for (int j = 0;j < 5;j++) {
            System.out.println("我是主线程");
            Thread.sleep(1000);

        }
        System.out.println("主线程结束了");
    }

}

    在这里插入图片描述

    // 这里修改t为后台线程，则主线程结束整个进程就结束
package demo2;

public class Test5 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
           for (int i = 0;i < 10;i++) {

               try {
                   System.out.println(Thread.currentThread().getName() +  "：本线程还活着");
                   Thread.sleep(1000);

               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
           }
           System.out.println(Thread.currentThread().getName() + "：本线程将消失");
        });

        t.setDaemon(true); // 这里修改t为后台线程，则主线程结束整个进程就结束

        System.out.println("ID-" + t.getId());
        System.out.println("名称-" + t.getName());
        System.out.println("状态-" + t.getState());
        System.out.println("优先级-" + t.getPriority());
        System.out.println("后台线程-" + t.isDaemon());

        t.start();

        for (int j = 0;j < 5;j++) {
            Thread.sleep(2000);
            System.out.println("我是主线程");

        }
        System.out.println("主线程结束了");
    }
}

    在这里插入图片描述

2.4 启动一个线程

之前我们通过覆写run方法创建了一个线程对象，但线程对象被创建出来并不代表着线程就开始运行了，我们需要通过调用start()方法才真正在操作系统的底层创建出一个线程:

public class Test6 {
    public static void main(String[] args) {
        Thread t = new Thread(()->{
            System.out.println("hh");
        });
        // 此时线程并未完全创建
    }
}

在这里插入图片描述

调用t.start()方法后，才算创建线程成功，同时自动调用run方法(被覆写)：

在这里插入图片描述

2.5 中断一个线程

目前常见的中断线程方式有以下两种：

  1. 用共享的标记来进行沟通

    package demo2;

public class Test7 {
    public static volatile boolean isQuit = false; // 这里需要给标志位加上volatile关键字
    public static void main(String[] args) throws InterruptedException {

        Thread t = new Thread(() -> {
            while (!isQuit) {
                System.out.println("我是一个线程，正在工作中");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });

        t.start();
        for (int i = 5;i >= 0;i--) {
            System.out.println("倒计时: " + i);
            Thread.sleep(1000);
        }
        System.out.println("让线程结束工作");
        isQuit = true;
        System.out.println("线程工作结束！");

    }
}

    在这里插入图片描述

  2. 使用thread对象的interrupted()方法来通知线程结束

    方法说明
    Thread.currentThread().isInterrupted()判断当前线程中断标志是否设置
    Thread.currentThread().Interrupt()设置中断标志中断该线程

    注：Thread.currentThread()操作是获取当前的线程实例(t)，哪个线程调用，得到的就是哪个线程的实例

    package demo2;

public class Test8 {

    public static void main(String[] args) throws InterruptedException {

        Thread t = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {

                try {
                    System.out.println("我是一个线程，正在工作中");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });

        t.start();
        for (int i = 5;i >= 0;i--) {
            System.out.println("倒计时: " + i);
            Thread.sleep(1000);
        }
        System.out.println("让线程结束工作");
        t.interrupt();
        System.out.println("线程工作结束！");

    }
}

    在这里插入图片描述

注：thread收到通知的方式有两种：

  1. 如果线程因为调用wait/join/sleep等方法而阻塞挂起，则以InterruptedException异常的形式通知，同时清除中断标准；

    当出现InterruptedException的时候，要不要结束线程取决于catch中代码的写法，可以选择忽略这个异常，也可以通过break跳出循环结束线程；

  2. 如果只是内部的一个中断标志被设置，thread可以通过；

    Thread.currentThread().isInterrupted()判断指定线程的中断标志是否设置，不清除中断标志，这种方式通知收到的更及时，即使线程正在sleep也可以马上收到。

2.6 等待一个线程

有时候一个线程需要等待另一个一个线程完成它的工作后，才能进行自己的下一步工作。这个时候可以通过join()方法来进行线程等待。

join(): 在哪个线程中调用join方法则当前线程要等待引用线程执行完后才能执行,如在主线程中调用t.join();则主线程要等待t线程执行完后才能执行

package demo2;

public class Test9 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            for (int i = 0;i < 5;i++) {
                System.out.println("t-线程工作中！");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });

        t.start();
        t.join();
        System.out.println("main 执行了");

    }
}

在这里插入图片描述

join()方法也可以设置时间限制，最多等待X毫秒，时间一到线程就停止阻塞等待:

t.join(2000);

在这里插入图片描述

2.7 获取当前线程引用

public static Thread currentThread(); 返回当前线程对象的引用

package demo2;

public class Test10 {
    public static void main(String[] args) {
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName());
    }
}

在这里插入图片描述

2.8 休眠当前线程

public static void sleep (long millis) throws InterruptedException; 休眠当前进程millis毫秒

注：因为线程的调度是不可控的，所有这个方法只能保证实际休眠时间是大于等于参数设置的休眠时间的

package demo2;

public class Test11 {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("开始时间：" + System.currentTimeMillis());
        Thread.sleep(3000); // 休眠主线程
        System.out.println("结束时间：" + System.currentTimeMillis());
    }
}

在这里插入图片描述

3. 线程状态

  • NEW: Thread对象创建好了，但是还没有调用start方法在系统中创建线程；
  • RUNNABLE：就绪状态，表示这个线程正在cpu上执行或准备就绪随时可以去cpu上执行；
  • TIME_WATING: 表示指定时间的阻塞，达到一定时间后会自动解除阻塞，一般是调用sleep方法或有时间参数的join方法时会进入该状态；
  • WATINGT: 表示不带时间的阻塞(死等)，必须要满足一定条件才会解除阻塞，一般调用wait方法或join方法会进入该状态；
  • BLOCKED: 锁竞争引起的阻塞;
  • TERMINATED: Thread对象仍然存在，但是系统内部的线程已经执行完毕了

在这里插入图片描述

&梧桐树夏
关注
专栏目录
笔记14-JAVAEE之多线程初阶
12-16
【JavaEE之多线程初阶】 在JavaEE开发中，多线程是提升系统性能和并发处理能力的重要手段。本文将深入探讨多线程的基本概念、应用以及关键特性。 1. **认识线程（Thread）** 1.1 概念 - **线程是什么**：线程被...
笔记16-JAVAEE之多线程进阶
12-17
Java 多线程进阶 - 锁策略与读写锁 在 Java 多线程编程中，锁策略和读写锁是两个非常重要的概念。本文将对 Java 多线程进阶中的锁策略和读写锁进行详细介绍。 锁策略 在多线程编程中，锁策略是一个非常重要的概念...
JAVAEE 多线程
m0_56364861的博客
03-23 299
javaee 多线程部分 比特汤老师 搬运
JavaEE多线程4
wu_yi_min的博客
08-11 752
CAS全称Compare and swap，字面意思是“交换和比较”。一个CAS操作包括以下操作：1）比较A和V是否相同（比较）2）如果比较相同，将B写入V（交换）此处虽然叫做“交换”，实际达到的效果是“赋值”3）返回操作是否成功特点：虽然一个CAS操作包含3个具体操作，但真实的CAS是一个原子的cpu指令完成的。这样的指令是线程安全的！
JavaEE多线程死锁
哒哒的博客
10-17 449
JavaEE多线程死锁
JavaEE多线程(2)
HD_13的博客
06-20 1221
现有t1线程t2线程和locker1锁locker2锁， locker2锁要对t1线程中内容加锁，但同时locker2锁对t2线程还未解锁，所以t1线程需要阻塞等待，而现在locker1锁也要对t2线程中的内容加锁，但是locker1对t1线程还未解锁，所以t2线程需要阻塞等待，这样就导致你等我，我等你的死锁现象`通过条件，判断当前逻辑是否能够执行，如果不满足条件不能执行，那么就主动进行阻塞(wait)让其他线程来调度cpu的资源，等到条件满足的时候，再让其它线程（阻塞的线程）来唤醒。
javaEE 多线程的实现和线程池
qq_45551151的博客
08-08 645
javaEE多线程线程的实现方法一线程的实现方法二实现Runnable于继承Thread相比的优点：线程阻塞 （主动阻塞）线程的中断用户线程和守护线程线程安全问题线程不安全处理1. 同步线程 synchronized 枷锁 线程排队执行 隐式锁（自己创建的）2.显式锁 Lock公平锁（先来先到）和不公平锁（一顿乱抢）；线程死锁多线程通信问题（生产者与消费者）线程的六大状态CallableRunnable 与Callable的相同点Runnable 与Callable的不同点缓存线程池定长线程池周期性任务执行
05-04 JavaEE多线程
2203_75335776的博客
05-04 178
04-28JavaEE多线程
2203_75335776的博客
04-28 193
519-JavaEE多线程线程安全问题
2203_75335776的博客
05-19 167
JAVAEE多线程synchronized 优化过程
哒哒的博客
10-12 872
JAVAEE多线程synchronized 优化过程
JavaEE基础教程 多线程PPT教案学习.pptx
09-30
JavaEE基础教程多线程PPT教案学习 本资源提供了多线程编程的基础知识，涵盖了进程和线程的概念、线程的创建、线程的生命周期等内容。下面是从该资源中提取的知识点： 1. 进程的概念：进程是程序的一次执行过程，...
JavaEE学习[JavaSE-06多线程.rar]
03-29
在JavaEE的学习过程中，多线程是不可或缺的一部分，尤其对于服务器端应用来说，多线程能够有效地利用系统资源，提高程序的并发处理能力。 多线程是Java编程中的核心概念，它允许一个程序同时执行多个任务。在Java中...
【JavaEE】【多线程】进程与线程的概念
最新发布
yj20040627的博客
10-07 1993
线程与进程概念讲解，及Java中创建一个线程
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 931
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1221
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
JDK1.0主要特性
FoolRabbit的专栏
10-06 364
JDK1.0主要特性。
字符函数和字符串函数和内存函数
Java_fenxiang的博客
10-05 705
strtok函数原型与功能概述在 C 语言中，strtok函数的原型为char *strtok(char *str, const char *delim)。它的主要功能是将字符串str按照delim中指定的分隔符进行分割，返回被分割出来的子字符串。工作原理首次调用：当第一次调用strtok时，需要将待分割的字符串str作为...
JavaEE多线程进阶：乐观锁与悲观锁策略解析
本笔记深入探讨了JAVAEE中的多线程进阶知识，主要涉及常见的锁策略以及CAS（Compare and Swap）机制。首先，介绍了两种基本的锁概念：乐观锁与悲观锁。 乐观锁假设在大部分情况下数据不会发生并发冲突，只在更新时...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值