Java自学-多线程(1)

1、初识并发问题

2、龟兔赛跑

package lesson01;

/**
 * Author: Gu Jiakai
 * Date: 2021/8/9 9:48
 * FileName: Race
 * Description:
 */
//模拟龟兔赛跑
public class Race implements Runnable {

    private static String winner;//胜利者。

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            //模拟兔子是否休息。
            if(Thread.currentThread().getName().equals("兔子")&&i%10==0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //判断比赛是否结束。
            boolean flag=gameOver(i);
            //如果比赛结束了。
            if(flag){
                break;
            }

            System.out.println(Thread.currentThread().getName()+"-->跑了"+i+"步！");
        }
    }


    //判断是否完成比赛
    private boolean gameOver(int steps){
        //判断是否有胜利者。
        if(winner!=null){//已经有胜利者。
            return true;
        }
        if(steps>=100){
            winner=Thread.currentThread().getName();
            System.out.println("winner is "+winner);
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        Race race = new Race();
        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();
    }
}

3、实现Callable接口

4、静态代理模式

package lesson02;

/**
 * Author: Gu Jiakai
 * Date: 2021/8/9 11:05
 * FileName: StaticProxy
 * Description:
 */

//静态代理模式总结：
//真实对象和代理对象都要实现同一个接口
//代理对象要代理真实角色

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



public class StaticProxy {
    public static void main(String[] args) {
        Wedding wedding = new Wedding(new You());
        wedding.HappyMarry();
    }
}

interface Mary{
    void HappyMarry();
}

//真实角色，你去结婚
class You implements Mary{

    @Override
    public void HappyMarry() {
        System.out.println("小明要结婚了，超开心！");
    }
}

//代理角色，帮助你结婚
class Wedding implements Mary{

    private Mary target;

    public Wedding(Mary target) {
        this.target = target;
    }

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

    private void before() {
        System.out.println("结婚之前，布置现场！");
    }

    private void after() {
        System.out.println("结婚之后，收尾款！");
    }


}

5、Lambda表达式

package lesson02;

/**
 * Author: Gu Jiakai
 * Date: 2021/8/9 11:29
 * FileName: TestLambda1
 * Description:
 */

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

    //静态内部类
    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();
        like.lambda();

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

//        4、局部内部类。
        class Like3 implements ILike{
            @Override
            public void lambda() {
                System.out.println("I like Lambda3！");
            }
        }

        like=new Like3();
        like.lambda();

        //5、匿名内部类。没有类的名称，必须借助接口或者父类。
        like=new ILike() {
            @Override
            public void lambda() {
                System.out.println("I like Lambda4！");
            }
        };
        like.lambda();

        //6、用lambda简化
        like=()->{System.out.println("I like Lambda5！");};
        like.lambda();

    }
}

//1、定义一个函数式接口
interface ILike{
    void lambda();
}

class Like implements ILike{

    @Override
    public void lambda() {
        System.out.println("I like Lambda！");
    }
}

package lesson02;

/**
 * Author: Gu Jiakai
 * Date: 2021/8/9 15:30
 * FileName: TestLambda2
 * Description:
 */
public class TestLambda2 {
    public static void main(String[] args) {
//        Lambda表达式简化。
//        Ilove love=(int a)->{System.out.println("I love you-->!"+a);};

//        简化1：去掉参数类型。
//        Ilove love=(a)->{System.out.println("I love you-->!"+a);};
//        love.love(520);

//        简化2：去掉括号。
//        Ilove love=a->{System.out.println("I love you-->!"+a);};
//        love.love(521);

        //简化3：去掉花括号
        Ilove love=(a,b)->System.out.println("I love you-->!"+a+b);;
        love.love(521,502);


        //总结:
        //lambda表达式只能有一行代码的情况下才能简化成为一行，如果有多行，那么就用代码块包裹。
        // 前提是接口为函数式接口
        //多个参数也可以去掉参数类型，要去掉就都去掉,必须加上括号，
    }
}

interface Ilove{
    void love(int a,int b);
}