JavaSe学习笔记（十一.2）（lambda表达式，线程状态）

于 2021-04-06 19:28:16 发布
阅读量173 收藏
点赞数
分类专栏： JavaSe学习笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47267252/article/details/115444461
版权

JavaSe学习笔记（十一.2）

Lambda表达式

概述

  • λ 希腊字母表中排序第十一的字母，英文名为lambda
  • 其实质属于函数式编程的概念

优点

  • 避免匿名内部类定义过多
  • 让代码看起来简洁
  • 去掉了一堆没有意义的代码，只留下核心逻辑

函数式接口

任何一个接口，如果只包含一个抽象方法，那么它就是一个函数式接口

  • 对于函数式接口，可以通过lambda表达式来创建该接口的对象

lambda简化代码效果

java
package com.lambda;

public class TestLambda02 {

    //3.静态内部类
    static class like1 implements iLike{
        @Override
        public void like(int a) {
            System.out.println("我爱你呦！"+a);
        }
    }
    public static void main(String[] args) {
        iLike like = new Like();
        like.like(1);

        like = new like1();
        like.like(2);

        //4.局部内部类
        class like2 implements iLike{
            @Override
            public void like(int a) {
                System.out.println("I Love you\t"+a);
            }
        }

        like = new like2();
        like.like(3);

        //5.匿名内部类
        like = new iLike() {
            @Override
            public void like(int a) {
                System.out.println("我稀罕你\t"+a);
            }
        };
        like.like(4);;

        //6.用lambada简化：
        like = (a)-> {
            System.out.println("好喜欢好喜欢你呀\t"+a);
        };
        like.like(5);
    }

}

//定义一个函数式接口
interface iLike{
    void like(int a);
}

//2.实现类
class Like implements iLike{
    @Override
    public void like(int a) {
        System.out.println("我喜欢你\t"+a);
    }
}

结果：
在这里插入图片描述

线程状态

概述

五种状态：
在这里插入图片描述
jdk中的描述：
在这里插入图片描述

常用方法

在这里插入图片描述

线程停止——Stop

  • 不推荐使用JDK提供的stop(),destroy()方法（已废弃）
  • 推荐使用一个标志位flag，当其等于false时，终止线程运行。
private boolean flag = true;

    public void stop(){
        this.flag = false;
    }

代码：

package com.yu.demo01;

public class TestThread07 implements Runnable {

    //设置标识位
    private boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println("run--->"+ i++);
        }
    }

    //定义公共方法停止线程
    public void stop(){
       this.flag = false;
    }

    public static void main(String[] args) {


        TestThread07 testStop = new TestThread07();
        new Thread(testStop).start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("main-->"+i);
            if (i==900){
                testStop.stop();
                System.out.println("线程停止了");
            }

        }
    }
}

结果截图：
在这里插入图片描述

线程休眠——Sleep

  • sleep (时间)指定当前线程阻塞的毫秒数; .
  • sleep存在异常InterruptedException;
  • sleep时间达到后线程进入就绪状态;
  • sleep可以模拟网络延时，倒计时等。
  • 每一个对象都有一个锁，sleep不会释放锁;（重要）

实例：

（1）模拟网络延时
package com.yu.demo01;

public class TestThread08 implements Runnable{
    private int ticketNums = 10;
    @Override
    public void run() {
       //run方法线程体
        while (true){
            if (ticketNums <= 0){
                break;
            }
            //模拟延时：200毫秒
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //Thread.currentThread().getName()返回当前执行的线程名字
            System.out.println(Thread.currentThread().getName()+"-->拿走了第"+ticketNums--+"张票");
        }
    }
    public static void main(String[] args) {
        TestThread08 ticket = new TestThread08();

        new Thread(ticket,"浩渺").start();
        new Thread(ticket,"老王").start();
        new Thread(ticket,"小王").start();
    }
}
（2）模拟倒计时
package com.yu.demo01;

public class TestThread09{
    public static void main(String[] args) {
        tenDown();
    }

    
    //模拟倒计时
    public static void tenDown(){
        int num = 10;
        while (num > 0){
            /*将编译时异常转换为运行时异常,目的:解耦*/
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();//控制台输出错误信息，返回错误位置
                System.out.println(e.toString());//获取异常类和异常类信息
                throw new RuntimeException(e.getMessage());//返回的异常信息
            }
            System.out.println(num--);
        }
    }
}
（3）模拟时钟
package com.yu.demo01;

import java.text.SimpleDateFormat;
import java.util.Date;

