JAVAEE之Thread类详解

已于 2024-09-22 16:37:23 修改
阅读量823 收藏 27
点赞数 16
文章标签： java-ee java 开发语言
于 2024-09-22 13:26:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yc_xym/article/details/142236570
版权

一.线程创建

1）继承Thread类

创建一个类，同时继承自标准库的Thread类，在类中重写run方法。

然后，在main函数中实列化刚才创建的类，并通过实例.start（）创建并运行线程。

例：

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

public class Demo1 {

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

注意！！上述代码中run方法并没有手动调用，但最终也执行了。像这样用户手动定义，却没有手动调用，最终被系统/库/框架进行调用的方法被称为“回调函数”（callback）。

2）实现Runnable接口

创建一个类，实现Runnable接口，在里面重写run方法。

在main函数中，实列化创建的类，并将实列填入Thread（）中。

例：

class MyRunnable implements Runnable{

    @Override
    public void run() {
        System.out.println("Hello Thread");
    }
}
public class Demo2 {
    public static void main(String[] args) {
        MyRunnable myRunnable=new MyRunnable();
        Thread t1=new Thread(myRunnable);
        t1.start();


    }
}

其中，Runnable就是用来描述要执行的任务是什么。

线程要执行的任务通过Runnable来描述，而不是通过Thread自己来描述。

通过Runnable，有利于代码解耦合。

3）通过匿名内部类来实现

public class Demo3 {
    public static void main(String[] args) {
        Thread t=new Thread(){
            @Override
            public void run() {
                System.out.println("Hello Thread");
            }
        };

        t.start();
    }
}

匿名内部类，就是“一次性使用的类”，用完就丢。

4）使用lambda创建线程

public class Demo4 {
    public static void main(String[] args) {
        Thread t1=new Thread(()->{
            System.out.println("Hello Thread");
        });

        t1.start();
    }
}

本质上还是匿名内部类，不过更为简化。

二.线程的启动

启动线程一般用start()方法即可

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

注：start与run的区别

作用功能不同：

  1. run方法的作用是描述线程具体要执行的任务；
  2. start方法的作用是真正的去申请系统线程

运行结果不同：

  1. run方法是一个类中的普通方法，主动调用和调用普通方法一样，会顺序执行一次；
  2. start调用方法后, start方法内部会调用Java 本地方法（封装了对系统底层的调用）真正的启动线程，并执行run方法中的代码，run 方法执行完成后线程进入销毁阶段。

三.获取当前线程引用

currentThread()是Thread类的静态方法，能获取到调用这个方法的实列。

public class Demo2 {
    public static void main(String[] args) {
        Thread t1=new Thread(()->{
            System.out.println("t1线程名："+Thread.currentThread().getName());
        });
        t1.start();
        System.out.println("main线程:"+Thread.currentThread().getName());
    }
}

四.中断线程

线程中断指让一个线程结束。

列如有两个线程A和B，B在运行，A想让B结束，核心就是A想办法让B的run方法执行完毕，而不是当B运行一半，A强制让其结束。

JAVA中，结束线程是一个"温柔"的过程，而不是直接粗暴的。

以下为中断线程的一种方法：

public class Demo3 {
    private static boolean isQuite=false;
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(()->{
            while (!isQuite){
                System.out.println("Hello t1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            System.out.println("线程t1结束");
        });
        t1.start();
        Thread.sleep(3000);
        System.out.println("main线程尝试结束t1线程");
        //修改变量，实现中断线程
        isQuite=true;
    }
}

Thread类里有个成员变量interruptued，bool类型，初始值为false

通过使用isInterrupted()方法就会设置以上标准位 

public class Demo4 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(()->{
           Thread currentThread=Thread.currentThread();
           while (!currentThread.isInterrupted()){
               System.out.println("Hello t1");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   throw new RuntimeException();
               }
           }
        });
        t1.start();
        Thread.sleep(3000);
        t1.interrupt();
    }
}
//运行时报错

运行时发现，代码抛出异常。

由于判断isInterrupted()和执行打印时间太快，整个循环大多数时间都花在sleep上。

main函数调用interrupt时，t1线程大概率在sleep状态

此时Interrupt不仅能设置标准位，还会唤醒sleep操作（会抛出异常 ）

注：当sleep被唤醒后，会清空刚才设置的interrupted标准位

因此，我们可以在catch中调整代码，取消抛出异常，并添加break结束循环。

public class Demo4 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(()->{
           Thread currentThread=Thread.currentThread();
           while (!currentThread.isInterrupted()){
               System.out.println("Hello t1");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   System.out.println("调整catch部分");
                   break;   //退出循环
               }
           }
            System.out.println("t1线程结束");
        });
        t1.start();
        Thread.sleep(3000);
        t1.interrupt();
    }
}

