Java（多线程02）

已于 2022-07-15 19:41:45 修改
阅读量639 收藏
点赞数
分类专栏： Java（学习笔记） # Java（多线程+网络编程+注解和反射） 文章标签： java
于 2022-03-15 14:45:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zachsj/article/details/123394228
版权

Java（多线程02）

参考视频：多线程10：Lambda表达式（狂神）

9. Lambda表达式

  • λ 希腊字母表中排序第十一位的字母，英文名Lambda

  • 避免匿名内部类定义过多

  • 其实质属于函数式编程的概念
    在这里插入图片描述
    a-> System.out.println("i like lambda-->"+a);
    new Thread (()->System.out.println("多线程学习。。。")).start();

  • 为什么要使用Lambda表达式

    • 避免匿名内部类定义过多
    • 使代码看起来简洁
    • 去掉无意义代码，简化代码，只留下核心的逻辑

  • 习惯之后会觉得简洁
     

  • 理解Functional Interface（函数式接口）是学习Java8 Lambda表达式的关键所在。

  • 函数式接口的定义：

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

示例一：

package com.zach.lambda;

//推导Lambda表达式
public class TestLambda1 {

    //3.静态内部类
    static class Like2 implements ILike{//标准的实现接口的方式
        @Override
        public void lambda() {
            System.out.println("i like lambda2");
        }
    }

    public static void main(String[] args) {
        ILike like = new Like();//创建一个接口对象（很方便）,new一个实现类
        like.lambda();//接口调用实现类

        Like2 like2 = new Like2();
        like2.lambda();

        //4.局部内部类
        class Like3 implements ILike{//标准的实现接口的方式
            @Override
            public void lambda() {
                System.out.println("i like lambda3");
            }
        }
        Like3 like3 = new Like3();
        like3.lambda();

        //5.匿名内部类:没有类的名称，必须借助接口或者父类
        ILike like4 = new ILike(){//Anonymous new ILike() can be replaced with lambda
                            // 匿名 new ILike() 可以替换为 lambda
                            //like 只是一个对象； { @...} 是一个没有名字的类；类似于上面的Like3只是无名
            @Override
            public void lambda() {
                System.out.println("i like lambda4");
            }
        };
        like4.lambda();

        //6.用Lambda表达式简化（★关键★）
        ILike like5 = ()->{//   =左边表明使用的是ILike接口；
            System.out.println("i like lambda5");//单条语句可以去掉大括号
        };
        like5.lambda();

        //like6最终还是从ILike like6 = new ILike();变成了匿名内部类
        ILike like6 = new ILike(){
            //类“从 ILike 派生的匿名类”必须：1.声明为抽象或2.在“ILike”中实现抽象方法“lambda()”
            @Override
            public void lambda() {
                System.out.println("i like lambda");
            }
        };//'ILike' 是抽象的； 无法实例化
        //like6最终还是从ILike like6 = new ILike();变成了匿名内部类

    }
}

//1.定义一个函数式接口（有且仅有一个抽象方法的接口）
interface ILike {
    public abstract void lambda();//接口中：隐式声明，自动抽象(public abstract 一般去掉)
}

//2.实现类
class Like implements ILike{//标准的实现接口的方式
    @Override
    public void lambda() {
        System.out.println("i like lambda");
    }
}
  • JDK8以后才支持Lamdba表达式
  • 函数式接口：有且仅有一个方法的接口。只有Lambda表达式需要函数式接口

示例二：（带参数的Lambda表达式）

package com.zach.lambda;

public class TestLambda2 {
    //2.静态内部类
    static class Love2 implements ILove{

        @Override
        public void love(int a) {
            System.out.println("i love u-->"+a);
        }
    }

