Thread的基本操作

已于 2023-07-16 12:15:31 修改
阅读量1.5k 收藏 3
点赞数 3
分类专栏： JAVAEE 文章标签： java java-ee
于 2023-03-18 20:17:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pawlaibd/article/details/129633473
版权

目录

一 .  创建线程

    1) 继承Thread类 

   2) 使用Runnable 来创建线程

 3) 继承Thread , 使用匿名内部类

 4)  实现Runnable , 使用匿名内部类

5)  lambda 表达式 创建线程(常用)

二 . Thread 构造方法 与 常用方法

1. 无参构造 Thread()

2. 只有Runnable 参数 Thread(Runnable)

 3. 带有Runnable 与 String  的构造方法 Thread(Runnable,String)

4. 只带有String 参数的构造方法 Thread(String)

 ​Thread 常见属性

1) 获得当前线程的引用

2) 获取ID

3) 获取名称

4) 获取优先级

5) 获取线程的状态

6) 是否存活

7)  是否被中断

 8) 是否后台线程

关于线程中的 run() 方法

三 . 线程的状态

1) 线程休眠

2) 线程中断

3) 线程等待

总结 : 

一 .  创建线程

    1) 继承Thread类 

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("通过继承来创建线程");
    }
}
public class Demo1 {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();
    }
}

   2) 使用Runnable 来创建线程

这种写法通过实现Runnable , 来描述线程中要执行的任务

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("使用实现Runnable 接口 创建线程");
    }
}
public class Demo2 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable());
        t.start();
    }
}

 3) 继承Thread , 使用匿名内部类

public class Demo3 {
    public static void main(String[] args) {
        Thread t = new Thread() {
            @Override
            public void run() {
                System.out.println("继承Thread,匿名内部类");
            }
        };
        t.start();
    }
}

 4)  实现Runnable , 使用匿名内部类

实现方法跟上面相同.(实现了Runnable,重写了run()方法)

public class Demo4 {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("实现Runnable 接口,匿名内部类");
            }
        });
        t.start();
    }
}

5)  lambda 表达式 创建线程(常用)

public class Demo5 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("lambda表达式");
        });
    }
}

总结 : 通常认为Runnable 这种写法更好一点 ~~ 能够做到让线程和线程执行的任务, 更好的进行解耦.  (写代码希望 : 高内聚, 底耦合)

Runnable 单纯的只是描述了一个任务 ~ 至于这个任务是要通过一个进程来执行,还是线程执行,或者是线程池来执行,还是协程来执行, Runnable本身别不关心,Runnable里面的代码也不关心.

二 . Thread 构造方法 与 常用方法

在这里主要将一下几个构造方法 : 

1. 无参构造 Thread()

2. 只有Runnable 参数 Thread(Runnable)

 3. 带有Runnable 与 String  的构造方法 Thread(Runnable,String)

4. 只带有String 参数的构造方法 Thread(String)

 ​Thread 常见属性

Thread 的几个常见属性

1) 获得当前线程的引用

Thread.currentThread();

2) 获取ID

3) 获取名称

4) 获取优先级

public static void main(String[] args) {
        Thread t = new Thread(() -> {
            //获取当前线程的ID
            System.out.println(Thread.currentThread().getId());
            //获取当前线程的名称
            System.out.println(Thread.currentThread().getName());
            //获取当前线程的优先级
            System.out.println(Thread.currentThread().getPriority());
            System.out.println("hello");
        });
        t.start();
    }

5) 获取线程的状态

这里的状态会分为很多种,在后面会重点介绍.

6) 是否存活

这里的线程存活指的是系统内核里的那个线程,是否存活的

public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while (true) {
                //空
            }
        });
        System.out.println(t.isAlive());
        t.start();
        System.out.println(t.isAlive());
    }

7)  是否被中断

这是线程中的一个标志位 默认值为false.

public class Demo11 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("hello");
        });
        t.start();
        System.out.println(t.isInterrupted());
    }
}

 我们通过interrupt() 方法就可以将这个标志位由false 变为 true;

public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("hello");
        });
        t.start();
        System.out.println(t.isInterrupted());
        t.interrupt();
        System.out.println(t.isInterrupted());
    }

 8) 是否后台线程

