首页 > 编程语言 >Java多线程-Lesson02

Java多线程-Lesson02

时间：2023-06-25 17:44:55浏览次数：38  
标签：Java Thread System 线程 Lesson02 println 多线程 public out

一.Lamda表达式

λ是希腊字母表的第十一位字母，英文名是Lambda

Lamda表达式的出现主要是为了避免匿名内部类过多的原因，它属于函数式编程的范畴 

为什么要使用Lamda表达式？

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

主要使用在创建的类只使用了一次时，创建匿名方法太多会很麻烦，Lamda表达式以其简洁的定义方式使得在类的一次使用中十分高效，在JDK1.8开始广泛使用

Lamda表达式和函数式接口编程是相辅相成的，只有使用函数式编程才使得Lamda表达式变得有意义

函数式接口的意义：

  • 任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口（Runnable接口）
  • public interface Runnable {
    public abstract void run();
} 
  • 对于函数式接口，我们可以通过Lamda表达式来创建接口对象

一次使用类的定义演化过程

1.接口-实现类

interface iLambda{
    //接口中默认就是抽象方法，即abstract修饰
  void PrintLambda();
}
class sonILambda implements iLambda {
    @Override
    public void PrintLambda() {
        System.out.println("接口--实现类使用");
    }
}

 

接口-实现类是我们使用最多的定义方式，它的生命周期是全局的，也就是不加特别的约束的话，不管在那个包内都可以通过new关键字实例化一个对象

但是对于只使用一次的类，就不需要这么麻烦，所以就衍生出了下一种定义方式

2.接口-静态内部类

//主方法所在类，启动类：Application
public class StudyLambda {
    //静态内部实现类
    static class sonILambdaStatic implements iLambda {
        @Override
        public void PrintLambda() {
            System.out.println("接口--静态实现类");
        }
    }
    public static void main(String[] args) {
        sonILambdaStatic sonILambda = new sonILambdaStatic();
        sonILambda.PrintLambda();
    }
}

 

静态内部实现类，首先它的类是静态的，并且它的位置位于我们的主方法的内部

这样的静态实现类依旧需要static关键字修饰，它和外部实现类差别并不是很大

主要是作用域，一个在全局，一个在类的内部

3.接口-局部内部类

    public static void main(String[] args) {
        //局部内部类
        class sonILambdaMian implements iLambda {
            @Override
            public void PrintLambda() {
                System.out.println("接口--局部内部类");
            }
        }
        sonILambdaMian Lambda = new sonILambdaMian();
        Lambda.PrintLambda();
    }

 

局部内部类作用域就更小了，它的作用域甚至只在主方法内部，

由于我们的类只使用一次，这样的定义也是没问题的

4.接口-匿名内部类

    public static void main(String[] args) {
        //局部内部类
        class sonILambdaMian implements iLambda {
            @Override
            public void PrintLambda() {
                System.out.println("接口--局部内部类");
            }
        }
        //匿名内部类
        iLambda iLambda = new iLambda() {
            @Override
            public void PrintLambda() {
                System.out.println("接口--匿名内部类");
            }
        };
        iLambda.PrintLambda();
    }

 

匿名内部类，没有类名称，必须借助接口或者父类

在使用到匿名内部类的时候，就和Lamda表达式很像了，匿名内部类把类体和创建写在了一起

对于这样的类，就可以使用Lamda表达式进行简化

5.Lamda表达式

 //Lambda表达式
        iLambda = ()->{
            System.out.println("Lamda表达式");
        };
        iLambda.PrintLambda();

 

我们可以看到，有了Lamda表达式的，对于只使用一次的类的表达非常方便

Lamda表达式使用的规则：接口中只含有一个抽象方法

完整的五种实现类方法具体的位置

class sonILambda implements iLambda {
    @Override
    public void PrintLambda() {
        System.out.println("接口--实现类使用");
    }
}
interface iLambda{
    //接口中默认就是抽象方法，即abstract修饰
    void PrintLambda();
}
//主方法所在类，启动类：Application
public class StudyLambda {
    //静态内部实现类
    static class sonILambdaStatic implements iLambda {
        @Override
        public void PrintLambda() {
            System.out.println("接口--静态实现类");
        }
    }
    public static void main(String[] args) {
        //局部内部类
        class sonILambdaMian implements iLambda {
            @Override
            public void PrintLambda() {
                System.out.println("接口--局部内部类");
            }
        }
        //匿名内部类
        iLambda iLambda = new iLambda() {
            @Override
            public void PrintLambda() {
                System.out.println("接口--匿名内部类");
            }
        };
        //Lambda表达式
        iLambda = ()->{
            System.out.println("Lamda表达式");
        };
        iLambda.PrintLambda();
    }
}

 

