Thread

//创建线程方式一：继承Thread类，重写run()方法，调用start开启线程
public class TestThread01 extends Thread {
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码———" + i);
        }
    }

    public static void main(String[] args) {
        //main线程，主线程

        //创建一个线程对象
        TestThread01 testThread01 = new TestThread01();

        //调用start()方法开启线程
        testThread01.start();

        for (int i = 0; i < 100; i++) {
            System.out.println("我在学习多线程--" + i);

        }
    }
}

运行结果是穿插顺序的，说明是同时执行

线程不一定立即执行，CPU安排调度

Runnable

//创建线程方式二：实现runnable接口，重写run方法，只想线程需要丢入runnable接口实现类，调用start方法。
public class TestThread02 implements Runnable {
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码———" + i);
        }
    }

    public static void main(String[] args) {
        //创建runnable接口的实现类对象
        TestThread02 testThread02 = new TestThread02();

        //创建线程对象，通过线程对象来开启我们的线程，代理
        new Thread(testThread02).start();

        for (int i = 0; i < 100; i++) {
            System.out.println("我在学习多线程--" + i);
        }
    }
}

运行结果同上，穿插运行

小结：

• 继承Thread类

  • 子类继承Thread类具备多线程能力
  • 启动线程：子类对象.start()
  • 不建议使用：避免OOP单继承局限性

• 实现Runnable接口

  • 实现接口Runnable具有多线程能力
  • 启动线程：传入目标对象+Thread对象.start()
  • 推荐使用：避免单继承局限性，灵活方便，方便同一对象被多个线程使用

买火车票案例

问题：多个线程操作同一资源的情况下，线程不安全，数据紊乱。

//多个线程同时操作同一个对象
public class TestThread03 implements Runnable {

    //票数
    private int ticketNums = 10;

    @Override
    public void run() {
        while (true) {
            if (ticketNums <= 0) {
                break;
            }
            System.out.println(Thread.currentThread().getName() + "-->抢到了第" + ticketNums-- + "张票");
        }
    }

    public static void main(String[] args) {
        TestThread03 testThread03 = new TestThread03();

        new Thread(testThread03, "小明").start();
        new Thread(testThread03, "老师").start();
        new Thread(testThread03, "黄牛党").start();
    }
}

龟兔赛跑

1.首先来个赛道距离，然后要离终点越来越近
2.判断比赛是否结束
3.打印出胜利者
4.龟兔赛跑开始
5.故事中是乌龟赢的，兔子需要睡觉，所以我们来模拟兔子睡觉
6.终于，乌龟赢得比赛

//模拟龟兔赛跑
public class TestThread04 implements Runnable{

    //胜利者
    private static String winner;

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            //模拟兔子休息
            if(Thread.currentThread().getName().equals("兔子")&& i%0==0){
                try {
                    Thread.sleep(200);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }

            }

            //判断比赛是否结束
            boolean flag=gameOver(i);
            //如果比赛结束了，就停止程序
            if(flag){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"-->跑了"+i+"步");
        }
    }

    //判断是否完成比赛
    public 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) {
        //一条赛道
        TestThread04 race = new TestThread04();

        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();
    }
}

Lamda表达式

推导过程：

package org.example.lamda;

/*
推导lamda表达式
 */
public class TestLamda {

    //3.静态内部类
    static class Like2 implements ILike {
        @Override
        public void lamda() {
            System.out.println("I like lamda2");
        }
    }

    public static void main(String[] args) {
        ILike like = new Like();
        like.lamda();

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

        //4.局部内部类
        class Like3 implements ILike {
            @Override
            public void lamda() {
                System.out.println("I Like Lamda3");
            }
        }
        like = new Like3();
        like.lamda();

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

        //6.用lamda简化
        like = () -> {
            System.out.println("I Like Lamda5");
        };
        like.lamda();
    }
}

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

//2.实现类
class Like implements ILike {
    @Override
    public void lamda() {
        System.out.println("I Like Lamda");
    }
}

Lambda简化

public class TestLamda2 {
    public static void main(String[] args) {
        //1.lamda表示简化
        ILove love = (int a) -> {
            System.out.println("I Love Java\t" + a);
        };

        //简化1：参数类型
        love = (a) -> {
            System.out.println("I Love Java\t" + a);
        };

        //简化2：简化括号
        love = a -> {
            System.out.println("I Love Java\t" + a);
        };

        //简化3：去掉花括号
        love = a -> System.out.println("I Love Java\t" + a);

        love.love(67);
    }
}

interface ILove {
    void love(int a);
}

总结：

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