Java线程

Posted 2022-04-02 z啵唧啵唧

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java线程相关的知识，希望对你有一定的参考价值。

文章目录

- - 二、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());

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MO38LYbi-1648645400139)(C:\\Users\\zhengbo\\AppData\\Roaming\\Typora\\typora-user-images\\image-20220330142731735<p>以上是关于Java线程的主要内容，如果未能解决你的问题，请参考以下文章</p> <p > <a style=$ Java对象"后事处理"那点事儿——垃圾回收

JUC并发编程 -- 线程的五种状态( 操作系统层面) 和六种状态(Java API层面)

Java并发006使用层面：Lock锁机制全解析

线程有哪些状态?

多线程--线程安全