2021-07-21关于多线程的学习记录

实现多线程的两种方式

        1.继承Thread类：

          子类继承Thread类具备多线程的能力

          启动线程：子类对象.start()

          不建议使用：避免OOP单继承的局限性。

        2.实现Runnable接口

          实现接口Runnable具有多线程能力

          启动线程：传入目标对象+Thread对象.start()

          推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

关于并发的问题：多个线程操作同一个资源可能会导致数据紊乱。

//龟兔赛跑示例

private static String winner;
    @SneakyThrows
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if(Thread.currentThread().getName()=="tu" && i==10){
                Thread.sleep(10);
            }
            if(gameover(i)){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"跑了"+i+"步");
        }
    }
    public boolean gameover(int step){
        if(winner != null){
            return true;
        }
        if(step>= 100){
            winner=Thread.currentThread().getName();
            System.out.println("胜者为"+winner);
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        GuiRun guiRun=new GuiRun();
        new Thread(guiRun,"gui").start();
        new Thread(guiRun,"tu").start();
    }

静态代理模式总结：

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

        好处： 代理对象可以做很多真实对象做不了的事情；真实对象专注做自己的事情

多线程的Thread的底层逻辑就是静态代理：

        new Thread(()->System.out.println("sss")).start();

package com.kyon.tool.test;

public class testMary {
    public static void main(String[] args) {
        WendyConpony wendyConpony= new WendyConpony(new You("狗"));
        wendyConpony.HappyMarry();
    }
}

interface Marry{
    void HappyMarry();
}

class You implements Marry{
    private String sei;

    public You(String sei){
        this.sei=sei;
    }
    @Override
    public void HappyMarry() {
        System.out.println("这个狗篮子==>"+sei+"结婚");
    }
}
//此处为代理对象
class WendyConpony implements Marry{
    //代理谁==》真实目标角色
    private Marry target;


    public  WendyConpony(Marry target){
        this.target=target;
    }
    @Override
    public void HappyMarry() {
    before();
    this.target.HappyMarry();//此处为真实对象
    after();
    }
    void before(){
        System.out.println("给钱");
    }
    void after(){
        System.out.println("入洞房");
    }
}

关于类的几种方式：

/*
推导lambda表达式
* */
public class TestLambda {
    //静态内部类
    static class Ilke2 implements Like{
        @Override
        public void lambda() {
            System.out.println("lambda2");
        }
    }
    public static void main(String[] args) {
        Like iLike=new ILike();
        iLike.lambda();

        iLike=new Ilke2();
        iLike.lambda();
        //局部内部类
        class Ilke3 implements Like{

            @Override
            public void lambda() {
                System.out.println("lambda3");
            }
        }
        iLike=new Ilke3();
        iLike.lambda();
        //匿名内部类
        iLike=new Like() {
            @Override
            public void lambda() {
                System.out.println("lambda4");
            }
        };
        iLike.lambda();
        //简化为lambda表达式
        iLike =()->{
            System.out.println("lambda5");
        };
        iLike.lambda();
    }
}
    //接口
    interface Like {
        void lambda();
    }
    //实现类
    class ILike implements Like {
        @Override
        public void lambda() {
            System.out.println("lambda1");
        }
    }

         函数式接口的定义：

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

                public interface Runnable{

                       public abstract void run(); 

               }

                对于函数式接口，可以通过lambda表达式来创建该接口。（硬性条件）

                

    public static void main(String[] args) {
        //lambda表达式
        Dota dota2=(String a)->{
            System.out.println(a);
        };
        //简化
        dota2=a->{
            System.out.println(a);
        };
        //简化（仅限一行代码）
        dota2=a->System.out.println(a);
        dota2.jiu("aaaa");
    }


}

interface Dota{
    void jiu( String tp);
}