JUC学习小结(三)

1、Java8之流式计算:

1)java内置核心四大函数式接口:

2)实例:

//R apply(T t);函数型接口,一个参数,一个返回值
Function<String,Integer> function = t ->{return t.length();};
System.out.println(function.apply("abcd"));

//boolean test(T t);断定型接口,一个参数,返回boolean
Predicate<String> predicate = t->{return t.startsWith("a");};
System.out.println(predicate.test("a"));

// void accept(T t);消费型接口,一个参数,没有返回值
Consumer<String> consumer = t->{
    System.out.println(t);
};
consumer.accept("javaXXXX");

//T get(); 供给型接口,无参数,有返回值
Supplier<String> supplier =()->{return UUID.randomUUID().toString();};
System.out.println(supplier.get());

 

2、Stream流式计算:

1)特点:

Stream 自己不会存储元素

Stream 不会改变源对象。相反,他们会返回一个持有结果的新Stream

Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行

2)阶段:

创建一个Stream:一个数据源(数组、集合)

中间操作:一个中间操作,处理数据源数据

终止操作:一个终止操作,执行中间操作链,产生结果

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Arrays;
import java.util.List;
import java.util.UUID;
import java.util.function.*;

@Data
@NoArgsConstructor
@AllArgsConstructor
class User
{
    private Integer id;
    private String  userName;
    private int     age;
}

/**
 * @create 2019-02-26 22:24
 *
 * 题目:请按照给出数据,找出同时满足
 *      偶数ID且年龄大于24且用户名转为大写且用户名字母倒排序
 *      最后只输出一个用户名字
 */
public class StreamDemo
{
    public static void main(String[] args)
    {
        User u1 = new User(11,"a",23);
        User u2 = new User(12,"b",24);
        User u3 = new User(13,"c",22);
        User u4 = new User(14,"d",28);
        User u5 = new User(16,"e",26);

        List<User> list = Arrays.asList(u1,u2,u3,u4,u5);

        list.stream().filter(p -> {
            return p.getId() % 2 == 0;
        }).filter(p -> {
            return p.getAge() > 24;
        }).map(f -> {
            return f.getUserName().toUpperCase();
        }).sorted((o1, o2) -> {
            return o2.compareTo(o1);
        }).limit(1).forEach(System.out::println);


    }
}

 

3、分支合并框架:

Fork:把一个复杂任务进行分拆,大事化小
Join:把分拆任务的结果进行合并

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;

class MyTask extends RecursiveTask<Integer>{
    private static final Integer ADJUST_VALUE = 10;
    private int begin;
    private int end;
    private int result;

    public MyTask(int begin, int end) {
        this.begin = begin;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        if((end - begin)<=ADJUST_VALUE){
           for(int i =begin;i <= end;i++){
                result = result + i;
           }
        }else{
            int middle = (begin + end)/2;
            MyTask task01 = new MyTask(begin,middle);
            MyTask task02 = new MyTask(middle+1,end);
            task01.fork();
            task02.fork();
            result =  task01.join() + task02.join();
        }


        return result;
    }
}


/**
 * 分支合并例子
 * ForkJoinPool
 * ForkJoinTask
 * RecursiveTask
 */
public class ForkJoinDemo {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        MyTask myTask = new MyTask(0,100);
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Integer> forkJoinTask = forkJoinPool.submit(myTask);

        System.out.println(forkJoinTask.get());

        forkJoinPool.shutdown();
    }
}

 

4、异步回调:

import java.util.concurrent.CompletableFuture;

public class CompletableFutureDemo {

    public static void main(String[] args) throws Exception {
        //同步,异步,异步回调

        //同步
//        CompletableFuture<Void> completableFuture1 = CompletableFuture.runAsync(()->{
//            System.out.println(Thread.currentThread().getName()+"\t completableFuture1");
//        });
//        completableFuture1.get();

        //异步回调
        CompletableFuture<Integer> completableFuture2 = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread().getName()+"\t completableFuture2");
            int i = 10/0;
            return 1024;
        });

        completableFuture2.whenComplete((t,u)->{
            System.out.println("-------t="+t);
            System.out.println("-------u="+u);
        }).exceptionally(f->{
            System.out.println("-----exception:"+f.getMessage());
            return 444;
        }).get();

    }
}

 

### Java JUC学习教程和资源 #### 了解基础概念 Java中的`java.util.concurrent`(JUC)工具包自JDK 1.5版本引入[^1],旨在提供显式锁定机制、原子变量以及高级集合类等功能的支持。这些功能极大地简化了并发编程的任务。 #### 掌握核心组件 - **锁(Lock)**:不同于内置的`synchronized`关键字所提供的隐式锁,`Lock`接口及其子类提供了更灵活且强大的锁定特性[^3]。 - **原子操作(Atomic Variables)**:通过诸如`AtomicInteger`这样的类可以执行高效的无锁算法,在高争用场景下性能优于传统的同步方式[^4]。 ```java import java.util.concurrent.atomic.AtomicInteger; public class AtomicExample { private static AtomicInteger atomicInt = new AtomicInteger(0); public void increment() { while (true) { int value = atomicInt.get(); boolean updated = atomicInt.compareAndSet(value, value + 1); if (updated) break; } } } ``` #### 利用线程管理设施 为了提高CPU利用率并减少创建销毁开销,开发者应熟悉如何运用线程池等池化技术来管理和重用工作线程实例[^2]: ```java import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class ThreadPoolExample { public static void main(String[] args) { ExecutorService executor = Executors.newFixedThreadPool(10); // 创建固定大小为10的线程池 Runnable task = () -> System.out.println(Thread.currentThread().getName()); for(int i=0;i<10;i++) { executor.submit(task); } executor.shutdown(); // 关闭线程池 } } ``` #### 高级主题探索 随着对基础知识掌握程度加深,还可以深入研究阻塞队列、信号量、倒计时门闩(`CountDownLatch`)、循环屏障(`CyclicBarrier`)等更为复杂的同步结构;同时关注AQS(AbstractQueuedSynchronizer),这是许多同步器的基础框架之一。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值