Java线程

二、Java线程

1.创建线程的方式

1.1 方式1

• 继承Thread类然后重写run方法，调用start方法来进行线程的启动

package com.zb.juc.test;

import lombok.extern.slf4j.Slf4j;

/**
 * @Description: 创建线程的方式1
 * @Author:啵唧啵唧~~
 * @Date:2022/3/29
 */
@Slf4j(topic = "c.Test1")
public class test1 {
    public static void main(String[] args) {
        Thread t = new Thread(){
            @Override
            public void run() {
                log.debug("running");
            }
        };
        t.setName("t1");
        t.start();
        log.debug("running");
    }
}

1.2方式2(推荐的一种方式)

• 将线程和线程要执行的代码分开’
• Thread代表线程
• Runnable代表可以执行的任务
• 提高代码的灵活性

package com.zb.juc.test;

import lombok.extern.slf4j.Slf4j;

/**
 * @Description:
 * @Author:啵唧啵唧~~
 * @Date:2022/3/29
 */
@Slf4j(topic = "c.Test2")
public class test2 {
    public static void main(String[] args) {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                log.debug("running");
            }
        };
        Thread t = new Thread(r,"t2");
        log.debug("running");
        t.start();
    }

}

学习使用 Lambad表达式

• 需要注意的是能够使用Lambda表达式只能使用在加了@FunctionalInterface注解的接口，这种接口表示只有一个抽象方法。
• 如果一个接口拥有多个抽象方法就不能够使用Lambda表达式了。

package com.zb.juc.test;

import lombok.extern.slf4j.Slf4j;

/**
 * @Description: 创建线程的方式2
 * @Author:啵唧啵唧~~
 * @Date:2022/3/29
 */
@Slf4j(topic = "c.Test2")
public class test2 {
    public static void main(String[] args) {
        
        //匿名内部类方式实现接口抽象方法
//        Runnable r = new Runnable() {
//            @Override
//            public void run() {
//                log.debug("running");
//            }
//        };
        
        //采用Lambda表达式快速实现匿名内部类接口抽象方法
        Runnable r = () -> log.debug("running");
        Thread t = new Thread(r,"t2");
        log.debug("running");
        t.start();
    }

}

Thread和Runnable之间的关系和原理

源码分析

• 构造方法Thread()将runnable对象作为target传给了init对象

• init()方法又将target传给了一个重载的init方法

• 在这个重载的init方法中实际上是将runnable对象赋值给这个Thread类的一个成员变量

• 在Thread的run方法中用到了runnable对象。在Thread类中的run方法实际上还是判断runnable是否为空，不为空 调用Runnable的run方法，也就是说使用Runnable方式创建接口还是先走Thread的run方法，判断Runnable是为否为空，不为空则调用Runnable类的run方法
• 如果直接使用Thread来创建线程，是重写父类的run方法，直接运行子类重写的run方法中的任务代码即可- 本质上不管是方法1还是方法2都是走的子类的run方法

总结

• 使用Runnable更容易与线程池等高级api配合
• 使用Runnable类让任务脱离了Thread的继承体系，更加灵活(在Java中组合由于继承)

1.3方式3

• 使用FutureTask类来接收Callable类型的参数，可以接收返回值

package com.zb.juc.test;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * @Description: 线程创建方式3
 * @Author:啵唧啵唧~~
 * @Date:2022/3/29
 */
@Slf4j(topic = "c.Test3")
public class test3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<Integer> task = new FutureTask<>(new Callable<Integer>() {
            @Override
            //实现call方法
            public Integer call() throws Exception {
                log.debug("running");
                //睡眠两秒后返回结果
                Thread.sleep(2000);
                //可以接收返回值
                return 200;
            }
        });

        //将task对象放在Thread类中
        Thread t = new Thread(task,"t3");
        //启动线程
        t.start();
        //{}表示占位符，表示这个位置里面要放的是task对象的返回值
        log.debug("{}",task.get());
    }
}

