第十七课：线程通信、Lambda表达式、JUnit单元测试

线程通信

线程通信 ：共享资源
wait() -> 只能被notify() 或者 notifyAll() 唤醒
wait(long) -> 到时间以后, 自动醒来
notify() - 每次只能唤醒一个线程, 只能唤醒等待时间久的那个线程
notifyAll() - 唤醒所有正在等待的线程
线程池: Executors 工厂类中的方法
newCachedThreadPool(): 创建一个根据需要创建新线程的线程池，但在可用时将重新使用以前构造的线程。
newFixedThreadPool(int nThreads): 创建一个线程池，该线程池重用固定数量的从共享无界队列中运行的线程。
newScheduledThreadPool(int corePoolSize): 创建一个线程池，可以调度命令在给定的延迟之后运行，或定期执行。

线程池执行任务的API:
1.submit(Runnable/Callable)
2.execute(Runnable)
为什么使用线程池?
1、减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
2、可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。
Callable(线程任务, 只能用在线程池) -> Runnable
new Thread(new Runnable(){});
Callable对象只能在 : Future f = pool.submit(Callable);
f.get() -> 得到call方法的返回值，可能会遇到阻塞
f.get(long, TimeUnit.xx) -> 超时继续

Lambda表达式

使用Lambda前提：
1.实现一个接口
2.接口中只有一个抽象方法
3.接口对象是作为方法参数使用的
语法: (参数列表) -> {一些代码}
(参数列表): 表示要重写的抽象方法的参数列表
固定语法, 指向/传递的意思
{一些代码}: 要重写的方法体
Lambda 取代匿名内部类的
Lambda和匿名内部类的区别：
匿名内部类: 本质还是类, 编译后也会生成字节码文件, 运行时也要加载
Lambda: 本质是一个函数, 编译后不会有字节码文件, 直接从内存中获取，效率更高
可推导即可省略:
1、() 中的参数类型, 可以省略, 如果有多个参数, 每个参数类型都要一起省略
2、{} 中如果只有一行代码, 不论这个方法有没有返回值, 那么[{} return ;] 可以省略，{} return ; 必须一起省略
3、() 中如果只有一个参数, () 可以省略, 和类型一起省略，() 中如果没有参数, 必须写 ()

函数式接口: 接口中只有一个抽象方法, 默认方法\静态方法\私有方法 随意
@FunctionalInterface -> 注解
@Override -> 检测方法是不是重写
@SuppressWarnings -> 压制警告
@Deprecated -> 标记一个类或者方法或者变量, 过时的
@FunctionalInterface -> 检测一个接口是不是函数式接口
可变长参数：取代了数组in[ ] arr ->int…arr
JDK1.5后，修改为可变长参数
1、方法中, 除了可变长参数, 还有别的参数, 可变长参数必须放在参数列表最后
2、而且一个方法中, 只能有一个可变长参数
JUnit: 单元测试 -> 以方法为单位, 可以取代主方法
System.out.println(); -> 打桩测试
Debug -> 断点测试
JUnit -> 单元测试
下面展示一些 内联代码片。

// A code block
var foo = 'bar';

public class DemoMyInterface {
    public static void main(String[] args) {
//        int s1 = method1(new MyInterface() {匿名内部类实现接口的功能
//            @Override
//            public int sum(int a, int b) {
//                return 0;
//            }
//        });

//        int s = method1((int a, int b) ->{
//                return a + b;});//实现接口重写
//        System.out.println(s);

        int s = method1(( a, b) ->
             a + b);//实现接口重写
        System.out.println(s);


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

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

//        ArrayList<String> list = new ArrayList<>();
//        Collections.sort(list, new Comparator<String>() {
//            @Override
//            public int compare(String o1, String o2) {
//                return 0;
//            }
//        });

//        ArrayList<String> list = new ArrayList<>();
//        Collections.sort(list,(String o1, String o2)-> {
//                return 0;
//            }
//        );
        ArrayList<String> list = new ArrayList<>();
        Collections.sort(list,( o1,  o2)->
                     0
        );
    }


    public static int method1(MyInterface s){
         return s.sum(3,4);

    }
}

JUnit使用步骤:

1、在工程中创建一个文件夹lib
2、将2个jar包复制到lib中
3、选择jar包 右键 -> Add as Library… 默认添加即可
4、写一个测试类, 在其中写一个方法[不需要返回值,不需要参数]
5、在方法上添加注解 @Test
6、运行这个方法即可

@Test: 测试的方法, 可以直接运行
@Before: 在测试方法之前调用的
@After: 在测试方法之后调用的
下面展示一些 内联代码片。

// A code block
var foo = 'bar';

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class Demo {
    @Before
    public void before(){
        System.out.println("A");
    }
    @After
    public void after(){
        System.out.println("Z");
    }
    @Test
    public void method(){
        System.out.println("aa");
    }
    @Test
    public void method1(){
        System.out.println("bb");
    }
    @Test
    public void method2(){
        System.out.println("cc");
    }
}