    public static void main(String[] args) {
        Love love = new Love();
        love.love(1);

        Love2 love2 = new Love2();
        love.love(2);

        //3.局部内部类
        class Love3 implements ILove{

            @Override
            public void love(int a) {
                System.out.println("i love u-->"+a);
            }
        }
        Love3 love3 = new Love3();
        love3.love(3);

        //4.匿名内部类(没有类名只能用ILove接口创建对象)
        ILove love4 = new ILove() {
            @Override
            public void love(int a) {
                System.out.println("i love u-->"+a);
            }
        };
        love4.love(4);

        //4.1.匿名内部类简化1（删除了创建对象的过程）
        new ILove(){
            @Override
            public void love(int a) {
                System.out.println("i love u-->"+a);
            }
        }.love(4_1);

        //5.Lambda表达式
        ILove love5 = (int a) -> {
            System.out.println("i love u-->"+a);
        };
        love5.love(5);

        //5.1.Lambda表达式简化1（可以去掉参数类型）
        ILove love5_1 = (a) -> {
            System.out.println("i love u-->"+a);
        };
        love5.love(5_1);

        //5.2.Lambda表达式简化2（可以去掉小括号）
        ILove love5_2 = a -> {
            System.out.println("i love u-->"+a);
        };
        love5.love(5_2);

        //5.3.Lambda表达式简化3（可以去掉大括号和对应分号）
        ILove love5_3 = a -> System.out.println("i love u-->"+a);
        love5.love(5_3);

    }
}

//0.接口（函数式接口：有且仅有一个方法的接口。只有Lambda表达式需要函数式接口）
interface ILove{
    void love(int a);
}

//1.普通的实现类
class Love implements ILove{

    @Override
    public void love(int a) {
        System.out.println("i love u-->"+a);
    }
}

小结：

  • 使用Lambda表达式的前提是接口必须是函数式接口（有且仅有一个方法的接口）。
  • 有且仅有一行代码时，Lambda表达式可以简化为一行。多行代码需要代码块{};包裹。
  • 有多个参数时也可以去掉参数类型，但必须重新加上小括号()，而且参数类型要全都去掉。

 

10. 静态代理模式

在这里插入图片描述
示例一：

package com.zach.proxy;

public class StaticProxy {

    public static void main(String[] args) {
//        You you = new You();//你要结婚
//        WeddingCompany weddingCompany = new WeddingCompany(you);
//        weddingCompany.HappyMarry();

        //如果在多线程中使用
        new Thread(() -> {
            System.out.println("i love u");
        }).start();

        //精简版的“婚庆”静态代理
        new WeddingCompany(new You()).HappyMarry();

    }
}

interface Marry{
    //人间四大喜事
        //久旱逢甘霖
        //他乡遇故知
        //洞房花烛夜
        //金榜题名时
    void HappyMarry();
}

//真实角色，需要结婚
class You implements Marry{

    @Override
    public void HappyMarry() {
        System.out.println("秦老师结婚 he is so-happy");
    }
}

//代理角色，帮助他人结婚
class WeddingCompany implements Marry{

    //代理谁->真实目标角色
    private Marry target;//新建一个目标（结婚）对象

    public WeddingCompany(Marry target) {
        this.target = target;
    }

    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();//这就是真实对象
        after();
    }

    private void after() {
        System.out.println("婚后算总账");
    }

    private void before() {
        System.out.println("婚前笑嘻嘻");
    }
}

静态代理模式小结：

  • 真实对象和代理对象都要实现同一个接口
  • 代理对象要代理真实角色

优点：

  • 代理对象可以做很多真实对象做不了（或者说不想做）的事情
  • 真实对象专注做自己（想做）的事情

 

11. 线程状态

在这里插入图片描述
在这里插入图片描述
线程的五个状态：

  • 新生状态（New）
  • 就绪状态（Runnable）
  • 运行状态（Running）
  • 阻塞状态（Blocked）
    • 等待阻塞
    • 同步阻塞
    • 其他阻塞
  • 死亡状态（Dead）
     

线程方法：
在这里插入图片描述

11.1 线程停止

  • 不推荐使用JDK提供的stop()、destroy()等已废弃的方法。
  • 推荐让线程自己停下来。
  • 建议使用一个标志位进行终止变量：当flag==false，则终止线程运行。

 
示例一：

package com.zach.state;

//测试stop
//1.建议线程正常停止->利用次数，不建议死循环
//2.建议使用标志位->设置一个标志位
//3.不要使用stop或者destroy等过时或者JDK不建议使用的方法
public class TestStop implements Runnable{

    //1.设置一个标志位
    private boolean flag = true;

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

    //2.设置一个公开的方法停止线程，转换标志位
    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {
        TestStop testStop = new TestStop();//创建了一个Runnable接口的实现对象
        new Thread(testStop).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main...Thread"+i);
            if (i==500){
                //调用stop方法切换标志位，让线程停止
                testStop.stop();
                System.out.println("stop...run...Thread");
            }
        }

    }
}

