Thread一般方法

最新推荐文章于 2024-06-25 13:31:33 发布
最新推荐文章于 2024-06-25 13:31:33 发布
阅读量466 收藏
点赞数
分类专栏： 多线程 文章标签： java 后端 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Qwe200000/article/details/123021651
版权

Thread 中的方法

start() 和 run()

  • 直接调用run() ,则仅仅是在主线程中调用了对象的run方法
  • start方法，在start方法中会调用start0() 这个方法，这个是native 修饰的底层方法，调用会，jvm会进行资源分配，然后进行run() 方法的回调，个人认为新的线程就是在 调用start0() 方法是产生的。

sleep 和 yield

sleep

  1. 调用sleep() 方法，会让当前线程从 RUNNING 进入 Timed Waiting 状态（阻塞）
  2. 其他线程可以使用interrupt(线程)，方法打断正在睡眠的线程，这时sleep方法会抛出InterruptedException方法。
  3. 睡眠结束后线程未必会得到执行，试试会从阻塞态编程就绪态，具体的还是得靠时间片轮转
  4. 可以使用TimeUnit的sleep 代替 Thread 的 sleep来获得更好的可读性

yield

  1. 调用yield 会使当前进程从 running进入runnable （就绪态），然后调度其他线程，
  2. 具体实现以来于操作系统的任务调度器 public static native void yield(); 该方法时 由 native 修饰的

线程优先级

  • 线程设置优先级会提示（hint）调度器优先调度该线程，但它仅仅是一个提示
  • 如果 cpu 比较忙，那么优先级高的线程会获得更多的时间片，但 cpu 闲时，优先级几乎没作用
Runnable task1 = () -> {
 int count = 0;
 for (;;) {
 System.out.println("---->1 " + count++);
 }
};
Runnable task2 = () -> {
 int count = 0;
 for (;;) {
 // Thread.yield();
 System.out.println(" ---->2 " + count++);
 }
};
Thread t1 = new Thread(task1, "t1");
Thread t2 = new Thread(task2, "t2");
// t1.setPriority(Thread.MIN_PRIORITY);
// t2.setPriority(Thread.MAX_PRIORITY); 设置优先级
t1.start();
t2.start();

join

/*
一个线程需要另一个线程的结果，但是一般无法准去估计另一个线程的完成时长可以使用
A 需要 B 的结果，那么可以在 A 中调用 B 的join 方法，join(time) 可以设置B在A中的执行时长
*/
static int r1 = 0;
static int r2 = 0;
public static void main(String[] args) throws InterruptedException {
 test3();
}
public static void test3() throws InterruptedException {
     Thread t1 = new Thread(() -> {
     sleep(2);
     r1 = 10;
 });
 long start = System.currentTimeMillis();
 t1.start();
 // 线程执行结束会导致 join 结束
 t1.join(1500);
 long end = System.currentTimeMillis();
 log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
}

interrupt

打断 sleep，wait，join 的线程

这几个方法都会让线程进入阻塞状态

打断 sleep 的线程, 会清空打断状态，以 sleep 为例

private static void test1() throws InterruptedException {
     Thread t1 = new Thread(()->{
        sleep(1);
     }, "t1");
     t1.start();
        sleep(0.5);
     t1.interrupt();
     log.debug(" 打断状态: {}", t1.isInterrupted());
}

java.lang.InterruptedException: sleep interrupted
 at java.lang.Thread.sleep(Native Method)
 at java.lang.Thread.sleep(Thread.java:340)
 at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
 at cn.itcast.n2.util.Sleeper.sleep(Sleeper.java:8)
 at cn.itcast.n4.TestInterrupt.lambda$test1$3(TestInterrupt.java:59)
 at java.lang.Thread.run(Thread.java:745)
21:18:10.374 [main] c.TestInterrupt - 打断状态: false

打断正常的线程

private static void test2() throws InterruptedException {
 	Thread t2 = new Thread(()->{
     while(true) {
         Thread current = Thread.currentThread();
         boolean interrupted = current.isInterrupted();
         if(interrupted) {
             log.debug(" 打断状态: {}", interrupted);
             break;
     		}
     }
     }, "t2");
     t2.start();
     sleep(0.5);
     t2.interrupt();
}

// 输出结果为 true

打断park 线程，不会清空打断状态

private static void test3() throws InterruptedException {
 Thread t1 = new Thread(() -> {
 log.debug("park...");
 LockSupport.park();
 log.debug("unpark...");
 log.debug("打断状态：{}", Thread.currentThread().isInterrupted());
 }, "t1");
 t1.start();
 sleep(0.5);
 t1.interrupt();
}

输出

21:11:52.795 [t1] c.TestInterrupt - park... 
21:11:53.295 [t1] c.TestInterrupt - unpark... 
21:11:53.295 [t1] c.TestInterrupt - 打断状态：true