Lambda表达式的优化

1.只有一句程序语句的程序体可以去掉大括号 { ...... }

iLambda = ()-> System.out.println("Lamda表达式");

 

2.对于有参数的方法可以不用参数类型

interface iLambda{
    //接口中默认就是抽象方法，即abstract修饰
    void PrintLambda(int a,String b);
}
iLambda = (a,b)-> System.out.println("Lamda表达式"+a+b);

 

3.对于只有一个参数可以小括号都不用带

interface iLambda{
    //接口中默认就是抽象方法，即abstract修饰
    void PrintLambda(int a);
}
iLambda = a-> System.out.println("Lamda表达式"+a);

 

上面的描述都是Lamda表达式的优化，对于常用的情况下，我们更推荐参数打上括号，语句体打上大括号

它即对多个参数的情况可以使用，但是又有简化，多条程序依旧也可以使用

iLambda = (a,b)-> {
            System.out.println("Lamda表达式");
            System.out.println(a);
            System.out.println(b);
        };

 

如上写法，

就是比较标准的Lamda表达式的写法

二.线程的状态

 线程一共有五个状态，其中线程的创建状态，已经在Lession1课程中说明完了

包括继承Thread类，实现Runnable接口等等

接下来我们会主要研究其它的四个状态

线程的停止：

线程的停止终究是不安全的，所以一般我们只推荐线程自然停止

线程的使用建议都是有穷的，而不是死循环

建议使用标志位停止线程，不建议使用jdk自带的一些停止线程的方法

public class TestStop implements Runnable{
    private Boolean flag=true;

    public void setFlag(Boolean flag) {
        this.flag = flag;
    }

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

    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();
        for (int i = 0; i < 200; i++) {
            if (i==150){
                testStop.setFlag(false);
            }
            System.out.println("main"+i);
        }
    }
}

 

如上代码：

当我们的主函数执行到第150次的时候，就会设置flag为false

而我们的false就是用来停止其它线程的标志

这就是使用标志来逼停线程，但是最推荐的还是自然停止

线程休眠sleep（）：

  • sleep（时间）指定当前线程的毫秒数；
  • sleep存在异常捕获机制InterruptedException
  • sleep时间到达后线程进入就绪状态
  • sleep可以模拟网络延时，倒计时等
  • 每个对象都有一把锁，sleep不会释放锁
//模拟倒计时
public class TestSleep implements Runnable{
    @Override
    public void run() {
        int i=20;
       while (i>=10){
            try {
                Thread.sleep(1000);
                System.out.println(i);
                i--;
            } catch (InterruptedException e) {
                System.out.println("sleep");
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        TestSleep testSleep = new TestSleep();
        new Thread(testSleep).start();
        Thread.sleep(12000);
        for (int i = 9; i >0; i--) {
            System.out.println(i);
            Thread.sleep(1000);
        }
    }
}

 

线程休眠简单来说就是让正在执行的线程程序停一会

它的停止时间单位是ms

1s = 1000ms

线程礼让yield（）：

  • 礼让线程，让当前正在执行的线程停止，但不阻塞
  • 将线程从运行状态转为就绪状态
  • 让cpu重新调度，礼让不一定成功，可能cpu在礼让后又让它进来了

 线程礼让的实现：

public class TestYield {
    public static void main(String[] args) {
        iYield iYield = new iYield();
        new Thread(iYield,"线程A").start();
        new Thread(iYield,"线程B").start();
    }
}

class iYield implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"开始执行");
        Thread.yield(); //线程礼让
        System.out.println(Thread.currentThread().getName()+"结束执行");
    }
}

可能的两种情况：

正常礼让：

线程A开始执行
线程B开始执行
线程A结束执行
线程B结束执行

礼让失败：

线程A开始执行
线程A结束执行
线程B开始执行
线程B结束执行

 线程的强制执行join（）：

线程的强制执行指的是，它在cpu中独占资源，一旦调用此方法，那么cpu就会优先处理这个线程，只有这个线程执行完成以后，其它线程才能执行

我们可以把它想象成平时排队时，那些插队的人，像是有特权一样，明明后来，结果它先被服务，才到我们