11.2 线程休眠

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

示例一：（模拟延时）

package com.zach.state;

//模拟网络延时：方法问题的发生性（线程是不安全的）
public class TestSleep implements Runnable{

    //票数
    private int ticketNums = 10;

    @Override
    public void run() {
        while (true){
            if (ticketNums<=0){
                break;
            }else {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (this){//添加同步锁可以解决多人拿到同一张票的问题
                    System.out.println(Thread.currentThread().getName()+"->拿到了第"+ticketNums--+"票");
                }
//                System.out.println(Thread.currentThread().getName()+"->拿到了第"+ticketNums--+"票");
            }
        }
    }

    public static void main(String[] args) {

        TestSleep ticket = new TestSleep();

        new Thread(ticket,"退钱哥").start();
        new Thread(ticket,"夺命书生").start();
        new Thread(ticket,"黄牛").start();

    }
}

示例二：（模拟倒计时）

package com.zach.state;

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

//模拟倒计时：
public class TestSleep2 {

    //模拟倒计时
    public static void tenDown() throws InterruptedException{
        int num = 10;

        while (true){
            Thread.sleep(100);
            System.out.println(num--);
            if (num<=0){
                break;
            }
        }
    }

    public static void main(String[] args) {
        try {
            tenDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //打印当前系统时间
        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();
            }
        }
    }
}

11.3 线程礼让

  • 礼让线程，让当前正在执行的线程暂停，但不阻塞
  • 将线程从运行状态转为就绪状态
  • 让cpu重新调度，礼让不一定成功！“看CPU心情”

示例一：

package com.zach.state;

//测试礼让线程
    //礼让不一定成功，“看CPU心情”
public class TestYield {

    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();
        new Thread(myYield,"c").start();

    }
    
}

class MyYield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
        Thread.yield();//礼让
        System.out.println(Thread.currentThread().getName()+"线程停止");
    }
}

11.4 线程强制执行

  • Join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞
  • 可以想象成插队

示例一：

package com.zach.state;

//测试join方法
    //想象成插队
public class TestJoin implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("线程程主 is coming"+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 < 100; i++) {
            if (i==20){
                thread.join();//插队
            }
            System.out.println("main"+i);
        }
    }
}

11.5 线程状态观测

  • Thread.State
    线程状态。线程可以处于以下状态之一：

    • New（新生状态）
      尚未启动的线程处于此状态。
    • Runnable（就绪状态）
      在Java虚拟机中执行的线程处于此状态。
    • Blocked（阻塞状态）
      被阻塞等待监视器锁定的线程处于此状态。
    • Waiting（等待状态）（阻塞）
      正在等待另一个线程执行特定动作的线程处于此状态。
    • Timed_Waiting（定时等待状态）（阻塞）
      正在等待另一个线程执行特定动作 达到指定等待时间 的线程处于此状态。
    • Terminated（终止状态）
      已退出的线程处于此状态。

  • 一个线程可以在给定时间点处于一个状态。这些状态是不反应任何操作系统线程状态的虚拟机状态。

示例一：

package com.zach.state;

public class TestState {

    public static void main(String[] args) throws InterruptedException {

        Thread thread = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("!!!!!!");
        });

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

        //观测启动后
        thread.start();//启动线程
        state = thread.getState();
        System.out.println(state);//Run

        while (state != Thread.State.TERMINATED){//只要线程不终止，就一直输出状态
            Thread.sleep(100);
            state = thread.getState();//更新线程状态
            System.out.println(state);//输出状态
        }

//        thread.start();//已经死亡的线程不能再被启动
    }
}

 
 

—————— THE END ——————
 