对比Runnable和Callable接口

@FunctionalInterface
public interface Runnable {
    //Runnable接口没有返回值，所以不能返回结果，只能执行run方法中的任务，不能抛出异常
    public abstract void run();  
}
//-------------------------------分割线----------------------------------

@FunctionalInterface
public interface Callable<V> {
    //有一个泛型的参数类型可以用来接收指定的返回值，并且可以抛出异常
    V call() throws Exception;
}

2.观察多个线程同时运行

package com.zb.juc.test;

import lombok.extern.slf4j.Slf4j;

/**
 * @Description: 观察多个线程同时运行
 * @Author:啵唧啵唧~~
 * @Date:2022/3/29
 */
@Slf4j(topic = "c.TestMultiThread")
public class TestMultiThread {
    public static void main(String[] args) {
        //创建线程1
        new Thread(()->{
            while(true){
                log.debug("running");
            }
        },"TestMultiThread1").start();
        
        //创建线程2
        new Thread(()->{
            while(true){
                log.debug("running");
            }
        },"TestMultiThread2").start();
    }
}

• 执行结果，发现两线程之间交替运行

02:27:56.357 c.TestMultiThread [TestMultiThread1] - running
02:27:56.357 c.TestMultiThread [TestMultiThread1] - running
02:27:56.357 c.TestMultiThread [TestMultiThread2] - running
02:27:56.357 c.TestMultiThread [TestMultiThread2] - running
02:27:56.357 c.TestMultiThread [TestMultiThread1] - running
02:27:56.357 c.TestMultiThread [TestMultiThread2] - running
02:27:56.357 c.TestMultiThread [TestMultiThread2] - running
02:27:56.357 c.TestMultiThread [TestMultiThread2] - running
02:27:56.357 c.TestMultiThread [TestMultiThread2] - running
02:27:56.357 c.TestMultiThread [TestMultiThread2] - running
02:27:56.357 c.TestMultiThread [TestMultiThread2] - running
02:27:56.357 c.TestMultiThread [TestMultiThread1] - running
02:27:56.357 c.TestMultiThread [TestMultiThread1] - running
02:27:56.357 c.TestMultiThread [TestMultiThread2] - running
    ...

3、查看进程、线程的方法

3.1windows下查看

tasklist ## 查看进程
tasklist | findstr java ##查看指定的进程信息
jps ## 查看所有的java进程
taskkill /F /PID ##强制杀死指定pid的进程  

3.2linux下查看

ps -ef | grep  ## 查看指定类型的进程
jps ## 查看java进程
top ##动态的查看进程使用情况
top -H -p xxx ## -H表示查看线程 -p表示查看的是哪个进程的的线程，这个p后面就是进程的id
jstack xxxx ## 跟进程的id  抓取的信息更加详细

3.3 jconsole(Java监视和管理控制平台)

• 在控制端打开jconsole平台，然后以下面这种方式来运行java类

## 使用jconsole工具启动java类的模板
java -Djava.rmi.server.hostname=`ip地址` -Dcom.sun.management.jmxremote Dcom.sun.management.jmxremote.port=`连接端口` -Dcom.sun.management.jmxremote.ssl=是否安全连接 Dcom.sun.management.jmxremote.authenticate=是否认证 java类

4、线程的运行原理

4.1栈和栈帧

• jvm由堆、方法区、程序计数器、虚拟机栈、本地方法栈组成，其中栈内存就是给线程用的，每个线程在启动之后虚拟机栈就会给他分配一块栈内存。
• 一个栈由多个栈帧组成、对应着每次方法调用时占用的空间内存
• 每个线程只能有一个活动栈帧，对应着正在执行的那个方法。
• 方法的执行遵循栈结构的后进先出原则。

debug查看一个线程的执行情况

package com.zb.juc.test;

/**
 * @Description:
 * @Author:啵唧啵唧~~
 * @Date:2022/3/29
 */