也就是说在打断以后，打断状态会一直是true，那么接下来的park(),会失效

private static void test4() {
 Thread t1 = new Thread(() -> {
 for (int i = 0; i < 5; i++) {
 log.debug("park...");
 LockSupport.park();
 log.debug("打断状态：{}", Thread.currentThread().isInterrupted());
 }
 });
 t1.start();
 sleep(1);
 t1.interrupt();
}

输出

21:13:48.783 [Thread-0] c.TestInterrupt - park... 
21:13:49.809 [Thread-0] c.TestInterrupt - 打断状态：true 
21:13:49.812 [Thread-0] c.TestInterrupt - park... 
21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true 
21:13:49.813 [Thread-0] c.TestInterrupt - park... 
21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true 
21:13:49.813 [Thread-0] c.TestInterrupt - park... 
21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true 
21:13:49.813 [Thread-0] c.TestInterrupt - park... 
21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true

为了避免打断状态一直是true，可以使用Thread.interrupted()清除打断状态

守护线程域主线程

  • 默认情况下，Java 进程需要等待所有线程都运行结束，才会结束。有一种特殊的线程叫做守护线程，只要其它非守

  • 护线程运行结束了，即使守护线程的代码没有执行完，也会强制结束。

log.debug("开始运行...");
Thread t1 = new Thread(() -> {
 log.debug("开始运行...");
 sleep(2);
 log.debug("运行结束...");
}, "daemon");
// 设置该线程为守护线程
t1.setDaemon(true);
t1.start();
sleep(1);
log.debug("运行结束...");

输出

08:26:38.123 [main] c.TestDaemon - 开始运行... 
08:26:38.213 [daemon] c.TestDaemon - 开始运行... 
08:26:39.215 [main] c.TestDaemon - 运行结束...

垃圾回收线程就是一种守护线程

Tomcat 中的Acceptor 和 Poller 线程都是守护线程，所以 Tomcat 接收到shutdown命令后，不会等待他们处理完当前请求