Zachsj
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java多线程嵌套_Java多线程进阶
weixin_36002897的博客
02-16 4175
需要理解锁是什么意思?首先是发生在多线程的情况下;线程a,线程b,共享资源share例如,share的资源一次只能被一个对象操作,这时候需要一个东西来标识(也叫监视器)出来表明该资源已经有人(指的是线程)在使用了,请还要使用的人(指的是线程)进入等待(线程等待池/队列);怎么实现呢?synchronized关键字,配合一个唯一的东西,可以是类.class,也可以是对象本身;但注意的是必须是一个引用...
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
Java多线程超详解
热门推荐
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
Java多线程（超详细！）
一只小菜鸡
05-13 12万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
qq_35716689的博客
03-10 10万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
java多线程（超详细）
zdl66的博客
08-14 10万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
java多线程使用教程
鹏鹏2077
04-25 5297
本教程介绍了Java多线程的基本知识和使用方法，包括创建线程、实现Runnable接口、继承Thread类、线程同步、线程间通信和线程池等。多线程技术可以提高程序的并发处理能力和响应速度，但同时也带来了线程安全和同步等问题，需要合理使用同步机制来保证线程安全。使用Java提供的Lock接口可以实现更加灵活和精细的线程同步。线程间通信可以使用wait()、notify()和notifyAll()方法来实现。线程池机制可以重用线程，提高了线程的利用率和效率。掌握了这些知识，可以使用Java实现高效、安全、可靠的
【Java多线程】停止线程
一定要站在自己热爱的生活里闪闪发光
10-03 5万+
目录 1. 停止线程的方法 2. 判断线程是否是停止状态 3. 能停止的线程——异常法 4. 在沉睡中停止 5. 能停止的线程——暴力停止 6. 方法stop()与java,lang.ThreadDeath异常 7. 使用return停止线程 1. 停止线程的方法 在Java中有以下3种方法可以终止正在进行的线程： 1）使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。 2）使用stop方法强行终止线程，但是不推荐使用这个方法，因为stop和suspend及resum
JAVA多线程是什么
qq_45022104的博客
08-31 4054
一、 什么是多线程： 我们现在所使用操作系统都是多任务操作系统(早期使用的DOS操作系统为单任务操作系统)，多任务操作指在同一时刻可以同时做多件事(可以同时执行多个程序)。 多进程:每个程序都是一个进程，在操作系统中可以同时执行多个程序,多进程的目的是为了有效的使用CPU资源，每开一个进程系统要为该进程分配相关的系统资源(内存资源) 多线程:线程是进程内部比进程更小的执行单元(执行流|程序片段),每个线程完成一个任务,每个进程内部包含了多个线程每个线程做自己的事情，在进程中的所有线程共享该进程的资源； 主
Java 多线程的应用场景
才哈哈的博客主页
05-01 1万+
电影院新片首映，观影人数大量增加，为提高日营业额，线下售票窗口由原单窗口调整为3窗口，设计一段简单的程序模拟该售票过程。
编程必备：JAVA多线程详解
拾一二的博客
06-14 7787
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
Java多线程详解及示例
07-20
本文将深入探讨Java多线程编程的重要性和使用方法。介绍多线程概念，讨论多线程的优势，并提供实际示例。此外，还将探讨多线程编程中的常见问题以及如何避免这些问题。通过本文，您将获得对Java多线程编程的全面理解...
Java多线程下载器
09-26
Java多线程下载器
Java多线程程序设计
02-19
Java多线程程序设计，源代码注释讲解都包括
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 727
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
Day43
m0_67496588的博客
06-20 994
JSON，Ajax
Homebrew使用
最新发布
gghh2015的博客
06-21 205
具体参考：https://blog.csdn.net/m0_67402970/article/details/126434901。简介：https://www.jianshu.com/p/f4c9cf0733ea。2、查看安装路径：brew list maven。官网：https://brew.sh/
Java面试八股之简述JVM内存结构
u012151345的博客
06-20 814
在Java 8之前，永久代（Permanent Generation）是方法区的实现，之后被元空间（Metaspace）取代。总结来说，JVM内存结构设计精巧，通过区分线程私有和共享区域，以及细致划分各个区域的功能，确保了Java程序的高效、安全运行。每个线程都有自己的栈，用于存储方法调用时的信息，包括局部变量表、操作数栈、动态链接、方法出口等。方法区的一部分，存放编译期生成的各种字面量和符号引用，如字符串字面量、类名、方法名等。JVM中最大的一块内存区域，用于存储几乎所有的对象实例和数组。
Geoserver源码解读三 GeoServerBasePage
Yuanben_wuxin的博客
06-19 980
GeoServerBasePage 登录
jni java多线程
04-15
Java多线程是指在Java程序中同时执行多个线程，每个线程都是独立的执行流。Java提供了多线程编程的支持，可以通过创建Thread类的实例来创建线程，并通过调用start()方法启动线程的执行。 在JNI中使用Java多线程时，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Zachsj

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

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

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

打赏作者

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

抵扣说明：

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

余额充值