2021-2-28 线程

线程

1.extends Thread

类名 extends Thread

重写run()方法

调用.start()开启线程，调用.run()的话按main里现后顺序执行，没有同步效果

public class TestTread1 extends Thread{

    @Override
    public void run(){
        for (int i=0;i<200;i++) {
            System.out.println(Thread.currentThread().getName()+"在执行线程--"+i);
        }
    }

    public static void main(String[] args) {
        //多对象
        TestTread1 t1 = new TestTread1();
        TestTread1 t2 = new TestTread1();
        TestTread1 t3 = new TestTread1();

        t1.start();
        t2.start();
        t3.start();

        for (int i = 0; i < 200; i++) {
            System.out.println("在主方法--"+i);
        }
    }
}

2.实现 Runnable接口

类名 implements Runnable

//创建线程第二个方法： 1。实现runnable接口  2.重写run（）方法  3. 执行线程需要丢入runnable接口实现，调用start方法。
public class TestTread2 implements Runnable{
    
    @Override
    public void run(){
        for (int i=0;i<200;i++) {
            System.out.println("在执行线程--"+i);
        }
    }

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

        //A.与直接继承extends主要区别是需要静态代理！！！（本质一样）
        //B.实现Runnable方便一个对象被多个线程使用，避免单继承局限性
        //创建线程对象，通过线程对象来开启我们的线程-----静态代理
        Thread thread = new Thread(t1);
        thread.start();
        //这两行等价于下面                                      
        //new Thread(t1).start();
        
        for (int i = 0; i < 200; i++) {
            System.out.println("在主方法--"+i);
        }
    }
}

3.多个线程同时操作同一个对象

火车票数据紊乱案例

//买火车票
//发现问题，多个线程操作同一对象时，线程不安全，数据紊乱
public class TestTread3 implements Runnable{
    //票数
    private int tacketNumbers = 10;
    public void run(){
        while(true){
            if(tacketNumbers<=0){
                break;
            }
            //模拟延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"-->拿到了第"+tacketNumbers--+"张票");
        }
    }
    public static void main(String[] args) {
        //一个对象 ticker
        TestTread3 ticker = new TestTread3();
        //开启三个线程同时操作ticker
        new Thread(ticker , "小明").start();
        new Thread(ticker , "小红").start();
        new Thread(ticker , "黄牛").start();
    }
}

龟兔赛跑案例

public class Race implements Runnable{
    private static String winner;

    @Override
    public void run(){
        for(int i = 0;i<101;i++){
            //模拟兔子睡觉
            if(Thread.currentThread().getName().equals("兔子")&& i%10==0){
                try {//ctrl alt t 快捷包裹
                    Thread.sleep(200);
                } 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();
    }
}

4.实现callable接口

//Callable的好处
//1.可以定义返回值
//2.可以抛出异常

public class Test1 implements Callable<Boolean> {//Callable的<>里面要一个返回值
    private String url;  //网络图片地址
    private String name; //图片名字

    public Test1(String url, String name){
        this.url = url;
        this.name = name;
    }

    @Override
    //重写call方法
    public Boolean call(){
        //方法体
        return true;
    }

    public static void main(String[] args) {
        //Test1 t1 = new Test1(url,name);//此处没给url和名字
        //Test1 t2 = new Test1(url,name);
        //Test1 t3 = new Test1(url,name);

        //1.创建服务
        ExecutorService ser = Executors.newFixedThreadPool(3);//三个线程

        //2.提交执行
        //Future<Boolean> r1  = ser.submit(t1);
        //Future<Boolean> r2  = ser.submit(t2);
        //Future<Boolean> r3  = ser.submit(t3);

        //3.获取结果
        //boolean rs1 = r1.get();
        //boolean rs2 = r2.get();
        //boolean rs3 = r3.get();

        //可以打印返回值rs1，rs2，rs3
        //System.out.println(rs1);//返回真，前面给定了
        //System.out.println(rs2);
        //System.out.println(rs3);

        //4.关闭服务
        ser.shutdownNow();
    }
}

5.静态代理

//静态代理模式：
//1.真实对象（要结婚的客人）和代理对象（婚庆公司）都要事先同一个接口
//2.代理对象要代理真实角色

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

public class Test1 {
    public static void main(String[] args) {

        new Thread(new Runnable() {
            @Override
            public void run() {

            }
        }).start();

        WeddingCompany wc1 = new WeddingCompany(new You());
        wc1.HappyMarry();
        //或者 new WeddingCompany(new You()).HappyMarry();

    }
}

interface Marry{
    void HappyMarry();
}

class You implements Marry{
    @Override
    public void HappyMarry(){
        System.out.println("客人要结婚了");
    }
}

class WeddingCompany implements Marry{
    private Marry target;//确定要帮谁结婚target

    public WeddingCompany(Marry 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("结婚后");
    }
}

6.lambda表达式

/*
* lambda表达式演变
* 目的：
* 简洁代码
* 函数式编程
* */
public class Lambda {

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



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

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

        //4.局部内部类
        class Like3 implements ILike{
            @Override
            public void lambda() {
                System.out.println("i like lambda3");
            }
        }
        ilike = new Like3();
        ilike.lambda();

        //5.匿名内部类,没有类的名称，必须借助接口或者父类. 重写方法
        ilike = new ILike() {
            @Override
            public void lambda() {
                System.out.println("i like lambda4");
            }
        };
        ilike.lambda();

        //6.用lambda简化
        ilike = ()->{
            System.out.println("i like lambda5");
        };
        ilike.lambda();
    }

}
//函数类接口，指接口只有一个抽象函数（方法）
//1.定义一个函数类接口
interface ILike{
    void lambda();
}

//2.实现类
class Like implements ILike{
    @Override
    public void lambda() {
        System.out.println("i like lambda");
    }
}

/*
对lambda表达式的进一步化简
*/
public class Lamdba2 {
    public static void main(String[] args) {
        Ilove love = (int a)->{
            System.out.println("i love u "+a);
        };
        //简化1.去掉参数类型
        Ilove love1 = (a)->{
            System.out.println("i love u "+a);
        };

        //简化2.去掉括号
        Ilove love2 = a->{
            System.out.println("i love u "+a);
        };
        love2.love(521);

        //简化3.去掉花括号
        Ilove love3 = a->
            System.out.println("i love u "+a);
        love3.love(522);

        /*
         * 总结：
         * lambda表达式，只能有一行代码的情况下才能简化成为1行，多行就用{}包裹
         * 前提是接口为函数式接口
         * 多个参数也可以去掉参数类型
         * */
    }
}

interface Ilove{
    void love (int a);
}