public class TestFrames {
    public static void main(String[] args) {
        m1(10);
    }

    private  static void m1(int x){
        int y = x+1;
        Object m = m2();
        System.out.println(m);
    }

    private static Object m2() {
        Object n = new Object();
        return n;
    }
}

• 新进来的方法给他分配的栈帧总是放在最上面，等方法执行完毕之后就会释放栈帧空间。

4.2线程的上下文切换

• 因为一些原因导致cpu不再执行当前的线程，转而执行另外一个线程的代码。
• 线程的cpu时间片用完
• 垃圾回收
• 有比自己更高优先级的线程需要运行
• 线程自己调用了sleep、yield、wait、join、park、synchronized、lock方法
  • 前三种属于是被动切换线程、最后一种属于是自己主动进行线程切换
• 当线程上下文切换的时候，需要操作系统保留当前线程的状态，并恢复另外一个线程的状态，Java中对应的概念就是程序计数器，它的作用就是来记录下一条jvm执行的指令地址，是线程私有的。
• 状态包括程序计数器、虚拟机栈中每个栈帧的信息，如局部变量、操作数栈，返回地址等。
• 如果频繁的进行线程上下文的切换必然会影响性能。

5、线程的常用方法

5.1 start和run

• 想要启动一个线程必须调用start方法，当调用start方法的时候，会在main方法所在的主栈外边开启一个分支栈，这个栈空间开辟完成之后，start方法执行结束，当线程抢夺到cpu执行时间片之后就会调用run方法，然后执行线程的任务

• 注意的是当线程直接调用run方法来执行执行线程的时候，虽然也能够执行相应的代码，但是实际上还是在main方法这个栈中将方法执行完毕的，并没有使用多线程

  package com.zb.juc.test;
  
  import lombok.extern.slf4j.Slf4j;
  
  /**
   * @Description:
   * @Author:啵唧啵唧~~
   * @Date:2022/3/29
   */
  @Slf4j(topic = "c.Test5")
  public class test4 {
      public static void main(String[] args) {
  
          Thread t = new Thread(new Runnable() {
              @Override
              public void run() {
                  log.debug("running");
              }
          });
          //直接调用run方法
          //t.run();
          //调用start方法’
          t.start();
      }
  }
  

  • 直接调用run方法
    

  • 调用start方法
    

5.2 sleep和yield

sleep

• 调用sleep方法会让线程从Runnable状态变为TIMED_WATING状态
• sleep方法写在哪个线程就是让哪个线程进入睡眠状态
• 使用interrupt方法打断正在睡眠状态的线程、此时sleep方法会抛出InterruptedException异常

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

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                log.debug("running....");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    log.debug("wake up....");
                    e.printStackTrace();
                }
            }
        });

        t.start();
        Thread.sleep(1000);
        t.interrupt();
    }
}

• 睡眠结束后的线程未必会立即执行、也就是说睡眠结束后的线程未必会立即获得cpu的执行权力。
• 建议使用TimeUnit.sleep方法代替Thread的sleep方法可以获得更好的可读性。

yield

• 调用yield会让当前线程从Running进入Runnable就绪状态，然后调度执行其他线程
• yield的具体实现还是要依赖于操作系统的任务调度器，因为一个线程在执行了yield方法后，虽然会将cpu执行权力让别的线程，但是如果此时没有别的线程需要执行，那操作系统还是会让这个线程继续执行

yield和sleep改变线程状态的区别

• sleep是让线程从运行状态变为阻塞状态、yield方法是让线程从运行状态变为就绪状态
• 处于阻塞状态的线程cpu不会给其分配cpu时间片，因为还处在睡眠状态，任务调度器会等你醒过来之后才会给你分配cpu时间片而处在就绪状态的线程cpu会给其分配cpu时间片。
• sleep方法在调用的时候要指定线程休眠时间、yiled不需要指定参数，只是将cpu执行权力让给别人，调度器依然会给其分配cpu时间片。

