【多线程:一些方法的注意点】

简介: 【多线程:一些方法的注意点】

【多线程:一些方法的注意点】

01.start 与 run

我们知道 start方法是运行Thread里的run方法,那么我们之间调用run方法,这两者之前的区别是什么

例子

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.Test")
public class Test {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread("t1"){
            @Override
            public void run() {
                log.debug(Thread.currentThread().getName());
            }
        };
        t1.start();
        t1.sleep(100);
        t1.run();
    }
}

结果

18:27:56.487 c.Test [t1] - t1

18:27:56.487 c.Test [main] - main

可以看出 直接调用 run 是在主线程中执行了 run,没有启动新的线程 使用 start 是启动新的线程,通过新的线程间接执行 run 中的代码

02. sleep 与 yield

sleep与yield的区别

sleep

  1. 调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态(阻塞)
  2. 其它线程可以使用 interrupt 方法打断正在睡眠的线程,这时 sleep 方法会抛出 InterruptedException
  3. 睡眠结束后的线程未必会立刻得到执行
  4. 建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性

yield

  1. 调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态,然后调度执行其它线程
  2. 具体的实现依赖于操作系统的任务调度器

sleep状态

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.Test6")
public class Test6 {

    public static void main(String[] args) {
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        t1.start();
        log.debug("t1 state: {}", t1.getState());

        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.debug("t1 state: {}", t1.getState());
    }
}

结果

18:53:22.128 c.Test6 [main] - t1 state: RUNNABLE
18:53:22.633 c.Test6 [main] - t1 state: TIMED_WAITING

刚开始调用的时候t1状态为运行态,之后当t1线程调用sleep时 主线程查看t1的状态为TIMED_WAITING(阻塞)

yield状态

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.TestYield")
public class TestYield {
    public static void main(String[] args) {
        Runnable task1 = () -> {
            System.out.println("---->1 ");
        };
        Runnable task2 = () -> {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Thread.yield();
            System.out.println("              ---->2 ");

        };
        Thread t1 = new Thread(task1, "t1");
        Thread t2 = new Thread(task2, "t2");
        t1.start();
        log.debug("t2 state: {}", t2.getState());
        t2.start();
        log.debug("t2 state: {}", t2.getState());

    }

}

结果

---->1
00:28:50.450 c.TestYield [main] - t2 state: NEW
00:28:50.454 c.TestYield [main] - t2 state: RUNNABLE

          ---->2 

可以看出t2线程yield让步后就变为了RUNNABLE就绪态

补充:

yield并不是一定会让步,它的原理是把自己让出 然后变成就绪态 然后和其它线程再争抢cpu,所以有可能yield后还是此线程。

例子

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.Test9")
public class Test9 {

    public static void main(String[] args) {
        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.start();
        t2.start();
    }
}

结果

---->1 16193
---->1 16194
---->1 16195
---->1 16196
---->1 16197
---->1 16198
---->1 16199
---->1 16200
---->1 16201
---->1 16202
---->1 16203
---->1 16204
---->1 16205
---->1 16206
---->1 16207
---->1 16208
---->1 16209
---->1 16210
---->1 16211

          ---->2 4458
          ---->2 4459
          ---->2 4460
          ---->2 4461
          ---->2 4462
          ---->2 4463
          ---->2 4464
          ---->2 4465
          ---->2 4466
          ---->2 4467

可以看出yield让步大概率是 让步到其它线程,但并不代表此线程就一定会让步。

再补充:Priority(优先级)

线程优先级会提示调度器优先调度该线程,但它仅仅是一个提示,调度器可以忽略它 如果 cpu 比较忙,那么优先级高的线程会获得更多的时间片,但 cpu 闲时,优先级几乎没作用。可以说它和yield一样 都是不确定是否一定会改变当前线程。

例子

package cn.itcast.test;

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.Test9")
public class Test9 {

