多线程的底层原理和应用

多线程的应用

​ 多线程知道怎么开启线程的只是基础，下面的例子中都是不同场景下对多线程的应用

静态代理模式

1. 静态代理模式其实就是Thread的实现原理

2. 代码如下

   package com.xiaoke.study.day01.com.xiaoke.study.Demo03_Threand;
   
   //写网上的一个内容
   //以结婚举例，接口是结婚
   //两个方法使用接口，一个是自己，一个是婚庆公司
   //然后在婚庆公司的方法中用自己代入
   
   
   public class StaticProxy {
       public static void main(String[] args) {
           //静态代理总结
           /**
            * 1.真实对象(我)和代理对象(婚庆公司)实现同一个接口
            * 2.代理对象要代理真实角色(使用构造方法加一个参数，参数是实现的接口类型就可以)
            * */
           //优点
           /**
            * 1，代理对象可以做很多真实对象做不了的事(即多余的事)
            * 2.真实对象可以专注做自己的事(比如我只结婚)
            * */
   
   //        new Thread(new Runnable() {
   //            @Override
   //            public void run() {
   //                System.out.println("我完成了这个事");
   //            }
   //        }
   //        ).start();
   
           //上面注释的7行部分的内容等同于下面这句
           new Thread(()-> System.out.println("我完成了这个事")).start();
           //下面这行代码就是上面这行代码即线程的底部实现原理
           new WeddingCompany(new My()).haveMarry();
           //上面这行代码就是下面这两行代码的简化
   //        WeddingCompany weddingCompany = new WeddingCompany(new My());
   //        weddingCompany.haveMarry();
   
       }
   
   }
   
   
   //结婚的接口
   interface Marry{
       void haveMarry();
   }
   
   //自己继承这个接口
   class My implements Marry{
   
       @Override
       public void haveMarry() {
           System.out.println("我结婚了");
       }
   }
   
   //婚庆公司继承这个接口
   class WeddingCompany implements Marry{
   
       Marry target;
       public WeddingCompany(Marry target) {
           this.target = target;
       }
   
       @Override
       public void haveMarry() {
           BeforeMarry();
           this.target.haveMarry();
           AfterMarry();
       }
   
   
       private void BeforeMarry() {
           System.out.println("结婚前婚庆公司的准备");
       }
   
   
       private void AfterMarry() {
           System.out.println("结婚后婚庆公司的收拾");
       }
   }
   
   
   
   
   
   

lambda表达式(扩展)

• λ是希腊字母的第十一个，英语名字为lambda，这个表达式作用总结来说就是简化，如下

  new Thread(()-> System.out.println("完成了简化")).start()
  

  作用

  1. 避免匿名内部类定义过多
  2. 可以让代码看上去更简洁
  3. 去掉了冗余代码

• 函数式接口(Functional Interface)是学习lambda的关键

  定义

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

     public interface Runnable {
         public abstract void run();
     }
     

  2. 对于函数式接口，我们可以通过lambda表达式创建该接口的对象

  package com.xiaoke.study.day01.com.xiaoke.study.Demo04_Lambda;
  /**
   * 推导lambda表达式
   * */
  public class Lambda {
  
      public static void main(String[] args) {
          LamTest lamTest = new Test();
  
  
      }
  
  
      Test test = new Test();
  
  }
  
  //1.定义一个只有一个抽象方法的接口(即函数式接口)
  interface LamTest{
      void LanbdaWay();
  }
  
  //2.定义一个方法，实现上面的这个接口
  class Test implements LamTest{
      @Override
      public void LanbdaWay() {
          System.out.println("这是对于实现接口的方法");
      }
  }