线程的优先级

• 线程优先级仅仅是一个提示，提示调度器优先执行但是调度器可以忽略它

• 如果cpu比较忙，那么优先级高的线程会获得更多的cpu时间片，但是cpu闲的时候，优先级几乎没有什么作用

• t.setPriority();//设置线程的优先级
  

5.3sleep的应用

• 在没有利用cpu来计算的时候，不要让while(true)空转来浪费cpu，这时可以使用sleep或者yield让出cpu的使用权交给其他线程

while(true){
    try{
        Thread.sleep();//避免cpu空转
    }catch(InterruptedException e){
        e.printStackTrace();
    }
}

5.4join方法详解

• 不使用join方法

@Slf4j(topic = "c.TestJoin")
public class TestJoin {
    //初始化r=0;
    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("开始");
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            log.debug("结束");
            //在t1线程中想要改变r的值
            r = 10;
        });
        t1.start();
        //观察线程t1有没有将r的值修改成功
        log.debug("结果为:{}", r);
        log.debug("结束");
    }
}

• 因为主线程和t1线程并发执行，打印r的结果的语句在主线程当中，主线程先执行完，t1线程还没来得及修改r的值
• 使用join方法后

• join方法就是在一个线程中调用另外一个线程的join方法，比如在这个例子当中主线程中调用了t1线程的join方法，那么主线程就得让t1线程执行完毕之后才能继续执行后面的代码。

在join方法中再说同步和异步

• 从调用的角度来讲
  • 需要等待结果的返回，才能继续运行叫做同步
    • 本例中在主线程中调用了t1线程的join方法，主线程要等待t1线程执行完毕之后才能继续执行叫同步
  • 不需要等待结果的返回就能继续运行叫做异步

5.5 interrupt 方法详解

interrrupt打断阻塞线程

@Slf4j(topic = "c.TestInterrupt2")
public class TestInterrupt2 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            log.debug("sleep...");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t1");
       //启动线程
        t.start();
        //主线程睡眠目的是确保t线程进入睡眠状态，这样主线程打断的才是阻塞线程
        Thread.sleep(1000);
        log.debug("interrupt");
        t.interrupt();
        //查看打断标记
        log.debug("打断标记:{}",t.isInterrupted());
    }
}

interrrupt打断正常执行的线程

• 打断正常执行的线程需要通过打断标记位来判断是否需要被打断

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

    public static void main(String[] args) throws InterruptedException {
        //打断正常执行的线程需要通过打断标记来进行打断
        Thread t1 = new Thread(() -> {
            while (true) {
                //获取当前线程的打断标志位
              boolean interrupt = Thread.currentThread().isInterrupted();
              //若打断标志位true跳出循环
              if (interrupt){
                  break;
              }
            }
        }, "t1");
        t1.start();
        Thread.sleep(1000);
        log.debug("interrupt");
        //执行打断
        t1.interrupt();
    }
}

两阶段终止模式

• 

/**
 * @Description: 两阶段终止模式
 * @Author:啵唧啵唧~~
 * @Date:2022/3/30
 */
@Slf4j(topic = "c.TestInterrupt4")
public class TestInterrupt4 {

    public static void main(String[] args) throws InterruptedException {
        TwoPhaseTermination termination = new TwoPhaseTermination();
        log.debug("开启监视器");
        termination.start();
        //监视5s后关闭监视器
        Thread.sleep(5000);
        log.debug("关闭监视器");
        termination.stop();
    }

}
@Slf4j(topic = "c.TwoPhaseTermination")
class TwoPhaseTermination{
    /**
     * 设定一个监视器
     */
    private Thread monitor;

