JUC--常用方法

发表于 更新于 分类于

JUC–常用方法

背景

  • JUC–常用方法

  • 博主以黑马JUC进行学习

方法名 static 功能说明 注意
start() - 启动一个新线程，在新的线程运行 run 方法中的代码 start 方法只是让线程进入就绪，里面代码不一定立刻运行（CPU 的时间片还没分给它）。每个线程对象的 start 方法只能调用一次，如果调用了多次会出现 IllegalThreadStateException
run() - 新线程启动后会调用的方法 如果在构造 Thread 对象时传递了 Runnable 参数，则线程启动后会调用 Runnable 中的 run 方法，否则默认不执行任何操作。但可以创建 Thread 的子类对象，来覆盖默认行为
join() - 等待线程运行结束
join(long n) - 等待线程运行结束，最多等待 n 毫秒
getId() - 获取线程长整型的 id id 唯一
getName() - 获取线程名
setName(String) - 修改线程名
getPriority() - 获取线程优先级
setPriority(int) - 修改线程优先级 Java 中规定线程优先级是 1~10 的整数，较大的优先级能提高该线程被 CPU 调度的机率
getState() - 获取线程状态 Java 中线程状态是用 6 个 enum 表示，分别为：NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED
isInterrupted() - 判断是否被打断 不会清除打断标记
isAlive() - 线程是否存活（还没有运行完毕）
interrupt() - 打断线程 如果被打断线程正在 sleep、wait、join 会导致被打断的线程抛出 InterruptedException，并清除打断标记；如果打断的正在运行的线程，则会设置打断标记；park 的线程被打断，也会设置打断标记
interrupted() static 判断当前线程是否被打断 会清除打断标记
currentThread() static 获取当前正在执行的线程
sleep(long n) static 让当前执行的线程休眠 n 毫秒，休眠时让出 CPU 的时间片给其它线程
yield() static 提示线程调度器让出当前线程对 CPU 的使用 主要是为了测试和调试

  • start与run

    • 调用run
      • 程序仍在线程运行，FileReader.read()方法调用还是同步的
    • 调用start
      • 不能被多次使用，会报IllegalThreadStateException

  • sleep与yield

    • sleep

      • 调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态

      • 其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException

      • 睡眠结束后的线程未必会立刻得到执行

      • 建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性

        • 内部也是使用了Thread的sleep，只不过使用了时间单位换算

        • TimeUnit.SECONDS.sleep(1)

          1
          2
          3
          4
          5
          6
          7
          8
          9
          10
          11
          12
          13
          14
          15
          16
          17
          18
          19
          20
          21
          22
          23
          24

              * sleep在哪个线程中，就对哪个线程进行睡眠

            * yield

              * 调用 `yield` 会让当前线程从 `Running` 进入 `Runnable` 状态，然后调度执行其它同优先级的线程。如果这时没有同优先级的线程，那么不能保证让当前线程暂停的效果
              * 具体的实现依赖于操作系统的任务调度器

            * 线程优先级
              * 线程优先级会提示（hint）调度器优先调度该线程，但它仅仅是一个提示，调度器可以忽略它
              * 如果 CPU 比较忙，那么优先级高的线程会获得更多的时间片，但 CPU 闲时，优先级几乎没作用

          * sleep实现

            * 在没有利用cpu来计算时，不要让while(true)空转浪费cpu，这时可以使用yield或sleep来让出cpu的使用权给其它程序

            ```java
            while(true){
               try{
                  Thread.sleep(50);
               }catch(InterruptedException e){
                  e.printStackTrace();
               }
            }

    • 可以用wait或条件变量达到类似的效果

    • 不同的是，后两种都需要加锁，并且需要相应的唤醒操作，一般适用于要进行同步的场景

    • sleep适用于无需锁同步的场景

  • join

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    static int r = 0;
    public static void main(String[] args) throws InterruptedException{
        test1();
    }
    private static void test1() throws InterruptedException{
        log.debug("开始");
        Thread t1 = new Thread(() -> {
             log.debug("开始");
             sleep(1);
             log.debug("结束");
             r = 10;
        });
        t1.start();
        //t1.join();
        log.debug("结果为:{}", r);
        log.debug("结束");
    }
    • 分析
      • 因为主线程和线程t1是并发执行的，t1线程需要1秒后才能算出r=10
      • 而主线程一开始就要打印r的结果，所以只能打印出r=0
    • 解决方法
      • 用sleep行不行？为什么
        • 可以，但等待时间不好把握
      • 用join，加在t1.start()之后即可

  • join的同步应用

    • 以调用角度来讲，如果
      • 需要等待结果返回，才能继续运行就是同步
      • 不需要等待结果返回，就能继续运行就是异步

  • join(long n)的限时同步

    • 按照n的时间等待，等待时间大于n，跳过等待；等待时间小于n，不执行等待

  • interrupt打断阻塞

    • 打断sleep的线程，会清空打断状态，以sleep为例
    • 会出现InterruptedException异常
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    private static void test1() throws InterruptedException{
        Thread t1 = new Thread(() -> {
            sleep(1);  //调用wait，join时，打断标记会清空
        }, "t1");
        t1.start();
        
        sleep(0.5);
        t1.interrupt();
        log.debug("打断状态:{}",t1.isInterrupted()); //false
    }

  • interrupt打断正常

    • 打断正常运行的线程，不会清空打断状态
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    private static void test2() throws InterruptedException{
        Thread t1 = new Thread(() -> {
         while(true){
             Thread current = Thread.currentThread();
             boolean interrupted = current.isInterrupted();
             if(interrupted){
                 log.debug("打断状态:{}",interrupted);
                 break;
             }
         }
        }, "t2");
        t1.start();
        
        sleep(0.5);
        t1.interrupt();
        log.debug("打断状态:{}",t1.isInterrupted()); //true
    }

  • interrupt打断park线程

    • 打断park线程，不会清空打断状态
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    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(1);
        t1.interrupt();
       
    }

  • 主线程与守护线程

    • 默认情况下，Java进程需要等待所有线程都运行结束，才会结束。有一种特殊的线程叫做守护线程，只要其它非守护线程运行结束了，即使守护线程的代码没有执行完，也会强制结束。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    log.debug("开始运行。。。");
    Thread t1 = new Thread(() -> {
       log.debug("开始运行。。。");
        sleep(2);
        log.debug("运行结束。。。");
    }, "daemon");
    //设置线程为守护线程
    t1.setDaemon(true);
    t1.start();
    sleep(1);
    log.debug("运行结束");
    • 垃圾回收器线程就是一种守护线程
    • Tomcat中的Acceptor和Poller线程都是守护线程，所以Tomcat接收到shutdown命令后，不会等待它们处理完当前请求

  • 线程的状态—五种状态

    • 从操作系统层面描述
    • 初始状态：仅是在语言层面创建了线程对象，还未与操作系统线程关联
    • 可运行状态（就绪状态）：指该线程已经被创建（与操作系统线程关联），可以由CPU调度执行
    • 运行状态：指获取了CPU时间片运行中的状态
      • 当CPU时间片用完，会从运行状态转换至可运行状态，会导致线程的上下文切换
    • 终止状态：表示线程已经执行完毕，生命周期已经结束，不会再转换为其它状态
    • 阻塞状态：
      • 如果调用了阻塞API,如BIO读写文件，这时该线程实际不会用到CPU，会导致线程上下文切换，进入阻塞状态
      • 等BIO操作完毕，会由操作系统唤醒阻塞的线程，转换至可运行状态
      • 与可运行状态的区别是，对阻塞状态的线程来说只要它们一直不唤醒，调度器就一直不会考虑调度它们

  • 线程的状态—六种状态

    • 这是从Java API层面来描述的
    • 根据Thread.State枚举，分为六种状态
    • NEW 线程刚被创建，但是还没有调用start（）方法
    • RUNNABLE 当调用了start（）方法之后，注意。Java API层面的RUNNABLE 状态涵盖了操作系统层面的【可运行状态】、【运行状态】和【阻塞状态】（由于BIO 导致的线程阻塞，在Java里无法区分，仍然认为是可行的）
    • BLOCKED, WAITING, TIMED_WAITING都是Java API 层面对【阻塞状态】的细分
    • TERMINGATED 当线程代码运行结束，类似于终止状态