一旦调用强制执行线程，那么其它线程都会被阻塞

代码实现：

public class TestJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("join线程"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();
        for (int i = 0; i < 500; i++) {
            if(i==200){
               //强制执行线性
               thread.join();
            }
            System.out.println("main"+i);
        }
    }
}

 线程的状态观测：

线程状态，可以处于一下状态之一

NEW

  • 尚未启动的线程处于此状态，其中也可以说是线程的新生状态

RUNNABLE

  • 在Java虚拟机中执行的时候处于此状态，也可以叫运行时状态

BLOCKED

  • 被阻塞等待监视器锁定的线程处于此状态，也可以叫阻塞状态

WAITTING

  • 正在等待另一个线程执行特定动作的线程处于此状态，也可以叫阻塞状态

TIMED_WAITING

  • 正在等待另一个线程执行动作达到指定等待时间的线程处于此状态，也可以叫阻塞状态

TERMINATED

  • 已退出的线程处于此状态，也可以叫死亡状态

一个线程可以在给定的一个时间段处于一个状态，但是它代表不了操作系统和JVM虚拟机的状态

Thread.State  类包含了线程的所有状态

代码简单描述：

 public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    System.out.println("sleep");
                }
            }
            System.out.println("Run over");
        });
        // 观察状态
        Thread.State state = thread.getState();
        //线程未启动但被创建的状态
        System.out.println(state);

        //启动后的状态
        thread.start();//启动线程
        state = thread.getState();
        System.out.println(state); //RunTime

        while (state != Thread.State.TERMINATED){//只要线程不死亡，就一直输出状态
            Thread.sleep(200);
            state=thread.getState(); //更新线程状态，必须做的事情
            System.out.println(state);
        }

    }

 

注意：一旦线程死亡就不能再次通过start（）方法启动了，而是要重新开辟线程，new Thread（）

线程优先级Priority：

Java提供了一个线程调度器来监控程序中启动后进入就绪状态的所有线程

线程调度器按照线程的优先级决定应该先调度那个线程来执行

优先级调度的范围用数字表示 ：1~10

  • Thread.MIN_PRIORITY  =  1
  • Thread.MAX_PRIORITY  =  10
  • Thread.NORM_PRIORITY  =  5

改变线程优先级的方法：

  • setPriority（int xxx）  设置线程的优先级
  • getPriority（）            查看线程的优先级

线程的优先级设置一定要此线程启动前调用

public class TestPriority implements Runnable{
    @Override
    public void run() {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            System.out.println("sleep");
        }
        System.out.println(Thread.currentThread().getName()+"---->"+Thread.currentThread().getPriority());
    }

    public static void main(String[] args) {
        TestPriority testPriority = new TestPriority();
        //拿到主线程的优先级
        System.out.println(Thread.currentThread().getName()+"---->"+Thread.currentThread().getPriority());
        //开辟新线程 t1
        Thread t1 = new Thread(testPriority,"t1");
        //先设置其优先级
        t1.setPriority(1);
        //然后再启动线程
        t1.start();
        Thread t2 = new Thread(testPriority,"t2");
        t2.setPriority(10);
        t2.start();
        Thread t3 = new Thread(testPriority,"t3");
        t3.setPriority(8);
        t3.start();
    }
}

 

注意点：

线程的优先级低，只能代表被cpu调度的概率低，并不是写定了谁的优先级最小就一定最后执行

我们只能根据更改优先级去干扰cpu的调度，并不能直接控制cpu的调度，详情参考《计算机操作系统》处理机章节

守护线程daemon：

  • 线程分为用户线程和守护线程
  • 虚拟机必须保证用户线程执行完毕 （main线程，主线程一定是执行完，程序结束）
  • 虚拟机不必等到守护线程执行完毕 （GC就是典型的守护线程，不仅不可见，可能很多人都会忽略他的存在，垃圾收集器）
  • 守护线程主要工作于：日志记录，监控内存，垃圾回收，等待操作

代码描述：

public class TestDaemon {
    public static void main(String[] args) {
        me i = new me();
        hiddenLove hidden = new hiddenLove();
        Thread isI = new Thread(i);
        isI.setDaemon(true);
        isI.start();
        new Thread(hidden).start();
    }
}