什么是前台线程 ??  什么是后台线程??

后台线程不阻止java进程结束.

即使后线程还没执行完, java进程该结束就结束了~~

前台线程更好相反

前台线程会阻止java线程结束, 必须得java进程中所有的前台线程都执行完 java进程才结束.

通过Thread 创建出来的线程都是前台线程,

可以通过setDaemon() 将前台设置为后台

public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while (true) {
                //空
            }
        });
        t.start();
        System.out.println(t.isDaemon());
    }

调用setDaemon()

public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while (true) {
                //空
            }
        });
        System.out.println(t.isDaemon());
        //注意这里在设置前后台线程时
        //这个语句要放在t.start()之前
        t.setDaemon(true);
        t.start();
        System.out.println("结束");
    }

关于线程中的 run() 方法

如果通过 t.run() 去调用 ,  那么它会是一个普通的方法去执行, 存在main线程中

public static void main(String[] args) {
        Thread t = new Thread(() -> {
            int j = 5;
            while (j-- > 0) {
                System.out.println("t:" + j);
            }
        });
        t.run();
        int i = 10;
        while (i-- > 0) {
            System.out.println("main :" + i);
        }
    }

通过上述的运行结果我们可以看出,先执行完run()方法,然后再向后执行

如果将t.run() 转换为 t.start()

run() 方法补充 : 

 多线程如何执行 (补充): 

三 . 线程的状态

1) 线程休眠

Thread.sleep()  : 让当前线程进入休眠 , 括号里面放入休眠的时间

Thread.sleep(1000) : 让当前线程休眠1秒  

public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while (true) {
                System.out.println("hello");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        System.out.println("------");
    }

hello在打印的时候也是 1秒打印一个

2) 线程中断

两种方式 : 1. 自己设立一个标志 来控制线程的运行

                  2. 使用线程中的isInterrupted()

1. 手动设置一个标志位 , 来控制线程是否要结束执行~~

t 线程 与 main 线程  都是在一个进程内, 因此它们用了同一份虚拟地址空间.

因此 , 在main线程中修改的isQuit 就会该变 t 线程中的isQuit.

public class Demo15 {
    public static boolean isQuit = false;
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while (!isQuit) {
                System.out.println("hello");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        isQuit = true;
        System.out.println("中断t线程");
    }
}

2. 使用isInterrupted() 来修改线程的标志位

public class Demo16 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("hello");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t.interrupt();
        System.out.println("-----");
    }
}

通过上述的输出结果 : 代码报错之后 , 没有中断 t 线程,还是在继续的执行程序

问题如下 :

修改后的代码 : 

public class Demo16 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("hello");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    break;
                }
            }
        });
        t.start();
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t.interrupt();
        System.out.println("-----");
    }
}

 

这样当它打印完异常日志后 , 我们直接让它break 退出循环.

3) 线程等待

实现一个代码通过 t 线程让i 自增10次

public class Demo17 {
    private static int i = 0;
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            for (int j = 0; j < 10; j++) {
                i++;
            }
        });
        t.start();
        System.out.println(i);
        System.out.println("main线程结束");
    }
}

 输出结果为 0 

问题如下 : 

 修改代码 : 

public class Demo17 {
    private static int i = 0;
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            for (int j = 0; j < 10; j++) {
                i++;
            }
        });
        t.start();
        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(i);
        System.out.println("main线程结束");
    }
}

对于线程等待的补充 : 

上述 t.join()  这句代码是在main线程中, 因此就是让main线程等待 t 线程执行完成.

要注意这里的等待与被等待对象.

另外我们还可以设置等待的时间

t.join(2000) : 表示main线程只等待 t 线程2秒钟. 然后就继续去执行main方法其余语句.

总结 : 

综上的线程的状态, 我们可以构造一个图