public class TestThread09{
    public static void main(String[] args) {
        //打印当前系统时间
        Date startTime = new Date(System.currentTimeMillis());//获取系统当前时间

        while (true){
            try {
                Thread.sleep(1000);
                System.out.println("当前时间："+new SimpleDateFormat("HH:mm:ss").format(startTime));//打印时间
                startTime = new Date(System.currentTimeMillis());//更新当前时间

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

在这里插入图片描述

线程礼让——Yield

  • 礼让线程，让当前正在执行的线程暂停，但不阻塞
  • 将线程从运行状态转为就绪状态
  • 让cpu重新调度，礼让不-定成功!看CPU心情
package com.yu.demo01;

import java.text.SimpleDateFormat;
import java.util.Date;

public class TestThread010 {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        new Thread(myYield,"胖虎").start();
        new Thread(myYield,"迪迦").start();
    }
}
class MyYield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程结束");
    }
}

线程强制执行——Join

  • Join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞
  • 可以理解为“插队”
package com.yu.demo01;

public class TestJoin implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i <100 ; i++) {
            System.out.println("线程插队"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //创建线程
        Thread thread = new Thread(new TestJoin());

        for (int i = 0; i < 300; i++) {
            if (i==200){
                thread.start();
                thread.join();//插队
            }
            System.out.println("main"+i);
        }
    }
}

截图：
在这里插入图片描述

观测线程状态

package com.lambda;

public class TestState {

    public static void main(String[] args) {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e.getMessage());
                }
            }
            System.out.println("我来了");
        });

        //观察状态
        Thread.State state = thread.getState();
        System.out.println(state);//NEW

        //启动后观察
        thread.start();
        state = thread.getState();
        System.out.println(state);

        while (state != Thread.State.TERMINATED){//判断线程是否死亡
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e.getMessage());
            }
            state = thread.getState();//更新线程状态
            System.out.println(state);

        }
		thread.start();//死亡后的线程不能再次启动
    }
}

结果：
在这里插入图片描述

线程优先级（默认为5）

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。

线程的优先级用数字表示，范围从1~10
Thread.MIN_ PRIORITY = 1;
Thread.MAX_ PRIORITY= 10;
Thread.NORM_ PRIORITY= 5;
使用以下方式改变或获取优先级
getPriority() . setPriority(int xxx)

测试线程优先级

package com.lambda;

public class TestPriority {//测试线程优先级

    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+"---->"+Thread.currentThread().getPriority());//主线程默认优先级5
        Mypriority mypriority = new Mypriority();

        Thread t1 = new Thread(mypriority);
        Thread t2 = new Thread(mypriority);
        Thread t3 = new Thread(mypriority);
        Thread t4 = new Thread(mypriority);
        Thread t5 = new Thread(mypriority);

        //先设置优先级，再启动
        t1.setPriority(2);
        t1.start();

        t2.start();

        t3.setPriority(5);
        t3.start();

        t4.setPriority(Thread.MAX_PRIORITY);//最大优先级--》10
        t4.start();

        t5.setPriority(8);
        t5.start();
    }
}
class Mypriority implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"---->"+Thread.currentThread().getPriority());
    }
}

结果
在这里插入图片描述

优先级低只是意味着获得调度的 概率低.并不是优先级低就不会 被调用了.这都是看CPU的调度

性能倒置：先执行了优先级低的线程，优先级高的反而在等待，一般不会出现

守护（daemon）线程

  • 线程分为用户线程和守护线程
  • 虚拟机必须确保用户线程执行完毕
  • 虚拟机不必等待守护线程执行完毕
  • 如后台记录操作日志，监控内存，垃圾回收等待等等

测试守护线程

package com.lambda;

public class TestDaemon {//测试线程优先级

    public static void main(String[] args) {
        Red red = new Red();
        Life life = new Life();

        Thread thread = new Thread(red);
        thread.setDaemon(true);//默认为false，是用户线程
        thread.start();//守护线程启动

        new Thread(life).start();//用户线程启动
    }
}
class Red implements Runnable{
    @Override
    public void run() {
        while (true) {
            System.out.println("红色永不沉睡！");
        }
    }
}
class Life implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("星空任我驰骋"+i);
        }
        System.out.println("生命长眠");
    }
}

结果：

在这里插入图片描述

注：若Red为用户线程那它应该没有停止运行的时候。但虚拟机不管守护线程，当用户线程结束的时候，整个程序都会结束。后面多运行的守护线程是因为虚拟机的关闭需要时间。

月色夜雨
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

月色夜雨

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值