day18and19

Day18

线程(object类)中常用的方法
public final void notify() 唤醒当前锁对象的线程 唤醒一个
public final void notifyAll() 唤醒所以使用这个锁对象的线程 唤醒所以
public final void wait() 无线等待 >等待被唤醒
public final void wait(long timeout)>定时等待
线程的方法
public final void join() 当前线程执行完毕才执行其他线程 一定是在线程开启之后调用
public static void sleep(long millis) 定时等待
public static void sleep() 无线等待 等着唤醒
public static void yield() 礼让放弃cpu的争夺权
public final void stop() 停止
public void interrupt() 中断

生产者与消费者模式


生产者


消费者

线程的生命周期(状态图)

2.状态的罗列
新生 实例化线程对象的时候 就是新生状态
就绪 线程可以执行 没有获取到cpu的执行权
运行 线程正在执行操作
阻塞 线程休息一会 sleep(时间) wait()
死亡 线程操作执行结束

3.线程状态的转换图

第三种创建线程的方式

步骤:
1.定义一个类实现Callable接口
2.实现其方法 (执行线程的操作)
3.实例化这个类
4.实例化任务类
5.创建一个线程 开启线程
6.调用给get() 方法得到其返回值

import java.util.concurrent.Callable;

public class MaTest implements Callable<String> {
    @Override
    public String call() throws Exception {
        String string="hdkjasjdla";
        return string;
    }
}

线程池

通过工具类得到线程池对象 ExecutorService 线程池对象
public static ExecutorService newSingleThreadExecutor() 线程池中只有一个线程
public static ExecutorService newFixedThreadPool(int nThreads) 线程池 根据指定的数量来进行创
建

Future submit(Callable task)
Future<?> submit(Runnable task)

关闭线程池
void shutdown() 在关闭线程池之前 会把添加到线程池的任务全部执行完毕
List shutdownNow() 会把没有执行的任务 进行关闭不执行
注意点: 当线程池关闭之后 不能再添加任务到线程池中

Dat19

jdk8提供四个函数式接口
Supplier：供给型接口 生产型接口
Consumer：消费型接口
Predicate：断言型接口
Function<T, R>：函数型接口

Supplier：供给型接口 生产型接口
只是提供了一个生产的方法
T get()

import java.util.function.Supplier;

public class Test {
     public static void main(String[] args) {
         Integer c=   play(()->{
                Integer[] integers={1,3,5,45,34};
                Integer num=integers[0];
                for (int i=0;i<integers.length;i++){
                    if (num<integers[i]){
                        num=integers[i];
                    }
                }
                return num;
            });
         System.out.println(c);
    }
    public  static Integer play(Supplier<Integer> supplier){
        return supplier.get();
    }
}

Consumer：消费型接口 只是提供了一个消费的方法
void accept(T t) 消费的方法
default Consumer andThen(Consumer<? super T> after) 表示连接多个消费型接口 可以进行多次消费

import java.util.function.Consumer;

public class Test2 {
    public static void main(String[] args) {
        String[] s={"uy,i","yut,u","uiy,s"};
        play(s,(String n)->{
            String j=n.split(",")[0];
            System.out.println(j);
        },(String s1)->{
            String j=s1.split(",")[1];
            System.out.println(j);});

    }
    public static void play(String[] str,Consumer<String> c1,Consumer<String> c2){
        for (String s:str){
            c1.andThen(c2).accept(s);
        }
    }
}

Predicate：断言型接口 判断性
boolean test(T t)用于来做判断
and() &&
negate() ！
or ||
用于来连接多个断言型接口


Function<T, R>：函数型接口 转换型接口
andThen(Function) 连接多个函数型接口
R apply(T t) 转换的方法
T==> 需要转换的类型 R ==>表示转换后的类型


Stream接口
4.Stream 不需要手动关闭 执行完流一些操作自定关闭
5.获取 Stream 接口
(1)stream()只能使用Collection类或者是其子类进行转换Stream流

(2)map集合不能直接转换为Stream流 间接转换
1.获取map所以的键 keySet() ==>Set
2.获取map获取的值 values() ==>Collection
3.把map中的键值转换为一对象 Set<Map.Entry<K,V>> entrySet()
（实际上和map遍历一样）

(3)将数据转换为Stream流
static Stream of(T… values)

常规的方法
Stream filter(Predicate<? super T> predicate) 过滤
void forEach(Consumer<? super T> action)
Stream skip(long n) 跳过
Stream limit(long maxSize) 获取指定的元素
map(Function<? super T,? extends R> mapper) ==> 用于做数据类型转换
long count() ==>返回的是Stream 流对象的数据长度
static  Stream concat(Stream<? extends T> a,Stream<? extends T> b)
将两个流资源组合成一个流资源