上述规则，可以让程序员有更多操作空间。

五.线程的属性与获取方法

1）获取线程的ID

可通过getID（）方法获得线程的ID

 public class Demo1 {
        public static void main(String[] args) {
            Thread t1=new Thread(()->{

            });
            t1.start();
            System.out.println("线程t1id为："+t1.getId());
            System.out.println("main线程id为"+Thread.currentThread().getId());

        }
    }

运行结果：

2）获取线程的名称

通过getName（）方法获取线程的名字

public class Demo1 {
        public static void main(String[] args) {
            Thread t1=new Thread(()->{

            });
            t1.start();
            System.out.println("t1线程名称:"+t1.getName());

        }
    }

如不主动定义，线程名字默认为Thread-0，我们可以在线程里命名线程。

public class Demo1 {
        public static void main(String[] args) {
            Thread t1=new Thread(()->{

            },"自定义名字");
            t1.start();
            System.out.println("t1线程名称:"+t1.getName());

        }
    }

3）获得线程的状态

通过getState（）方法获取线程的状态

  public class Demo1 {
        public static void main(String[] args) {
            Thread t1=new Thread(()->{
                
            });
            t1.start();
            System.out.println("t1线程状态:"+t1.getState());

        }
    }

        

在JAVA中，线程状态分为六种

  1. 新建（NEW）:创建未被使用的线程处于这种状态。

     public class Demo1 {
        public static void main(String[] args) {
            Thread t1=new Thread(()->{

            });
            //t1线程没有start()创建   
            System.out.println("t1线程状态:"+t1.getState());

        }
    }

  2. 运行（RUNNABLE）：调用start（）后，线程就绪（没运行，但随时可以运行）或正在运行的状态都为RUNNABLE。 
    public class Demo1 {
        public static void main(String[] args) {
            Thread t1=new Thread(()->{

            });
            t1.start();
            System.out.println("t1线程状态:"+t1.getState());

        }
    }

  3. 无限期等待（WAITING）：线程不会被分配cpu执行时间，无限的等待。使用无参数的join（）时可能会进入此状态。 
     public class Demo1 {
        public static void main(String[] args) throws InterruptedException {
            Thread t1=new Thread(()->{
            while (true){

            }
            });
            Thread t2=new Thread(()->{
                try {
                    t1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            t1.start();
            t2.start();
            Thread.sleep(2000);
            System.out.println("t2线程状态:"+t2.getState());

        }
    }

  4. 限期等待（TIMED_WAITING）：处于这种状态的线程也不会被分配CPU执行时间，不过无须等待被其他线程显式地唤醒，在一定时间之后它们会由系统自动唤醒。（sleep（）和带参数的join（）可使线程进入此状态） 
       public class Demo1 {
        public static void main(String[] args) throws InterruptedException {
            Thread t1=new Thread(()->{
            while (true){

            }
            });
            Thread t2=new Thread(()->{
                try {
                    t1.join(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            t1.start();
            t2.start();
            Thread.sleep(2000);
            System.out.println("t2线程状态:"+t2.getState());

        }
    }

  5. 阻塞（BLOCKED）：线程被阻塞了

  6. 结束（TERMINATED）：已终止线程的线程状态，线程已经结束执行。

4）获取进程优先级

线程通过getPriority（）方法获取线程优先级。

设置不同优先级会影响系统调度。

public class Demo1 {
        public static void main(String[] args) throws InterruptedException {
            Thread t1=new Thread(()->{

            });
            t1.start();
            System.out.println("线程t1优先级:"+t1.getPriority());
            System.out.println("main线程优先级:"+Thread.currentThread().getPriority());
        }
    }

5）获取线程是否为后台线程

何为前台线程与后台线程

再介绍方法前，先介绍何为前台线程与后台线程

前台线程：某个线程在运行过程中，能够阻止进程结束，为"前台线程"（main线程）。

后台线程（守护进程）：线程在运行过程中，不能阻止进程结束，随着进程一起结束，为“后台线程”。

简单来说，如果当main线程结束后，进程还在进行，那该线程为前台线程

如以下代码

 public class Demo1 {
        public static void main(String[] args) throws InterruptedException {
            Thread t1=new Thread(()->{
            while(true){
                System.out.println("Hello Thread");
            }
            });
            t1.start();
            System.out.println("main线程结束");
        }
    }

main线程已经结束，t1线程却还在运行，此时t1为前台线程

当我们用setDaemon()将t1线程设为后台线程时，main线程结束将带走t1线程

 public class Demo1 {
        public static void main(String[] args) throws InterruptedException {
            Thread t1=new Thread(()->{
            while(true){
                System.out.println("Hello Thread");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            });
            //将t1设为后台进程
            t1.setDaemon(true);
            t1.start();

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

获取是否为后台线程

通过isDaemon()来获取线程是否为后台进程，若是返回true，否返回false

 public class Demo1 {
        public static void main(String[] args) throws InterruptedException {
            Thread t1=new Thread(()->{
            while(true){
                System.out.println("Hello t1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            });
            Thread t2=new Thread(()->{
                while(true){
                    System.out.println("Hello t2");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            t1.setDaemon(true);
            t1.start();
            t2.start();
            System.out.println("t1线程是否为后台线程"+t1.isDaemon());
            System.out.println("t2线程是否为后台线程"+t2.isDaemon());

        }
    }

6）获取线程是否存活

代码中，创建的NEW Thread对象，生命周期和内核实际中的线程是不一定一样的。

可能会出现Thread对象仍然存在，但内核中的线程不存在这种情况（不会出现Thread对象不存在，但内核线程存在）。

通过isAlive()获取线程是否存活

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(()->{
            for (int i = 0; i < 3; i++) {
                System.out.println("Hello t1");
            }
        });
        System.out.println("t1线程创建前的存活状态"+t1.isAlive());
        t1.start();
        System.out.println("t1线程创建后的存活状态"+t1.isAlive());;
        Thread.sleep(4000);
        System.out.println("t1线程结束后的存活状态"+t1.isAlive());
    }
}

六.线程休眠

通过Thread.sleep()可以使线程休眠（阻塞）

public class Demo5 {
    public static void main(String[] args) throws InterruptedException {
        long start=System.currentTimeMillis();  //获取线程开始时间
        Thread.sleep(2000);  //休眠2000ms
        long end=System.currentTimeMillis();
        System.out.println("线程运行时间:"+(end-start));

    }
}

   sleep 的原理就是让原本在 就绪队列 中的线程，转移到 阻塞队列 中去，等 sleep 的时间到了，再转移到 就绪队列 中。​

七.线程等待

多线程并发编程，一般情况下线程的调度顺序是不确定的。

通过join()可以干预线程的结束顺序

以下代码，主线程等待t1线程结束后再结束

    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(()->{
            for (int i = 0; i < 3; i++) {
                System.out.println("Hello t1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("t1线程结束");
        });
        t1.start();
        System.out.println("主线程开始等待");
        t1.join();
        System.out.println("主线程结束等待");
    }

以上代码join不带参数，会等到特定线程结束后继续运行，为"死等"。

join还有带参数的版本，在（）内填写参数，超过时间后，等待线程也会执行。

以上便是全部内容，若有不对，欢迎指正

yc_xym
关注
【JavaEE】Thread类详解
p_fly的博客
01-09 176
上篇文章【JavaEE】操作系统+进程+线程_p_fly的博客-CSDN博客 讲了线程的概念，接下来就介绍如何创建线程和相关的注意事项。目录创建线程的五种常用写法1.继承Thread类2.使用匿名内部类，继承Thread类3.实现Runnable接口4.使用匿名内部类，实现Runnable接口5.Lambda表达式Thread类中的部分方法静态方法(类方法)获取线程实例休眠线程构造方法实例方法获取Thread的常见属性描述线程的任务启动(创建)线程等待线程中断线程在Java中，操作多线程最核心的类就是Thr
JavaEE——Thread类详解
lzhNox的博客
07-23 330
Thread类详解
【JavaEE】详解Object类
horsa的博客
05-30 1452
Object类
JavaEE: 死锁问题详解
月临水的博客
08-06 774
本文详细介绍了死锁的出现场景及其解决方法，包括线程连续加锁、两个线程两把锁、多个线程多个锁等情况，并分析了死锁的四个必要条件。同时，文章还讨论了内存可见性问题及其原因，提出了使用volatile关键字解决内存可见性问题的方法。通过对synchronized和volatile关键字的深入解析，强调了在多线程编程中正确使用锁和关键字的重要性。
【JavaEE】synchronized原理详解
p_fly的博客
07-17 1294
synchronized的加锁过程是逐步提高的，并不是一上来就要加重量级锁。
【JavaEE初阶】 死锁详解
m0_71731682的博客
10-12 1483
本文重点：死锁咋回事死锁的三个典型情况死锁的四个必要条件如何破除死锁。
JavaEE之反射（详解）
ChatYU的博客
06-22 693
什么是反射，类对象的获取方式及通用场景，反射实例化，有参构造器和无参构造器反射实例化，各种反射动态方法调用
【JavaEE初阶】 线程池详解与实现
m0_71731682的博客
10-22 1548
线程池，是一种线程的使用模式，它为了降低线程使用中频繁的创建和销毁所带来的资源消耗与代价。通过创建一定数量的线程，让他们时刻准备就绪等待新任务的到达，而任务执行结束之后再重新回来继续待命。线程池最核心的设计思路：复用线程，平摊线程的创建与销毁的开销代价相比于来一个任务创建一个线程的方式，使用线程池的优势体现在如下几点：提升了响应速度是怎么体现的呢？这里博主和大家详细说一下：此时呢，我们的线程池就像方法一，我们可以利用已经存在的线程自己完成操作，而不是去重新创建。Executors 创建方式有以下几个注意上述
Thread线程类基本使用(下)
qq_61797201的博客
07-28 1468
前一篇文章主要介绍了如何创建新线程和如何查看Java进程中的线程信息等知识，这篇文章接着介绍关于Thread的一些构造方法及方法，这篇文章会用到。
javaee编写小bbs
12-25
在BBS应用中，我们可以通过JPA定义实体类（如User、Thread、Post），然后使用CRUD（Create、Read、Update、Delete）操作与数据库进行交互。 6. **会话管理** 在论坛中，用户登录后可能需要保持状态，这就涉及到了...
JavaEE学习之走进Servlet
ozl520的博客
12-21 437
Servlet引言1.C/S架构和B/S架构1.2 C/S架构（Client/Server 客户端/服务端）1.3 B/S架构（Browser/Server 浏览器/服务器）服务器1.概念1.1 什么是web三级目录 引言 1.C/S架构和B/S架构 c/s和b/s架构是软件发展过程中出现的两种软件架构方式 1.2 C/S架构（Client/Server 客户端/服务端） 特点：必须在客户端安装特定软件 优点：图形效果显示较好（如：3d游戏） 缺点：服务器的软件和功能进行升级，客户端也必须升级，不利于
JavaEE实战——XML文档DOM、SAX、STAX解析方式详解
李春春的专栏
06-22 5793
本文主要介绍XML文档作为存储和传输数据的三种解析方式，其各自主要的思想、实现方式、CURD实现，以及最后展示一个综合的实战例子加以巩固理解。
安卓开发 之小白养成-Service详解
qq_34506989的博客
10-31 587
什么是Service ervice是Android中四大组件之一，在Android开发中起到非常重要的作用。Service（服务）是一个没有用户界面的在后台运行执行“耗时操作”的应用组件。其他应用组件能够启动Service，并且当用户切换到另外的应用场景，Service将持续在后台运行。另外，一个组件能够绑定到一个service与之交互（IPC机制），例如，一个service可能会处理网络操作，播...
【后端开发】JavaEE初阶——计算机是如何工作的？？？
GGBond778的博客
09-20 1405
本期讲解了关于计算机的构成，主要讲解了关于CPU的相关知识，以及操作系统中最主要的进程控制块和进程的相关知识如状态，通信等问题。
计算机毕业设计宠物领养网站我的发布领养领养用户信息/springboot/javaWEB/J2EE/MYSQL数据库/vue前后分离小程序
计算机程序开发设计
09-26 1196
Node.js‌：‌Node.js是一个开源、跨平台的JavaScript运行环境，允许在服务器端运行JavaScript代码。‌为解决传统服务器阻塞问题，Node.js采用单线程模式，使用事件驱动、非阻塞和异步模型等技术提高性能。‌基于Google的V8引擎，优化应用程序的传输量和规模，提高代码复用性和可维护性。‌可用于构建Web应用、API接口项目、跨平台桌面应用等，同时支持读写和操作数据库、创建命令行工具等。Node.js支持模块化编程，可将代码拆分成独立并互相依赖的小模块，便于管理和维护。
Java EE中的编码问题及解决方案
最新发布
Yhame的博客
09-26 244
确保所有数据输入、处理和输出环节中的编码一致，能够有效避免乱码问题。这包括表单提交、JSP页面、Servlet响应、数据库交互及任何外部文件的读取和写入等。通过以上的编码设置，可以提高应用程序的健壮性和用户体验。希望本文能帮助您在Java EE开发中顺利处理字符编码问题！
【JavaEE初阶】深入解析死锁的产生和避免以及内存不可见问题
GGBond778的博客
09-26 1581
本期总结了关于多线程的重要知识即死锁，分别从造成原因和如何进解决提出了关于小编的理解，以及线程安全问题之内存可见性问题，并附上了代码供小伙伴们参考参考~~~
工厂模式的介绍及实现
户伟伟的博客
09-25 70
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
Java基础：继承Thread类创建线程详解
"这篇资源主要涉及的是Java编程的基础知识，特别是关于如何通过继承Thread类来创建线程。同时，还涵盖了Java学习的概述、重要知识点、学习方法以及Java软件工程师应掌握的技术体系。" 在Java编程中，创建线程有多种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值