class me implements Runnable{
    @Override
    public void run() {
        int i=0;
        while (true) {
            i++;
            System.out.println("喜且不语，急却等待:第"+i+"次");
        }
    }
}
class hiddenLove implements Runnable{
    @Override
    public void run() {
        int i;
        for (i = 1; i < 5 * 365; i++) {
            System.out.println("释放希望，沐浴阳光，带来治愈");
        }
        System.out.println("会再见嘛？我的意思是"+i+"天后");
    }
}

 

守护线程和用户线程最大的区别在于对虚拟机的要求不同

如果虚拟机还在运行，守护线程也在运行

如果用户线程不运行了，虚拟机也会停止

 

标签：Java,Thread,System,线程,Lesson02,println,多线程,public,out
From： https://www.cnblogs.com/5ran2yl/p/17494269.html

相关文章

  • 【拼多多商品详情数据】API接口获得宝贝详情数据、商品标题数据等Java调用示例
    ​拼多多商品详情API接口的作用是获取拼多多平台上某个商品的详细信息，包括商品标题、价格、图片、规格、参数、店铺信息等。开发者可以通过该接口获取到商品的原始数据，方便进行数据分析、价格比较、爬取等操作。通过该接口获取到的商品详情数据可以结合其他数据进行深度挖掘，例如......
  • java 中的多线程问题
    结论  全局变量 多线程非安全  （堆） static局部变量 多线程安全  （栈） fina也可以安全1：线程调用时，每一个线程都拥有一套完整的调用栈帧，栈帧中包含完整的调用方法名，方法的局部变量。而且栈是先入后出，调用方法时入栈，方法结束是出栈。2：使用线程池时需要注意参数问......
  • java tricky
    1、根据枚举的name获取枚举类：privatestaticSmsProviderTypefromName(StringspName){returnStream.of(SmsProviderType.values()).filter(sp->StringUtils.equals(sp.name(),spName)).findFirst().orElse(null);}2、字符串转成int（注意给默认值）：NumberUtils.toInt3......
  • JAVA标签
    breakcontinue标签：```java标签（label）是在编程语言中用于标识代码的位置的符号。它通常与跳转语句（如break和continue）结合使用，用于控制程序的流程。在Java中，标签以标识符的形式出现，后面跟着一个冒号（:）。标签可以与循环语句（如for、while、do-while）和条件语句（如if、switch）一起......
  • java 中在图像上绘制文字
    privatevoidprintText(BufferedImageimage,floatx,floaty,Stringtext){Graphics2Dg=image.createGraphics();g.setColor(Color.RED);g.setFont(newFont("Arial",Font.BOLD,30));FontMetricsfm=g.getFontMet......
  • 关于Java中ArrayList类的toArray方法详解
    先上源码：publicObject[]toArray(){returnArrays.copyOf(elementData,size);}可以看到ArrayList类的toArray()方法调用了Arrays.copyOf(elementData,size)（其中的elementData是ArrayList类中用来存储对象的数组，size是数组大小），接下来进入其内部：publicsta......
  • 【淘宝商品详情数据】api接口获得宝贝详情数据、优惠价格数据Java调用示例
    淘宝详情API接口的作用是获取淘宝平台上某个商品的详细信息，包括商品标题、价格、图片、规格、参数、店铺信息等。开发者可以通过该接口获取到商品的原始数据，方便进行数据分析、价格比较、爬取等操作。通过该接口获取到的商品详情数据可以结合其他数据进行深度挖掘，例如可以将商品数......
  • 【Java】修改生成的PDF的表格中文字的字体
    首先导入依赖<dependency><groupId>com.itextpdf</groupId><artifactId>itextpdf</artifactId><version>5.5.10</version></dependency>使用form.setFieldProperty("${表格名字}",&......
  • 使用java中的Calendar遇到的时区问题
    项目中有一个增加1小时的工具函数结果今天测试出现了一个问题原因是1986年的9月13号到14号之间会有一个时区的转换需要程序特殊处理下这是原函数的结果SatSep1322:00:00CDT1986SatSep1323:00:00CDT1986SatSep1323:00:00CST1986SunSep1400:0......
  • Java学习之Mysql基础问题整理
    Mysql常见存储引擎命令：SHOWENGINES; Mysql版本5.5以后默认引擎是InnoDB，5.5版本以前的是MyISAMInnoDB和MyISAM的区别1、InnoDB支持事务，MyISAM不支持。对于InnoDB每一条SQL语言都默认封装成事务，自动提交，这样会影响速度，所以最好把多条SQL语言放在begin和commit之间，组成一个......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99