cc斌斌
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【JAVA】-- 多线程Thread类的常用方法
张修宇的博客
05-17 1万+
一、Thread类的常用方法 1、start（）：启动当前线程 2、run（）：通常需要重写Thread类中的此方法，将创建的线程要执行的操作写在此方法中。 3、currentThread（）：静态方法，返回执行当前代码的线程 4、getName（）：获取当前线程的名字，与3一起使用可得到正在执行的线程的名字 5、setName（）：设置当前线程的名字 6、yield（）：释放当前cpu的执行权 7、join（）：在线程a中调用线程b的join（）；此时线程a就进入阻塞状态，直到线程b完全执行
Android Framework中的线程Thread及它的threadLoop方法
热门推荐
frank 的专栏
04-09 3万+
当初跟踪Camera的代码中的时候一直追到了HAL层，而在Framework中的代码看见了若干个Thread。它们普遍的特点就是有一个threadLoop方法。按照字面的意思应该是这个线程能够循环处理数据。对应我想到到了java上层中的HandlerThread，这个估计也差不多，但当时心里总有一个疙瘩，想弄清楚它到底是怎么循环起来的。Android中java世界的Thread先来看看java是怎么
Java多线程-Thread类的run方法
南七行者的博客
01-09 1541
Java中的线程是基于操作系统的原生线程实现的，而start0()方法主要就是与操作系统进行交互，创建和启动新的系统级线程。以上执行逻辑可能因不同的JVM实现和不同的操作系统有所不同，具体实现代码可以在JVM的源代码中找到。（3）在新的系统级线程上调用Java线程对象的run()方法。通过上面的分析，要让线程执行某段逻辑的关键是，实现run方法。（2）传入一个实现了run方法的Runnable接口的实现类。（2）将Java线程对象与新创建的系统级线程进行关联。（1）申请系统资源创建一个新的系统级线程。
thread方法
soar的博客
01-12 369
线程的常用方法 编号 方法 说明 1 public void start() 使该线程开始执行；Java 虚拟机调用该线程的 run 方法。 2 public void run() 如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任
直接调用 Java 线程的 run() 方法会发生什么？
最新发布
Lorin 洛林的后端技术小站
06-25 878
`直接调用 run() 方法不会启动一个新的线程，它只是普通方法调用，代码在当前线程中同步顺序执行。`
Thread的run（）方法与start（）方法
寸人
08-21 734
今天看到一个面试题问到Thread的run（）方法与start（）方法
Thread 中的run()
weixin_33744854的博客
02-23 326
1 /** 2 * If this thread was constructed using a separate 3 * <code>Runnable</code> run object, then that 4 * <code>Runnable</code> object's <code&gt...
Thread的run方法和start方法
soltex的专栏
11-03 858
创建一个线程的时候用Thread作为父类，例如class OneThread extends Thread { public void run(){  //do something    }} public class MainApp {    public static void main(String[] args){         OneThread ot = new On
Thread 类及常见方法
question_mark的博客
12-03 185
package package1128_2; public class MyThread { public static void main(String[] args) { //直接写代码块里面 new Thread(new Runnable() { @Override public void run() ...
【JavaEE】Thread 类及常用方法
保护小周ღ的博客
03-20 1906
哈喽，大家好~我是保护小周ღ，本期为大家带来的是 Java 多线程的 Thread 类，讲述了 Thread 类的常用方法及常用属性，例如：线程的 name， 如何启动线程，终止线程，等待线程…… 更多精彩敬请期待：保护小周ღ *★,°*:.☆(￣▽￣)/$:*.°★* ‘
Java Thread中的join()方法解释
wenhonglian的博客
08-28 8178
Join作用 join是定义在Thread类中的方法，作用是阻塞当前线程的执行，等到被调用join的线程对象执行完毕才执行继续执行当前线程。在Java源码中的定义如下： public final void join() throws InterruptedException { join(0); } public final synchronized void join(long millis) throws InterruptedException 接下来我们先来看看join的简单使用，这样能
Java--深入JDK和hotspot底层源码剖析Thread的run()、start()方法执行过程
JustinQin
09-26 2274
【学习背景】 今天主要是来了解Java线程Thread中的run()、start()两个方法的执行有哪些区别，会给出一个简单的测试代码样例，快速理解两者的区别，再从源码层面去追溯start()底层是如何最终调用Thread#run()方法的，个人觉得这样的学习不论对面试，还是实际编程来说都是比较有帮助的。 进入正文~ 学习目录一、代码测试二、源码分析2.1 run()方法2.2 start()方法三、使用总结 一、代码测试 执行Thread的run()、start()方法的测试代码如下： public
线程问题：run()方法的调用
m0_59281987的博客
04-07 1120
因此，从源码的角度来看，即使你是通过 `Thread` 类来启动线程，并调用 `run()` 方法，但由于 `target` 成员变量的存在，实际上会调用 `Runnable` 接口中的 `run()` 方法，这就是为什么即使在多线程中，调用 `run()` 方法也会执行 `Runnable` 对象的 `run()` 方法。当 `Thread` 的 `run()` 方法被调用时，它会检查 `target` 是否为 `null`，如果不为 `null`，则调用 `target` 的 `run()` 方法。
Thread类的run方法和start方法
Waiting的博客
12-04 2470
Thread类的run方法和start方法 start方法是Thread类中的方法，用于启动新的线程。而调用run方法时，不会启动新的线程。在调用start方法后，程序会在后台启动新的线程。然后，由这个新的线程调用run方法。start方法主要执行以下操作： 1.启动新线程 2.调用run方法 start方法和run方法之间的关系如下图所示： 代码如下： 运行结果： 总结： 使用start方法才能算是真正开启了新的线程，而只使用run方法不能算是开辟一个新的线程，只能算是在某一个单线程中的顺序执行，本
java Thread类的run（）方法以及start()方法
qfycc92的专栏
10-09 814
最近参加校招的面试，被问到了
Thread 的run方法和start方法的区别
黑天鹅的博客
05-03 1616
start()方法是用来启动线程，实现了多线程运行 点进去查看源码，发现start方法创建一个线程并让线程处于就绪状态，并且在start方法内会调用start0()方法，而start0作为本地方法会用c/c++创建一个线程并且调用run方法运行 private native void start0(); @Override public void run() { ...
可以直接调用 Thread 类的 run 方法吗？
zcx12ZCX的博客
11-23 615
可以直接调用 Thread 类的 run 方法吗？
thread构造方法
09-11
Thread类提供了多个构造方法用于创建线程对象。其中常见的构造方法有以下几种: 1. Thread(): 创建一个新的线程对象。 2. Thread(Runnable target): 使用Runnable对象创建线程对象。 3. Thread(String name): 创建一个新的线程对象，并为其命名。 4. Thread(Runnable target, String name): 使用Runnable对象创建线程对象，并为其命名。 此外，还有一个可以将线程分组管理的构造方法Thread(ThreadGroup group, Runnable target)，但目前我们只需要了解即可。 以下是一些使用不同构造方法创建线程对象的示例: 1. 使用无参数构造方法: Thread thread = new Thread(); 2. 使用传入Runnable对象的构造方法: class MyRunnable implements Runnable { @Override public void run() { // 线程的具体工作 } } public class Demo { public static void main(String[] args) { Thread thread = new Thread(new MyRunnable()); } } 3. 使用传入String的构造方法（给线程起名）: Thread thread = new Thread("MyThreadName"); 请注意，以上示例仅供参考，具体的线程操作可能需要更多的代码来完成其他功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值