艺颗码心
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
rt thread自学笔记
04-24
基于rt-thread官网上的内核说明文档，自己做了详细的注释，希望对大家学习有所帮助。 RT-Thread，全称是 Real Time-Thread，顾名思义，它是一个嵌入式实时多线程操作系统，基本属性之一是支持多任务，允许多个任务同时运行并不意味着处理器在同一时刻真地执行了多个任务。事实上，一个处理器核心在某一时刻只能运行一个任务，由于每次对一个任务的执行时间很短、任务与任务之间通过任务调度器进行非常快速地切换（调度器根据优先级决定此刻该执行的任务），给人造成多个任务在一个时刻同时运行的错觉。在 RT-Thread 系统中，任务通过线程实现的，RT-Thread 中的线程调度器也就是以上提到的任务调度器。
Hbase 基本操作类
07-16
Hbase 基本操作类 static { //此处可以使用hbase的配置文件，也可以通过代码来实例化hbase连接 /* * Configuration HBASE_CONFIG = new Configuration(); * HBASE_CONFIG.set("hbase.zookeeper.quorum", ...
多线程笔记（第一章）
qq_31587111的博客
01-28 385
1.实现多线程可以继承thread和实现runnable接口 2.currentThread方法可返回代码段正在被哪个线程调用的信息thread.currentthread.getname() 3.isAlive()方法判断当前状态是否处于活动状态，实例化mythread thread = new mythread thread.isAlive() 4.sleep()方法是暂时执行 5.如何实现线程安全，使用synchronized关键字 6.获取线程的唯一标识thread.currentThr
java 进阶—线程的常用方法
从零开始的博客
03-02 352
解析（看的懂得小伙伴可以略过）： 我们在主线程中，直接加了 join, 所以得等主线程执行完成再执行主线程，由于我们是在主线程之后加的判断线程 thread-0是否存活，这时候 thread-0 已经执行完任务了，生命周期结束，所以此时的thread-0 已经终止了。举个例子：比如还是前面 thread-0 跟 主线程 抢占cpu执行权，现在我们在主线程中加一个 限制 条件，当主线程 循环到 10 时，让主线程进入阻塞状态，thread-0优先执行完，主线程再开始执行。今天，我们来看看线程的基础操作。
多线程—Thread类的用法
m0_62824239的博客
03-23 723
目录什么是Thread类Thread类的基本用法线程创建最基本的创建方法实现runnable接口使用匿名内部类lambda表达式 Java这个生态中最常用的并发编程方式是多线程。 什么是Thread类 在java标准库中，就提供了一个Thread类，来表示/操作线程。Thread类也可以视为Java标准库提供的API，创建好的Thread实例，其实和操作系统中的线程是一一对应的关系，操作系统，提供了一组关于线程的API，Java对于这组API进一步封装，就成了Thread类。 Thread类的基本用法 线程
Thread线程类基本使用(下)
qq_61797201的博客
07-28 1331
前一篇文章主要介绍了如何创建新线程和如何查看Java进程中的线程信息等知识，这篇文章接着介绍关于Thread的一些构造方法及方法，这篇文章会用到。
Thread 类的基本用法（附详细代码），通俗易懂。
gaoyu0914的博客
04-16 7610
1、线程创建 1.1 继承Thread类 1.2 实现Runnable接口 1.3 匿名内部类 1.4 使用lambda来创建Runnable 2、线程中断 3、线程等待 4、线程休眠 5、获取线程实例
Windows_Thread.rar_thread 操作系统
09-24
线程是操作系统内核调度的基本单元，它代表了进程内的一个执行流。在Windows操作系统中，每个进程可以包含一个或多个线程，这些线程共享同一块内存空间，包括全局变量、堆内存等资源。线程间的通信比进程间通信更...
基于RT-thread的嵌入式操作系统
04-29
【基于RT-thread的嵌入式操作系统】是一种广泛应用于各种单片机环境的实时操作系统（RTOS）。RT-thread由一系列模块组成，旨在提供高效、稳定、安全的运行环境，以支持复杂和实时的应用程序。该操作系统的核心特性...
RT-Thread操作系统移植文件
最新发布
05-16
1. **内核移植**：RT-Thread的内核包括任务调度、中断处理、内存管理等基本功能。移植工作首先需要针对目标硬件平台实现这些内核服务，例如设置中断向量表、初始化内存管理单元（如MMU）、实现任务调度器等。 2. **...
socket thread操作
05-18
总结来说，Socket线程操作是网络编程中的核心技能，需要熟练掌握Socket的基本使用、多线程的同步与通信、异常处理以及性能优化等知识点。通过实践和学习，可以设计出高效、稳定的多线程网络应用。
java thread参数_Java Thread构造参数源码详细介绍
weixin_36466165的博客
02-12 370
Thread类是一个构建线程的关键类，通过传递一个实现了Runnable接口的类就可以简单构造出一个线程对象，下面就来看看有关Thread类的一些基础知识点吧(本文略长请耐心阅读，相信你一定受益匪浅)。Thread一共有8种(public修饰)构造函数和一种(default修饰)默认构造函数，分别如下所示：public Thread() {init(null, null, "Thread-" + ...
Qt 的线程与事件循环
热门推荐
LynFun的专栏
12-18 3万+
周末天冷，索性把电脑抱到床上上网，这几天看了 dbzhang800 博客关于 Qt 事件循环的几篇 Blog，发现自己对 Qt 的事件循环有不少误解。从来只看到现象，这次借 dbzhang800 的博客，就代码论事，因此了解到一些 Qt 深层的实现，虽然是在 Qt 庞大的构架里只算的是冰山的一角，确让人颇为收益。         从 dbzhang800 的博客中转载两篇关于事件循环的文章，放在
Thread的使用
Yan1less的小窝
03-14 234
本文只是初步介绍java中的线程，仅了解其重要方法的用法和需要注意的点。 join()：比如在A线程中调用B.join()。那么在B线程执行完之前A会一直阻塞；底层是用wait实现，所以会释放锁 wait()：阻塞线程 notify()：唤醒线程，这两个方法会成对出现，这两个方法的使用要在锁中或同步块中 sleep()：休眠一段时间；不会释放锁 interrupt()：打断线程，强制结束...
QThread的用法
weixin_37603532的博客
06-22 805
QThread的用法
NSThread使用详解
秋恨雪
05-10 3838
本人录制技术视频地址：https://edu.csdn.net/lecturer/1899 欢迎观看。上一节中，我转载他人的文章，对多线程的理论知识进行了大致的描述，如果想了解的话，请点击这里。接下来的几节内容，我将一一介绍各自的使用。1. NSThread相关的主要方法：创建、启动线程NSThread *thread = [[NSThread alloc] initWithTarget:self...
C#学习Thread
weixin_30449239的博客
09-07 653
.NET框架是C#的运行时类库，.NET是一个多线程的环境。线程(Thread)是进程中一个单一的顺序控制流程。线程是进程中的实体。一个进程可以有多个线程，一个线程必须有一个父进程。 线程一般具有read,blocking和operation三种基本状态。由三种基本状态，衍化出五种线程的基本操作。首先，derive，线程是在进程内派生出来的。其次，schedule，选择一个...
Thread的几种常用方法
小唐同学的博客
05-14 5383
对Thread类中的常用方法进行整理 currentThread（） 返回对当前正在执行的线程对象的引用 public static void main(String[] args) { System.out.println(Thread.currentThread().getName()); } 代码会返回main yield 提示调度程序，当前线程愿意放弃当前对处理器的使用。调度程序可以忽略这个提示。 sleep 导致当前正在执行的线程休眠（暂时停止执行）指定的毫秒数，具
Thread理解和应用
jianpanxia123的博客
04-11 567
目录 一.什么是线程. 进程: 线程 线程和进程的区别: 二.线程的生命周期: 三.Java线程的创建 1.线程创建的方式. 继承Thread类创建线程 实现Runnable 接口创建线程 实现Callable接口开启线程 三种方式的区别: 2.线程池: 什么是线程池: 线程池的作用： 为什么要用线程池: 常见的线程池: 3.本地线程变量ThreadLocal ...
ThreadX操作系统内核用户指南
"ThreadX用户手册英文完整版，包含RTOS_ThreadX相关知识，是全面的操作指南，中文翻译版可能有删减。" ThreadX是一个高性能的嵌入式操作系统内核，由ExpressLogic公司开发并提供。这份User Guide是ThreadX的官方...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值