多线程：Callable接口、静态代理、Lamda表达式、线程状态

Callable

1.实现Callable接口

2.重写call方法，需要抛出异常值

3.创建目标对象

4.创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);

5.提交执行：Future<Boolean> result1 = ser.submit(t1);

6.获取结果：boolean r1 = result1.get();

7.关闭服务:ser.shutdownNow();

Callable的好处：

1.可以定义返回值

2.可以抛出异常

静态代理

public class StaticProxy {

    public static void main(String[] args) {
        
        WeddingCompany weddingCompany = new WeddingCompany(new You());
        weddingCompany.HappyMarry();
    }

    interface Marry{
        void HappyMarry();
    }
}
//真实角色，你去结婚
class You implements StaticProxy.Marry{
    @Override
    public void HappyMarry() {
        System.out.println("秦老师要结婚了，高兴！");
    }
}
//代理角色，帮你去结婚
class WeddingCompany implements StaticProxy.Marry{

    private StaticProxy.Marry target;

    public WeddingCompany(StaticProxy.Marry target){
        this.target = target;
    }

    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();
        after();
    }

    public void before(){
        System.out.println("结婚前准备准备");
    }

    public void after(){
        System.out.println("结完婚收拾收拾");
    }
}

静态代理总结：

1.真实对象和代理对象实现同一个接口

2.代理对象代理真实对象，使用target，放入代理对象，对真实对象进行操作，同时在代理对象内写出其他拓展方法。

好处：

//代理对象可以做很多真实对象做不了的事情

//真实对象可以专注做自己的事情

new Thread (()->System.out.println("我爱你")).start();

new WeddingCompany(new You()).HappyMarry();

把多线程和代理模式进行类比，都是同样继承接口。

lamda表达式

为什么要使用lambda表达式？？

1.避免内部类过多

2.可以让你的代码看起来更简洁

3.去掉一堆没有用意义的代码，只保留核心的逻辑

函数式接口：

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

对于函数式接口，我们可以通过lambada表达式来创建该对象。

public class TestLambda2 {
    public static void main(String[] args) {
        Ilove love = (int a) -> {
            System.out.println("good"+a);
        };
        love.love(2);
        //简化1：参数类型
        love = (a) -> {
            System.out.println("good1"+a);
        }
        love.love(3);
        //简化2:简化括号
        love = a->{
            System.out.println("good"+a);
            System.out.println("good111"+a);
        };
        //简化3：去掉花括号
        love = a -> System.out.println("good"+a);
        //总结：
                //lambda表达式只能有一行代码情况下才能为一行，如果有多行，那么九可以用代码块包裹
                //前提式接口为函数式接口（接口里只有一个方法）
                //多个参数也可以去掉参数类型，要去掉就都去掉，但是必须得加上括号了
                //所以说多线程也可以使用lambda表达式 Thread = ()
        love.love(6);
    }
}

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

线程状态

五种状态：创建、就绪、阻塞、运行、死亡

setPriority(int newPriority)                         更改线程优先级

static void sleep(long millis)                        在指定的毫秒数内让当前正在执行的线程体休眠

void join()                                                    等待该线程停止(vip中间插入)

static void yield()                                        暂停当前正在执行的线程对象，并执行其他的线程

void interrupt();                                          中断线程，别用这个方法

boolean isAlive()；                                        测试线程是否处于活动状态

测试stop方法

//1.建议线程正常停止-->利用次数，不建议死循环
//2.建议使用标志位-->设置一个标志位
//3.不要使用stop或者destory这种过时或者jdk不建议的方法
public class TestStop implements Runnable {

    //1.设置标志位
    private boolean flag = true;

    @Override
    public void run() {
        int i =0;
        while(flag){
            System.out.println("run....Thread"+i++);
        }
    }
    public void stop(){
        this.flag = false;
    }
    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("mian"+i);
            if(i==900){
                //调用stop方法切换标志位，让线程停止
                testStop.stop();
                System.out.println("线程该停止了");
            }
        }
    }
}