    public static void main(String[] args) {
        Runnable task1 = () -> {
            int count = 0;
            for (;;) {
                System.out.println("---->1 " + count++);
            }
        };
        Runnable task2 = () -> {
            int count = 0;
            for (;;) {
                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();
    }
}

结果

---->1 61594
---->1 61595
---->1 61596
---->1 61597
---->1 61598
---->1 61599
---->1 61600
---->1 61601
---->1 61602
---->1 61603
---->1 61604

          ---->2 459942
          ---->2 459943
          ---->2 459944
          ---->2 459945
          ---->2 459946
          ---->2 459947
          ---->2 459948
          ---->2 459949
          ---->2 459950
          ---->2 459951
          ---->2 459952
          ---->2 459953
          ---->2 459954
          ---->2 459955
          ---->2 459956
          ---->2 459957
          ---->2 459958
          ---->2 459959
          ---->2 459960
          ---->2 459961
          ---->2 459962
          ---->2 459963
          ---->2 459964

可以看出虽然t2的优先级为MAX_PRIORITY(优先级为10) t1的优先级为MIN_PRIORITY(优先级为1),但是仍然会出现t1不断输出的情况,说明了 优先级只是作为参考 真正决定执行什么线程的是cpu。

目录
相关文章
|
14天前
|
Java 开发者
在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口
【10月更文挑战第20天】在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口。本文揭示了这两种方式的微妙差异和潜在陷阱,帮助你更好地理解和选择适合项目需求的线程创建方式。
13 3
|
14天前
|
Java 开发者
在Java多线程编程中,选择合适的线程创建方法至关重要
【10月更文挑战第20天】在Java多线程编程中,选择合适的线程创建方法至关重要。本文通过案例分析,探讨了继承Thread类和实现Runnable接口两种方法的优缺点及适用场景,帮助开发者做出明智的选择。
12 2
|
14天前
|
安全 Java
Java多线程通信新解:本文通过生产者-消费者模型案例,深入解析wait()、notify()、notifyAll()方法的实用技巧
【10月更文挑战第20天】Java多线程通信新解:本文通过生产者-消费者模型案例,深入解析wait()、notify()、notifyAll()方法的实用技巧,包括避免在循环外调用wait()、优先使用notifyAll()、确保线程安全及处理InterruptedException等,帮助读者更好地掌握这些方法的应用。
12 1
|
14天前
|
Java 开发者
Java多线程初学者指南:介绍通过继承Thread类与实现Runnable接口两种方式创建线程的方法及其优缺点
【10月更文挑战第20天】Java多线程初学者指南:介绍通过继承Thread类与实现Runnable接口两种方式创建线程的方法及其优缺点,重点解析为何实现Runnable接口更具灵活性、资源共享及易于管理的优势。
26 1
|
14天前
|
Java
在Java多线程编程中,`wait()`和`notify()`方法的相遇如同一场奇妙的邂逅
在Java多线程编程中,`wait()`和`notify()`方法的相遇如同一场奇妙的邂逅。它们用于线程间通信,使线程能够协作完成任务。通过这些方法,生产者和消费者线程可以高效地管理共享资源,确保程序的有序运行。正确使用这些方法需要遵循同步规则,避免虚假唤醒等问题。示例代码展示了如何在生产者-消费者模型中使用`wait()`和`notify()`。
22 1
|
14天前
|
安全 Java 开发者
Java多线程中的`wait()`、`notify()`和`notifyAll()`方法,探讨了它们在实现线程间通信和同步中的关键作用
本文深入解析了Java多线程中的`wait()`、`notify()`和`notifyAll()`方法,探讨了它们在实现线程间通信和同步中的关键作用。通过示例代码展示了如何正确使用这些方法,并分享了最佳实践,帮助开发者避免常见陷阱,提高多线程程序的稳定性和效率。
26 1
|
14天前
|
Java
在Java多线程编程中,`wait()` 和 `notify()/notifyAll()` 方法是线程间通信的核心机制。
在Java多线程编程中,`wait()` 和 `notify()/notifyAll()` 方法是线程间通信的核心机制。它们通过基于锁的方式,使线程在条件不满足时进入休眠状态,并在条件成立时被唤醒,从而有效解决数据一致性和同步问题。本文通过对比其他通信机制,展示了 `wait()` 和 `notify()` 的优势,并通过生产者-消费者模型的示例代码,详细说明了其使用方法和重要性。
21 1
|
18天前
|
监控 Java
在实际应用中选择线程异常捕获方法的考量
【10月更文挑战第15天】选择最适合的线程异常捕获方法需要综合考虑多种因素。没有一种方法是绝对最优的,需要根据具体情况进行权衡和选择。在实际应用中,还需要不断地实践和总结经验,以提高异常处理的效果和程序的稳定性。
17 3
|
18天前
|
监控 Java
捕获线程执行异常的多种方法
【10月更文挑战第15天】捕获线程执行异常的方法多种多样,每种方法都有其特点和适用场景。在实际开发中,需要根据具体情况选择合适的方法或结合多种方法来实现全面有效的线程异常捕获。这有助于提高程序的健壮性和稳定性,减少因线程异常带来的潜在风险。
13 1