    /**
     * 启动监视线程
     */
    public void start(){
        monitor=new Thread(()->{
           while(true){
               //获得当前线程的打断标记位
               Thread current = Thread.currentThread();
               //如果打断标记为位true
               if (current.isInterrupted()){
                   log.debug("料理后事");
                   break;
               }
               //若线程没有被打断睡眠1s然后记录监视情况
               try {
                   /**
                    * 情况1:有可能在睡眠的过程中监视器被打断,在线程睡眠的时候被打断，线程的打断标志位会置为false，
                    * 那么在上面检测打断标志位的时候就无法正常的退出监视过程，我们知道在睡眠过程的时候将线程打断会
                    * 抛出InterruptedException异常我们可以在catch块当中"料理后事，然后退出监视",但是这样
                    * 会导致代码冗余，因为在前面已经做过一次料理后事的代码逻辑了，转而一想既然非要走catch语句块
                    * 那么可以在catch语句块当中将打断标记为置为true即可，即再次调用interrupt方法可以重新设置打断标记位
                    * 情况二:在正常的情况下被打断,这时候他的打断标记为会被置为true，在之前的代码逻辑中直接走完相应的流程即可
                    */
                   Thread.sleep(1000);//情况1
                   log.debug("记录监视情况");//情况
               } catch (InterruptedException e) {
                   e.printStackTrace();
                   //小技巧,重新设置打断标记位,被打断后再次打断就会为true
                   current.interrupt();
               }
           }
        });
        //开启线程
       monitor.start();
    }

    /**
     * 停止监视
     */
    public void stop(){
        monitor.interrupt();
    }
}

5.6守护线程

• 守护线程:默认java进程要等待java进程中所有线程都执行结束后才会结束java进程，但是守护线程只要等待其他的线程运行结束，即使守护线程的代码没有执行完毕也会强制结束。
• 开启守护线程的方式

//在线程启动的时候调用setDaemon(true);即可将调用这个方法的线程设置为守护线程
t.setDaemon(true);//设置t线程为守护线程
t.start();

• 注意：垃圾回收器线程就是一个守护线程

5.7 线程的状态

从操作系统层面来描述(分为5种)

• 初始状态:仅仅在语言层面创建了线程对象，还没有和操作系统进行关联，叫做初始状态
• 可运行状态(就绪状态):指的是该线程已经被创建且和操作系统进行了管理，可以由cpu进行调度执行
• 运行状态:指的是获得了cpu时间片的时候的状态
  • 当cpu的时间片执行完毕之后，会从运行状态回到就绪状态，会导致线程上下文的切换
• 阻塞状态
  • 当调用了阻塞api，如BIO在读取文件的时候，线程实际上不会使用cpu，会导致线程上下文切换，进入阻塞状态
  • 当BIO执行结束之后，会由操作系统唤醒线程转至就绪状态
  • 阻塞状态与可运行状态的区别是，阻塞状态的线程只要他们一直不唤醒，调度器就一直不会考虑调度他们
• 终止状态:表示线程已经执行完毕，生命周期已经结束，不会再转换为其他的状态。

从Java Api层面来看(六种状态)

• 在Java中层面线程的状态有六种，从Thread中State枚举可以看出
  • State枚举的源码，可以看出一共有NEW、RUNNABLE、BLOCKED、 WAITING、TIMED_WAITING、 TERMINATED六种状态。

/**
源码
**/
public enum State {
    NEW,
    RUNNABLE,
    BLOCKED,
    WAITING,
    TIMED_WAITING,
    TERMINATED;
}

• new 线程刚被创建，还没有调用start方法
• RUNNABLE当调用了start方法()之后，注意，Java API层面的RUNNABLE状态涵盖了操作系统层面的可运行状态、运行状态、阻塞状态(由于阻塞IO导致线程的阻塞，在Java当中无法区分，仍然认为是可运行状态)
• Java中的三种阻塞状态:BLOCKED、WAITING、TIMED_WAITING, 调度器也不会给他们分配时间片。
• WAITING：没有明确等待时长
• TIMED_WAITING：等待指定的时间