並行流與序列流

什麼是並行流

我們先了解一下什麼是Fork/Join框架

Fork/Join框架和傳統的執行緒池的區別

---

應用Fork/Join計算100000000的和：

public class ForkJoinCalculate extends RecursiveTask<Long> {
    /**
     *
     */
    private static final long serialVersionUID = 13475679780L;

    private long start;
    private long end;

    private
 
 static final long THRESHOLD = 10000L; //臨界值

    public ForkJoinCalculate(long start, long end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
        long length = end - start;

        if(length <= THRESHOLD){
            long sum = 0;

            for
 
 (long i = start; i <= end; i++) {
                sum += i;
            }

            return sum;
        }else{
            long middle = (start + end) / 2;

            ForkJoinCalculate left = new ForkJoinCalculate(start, middle);
            left.fork(); //拆分，並將該子任務壓入執行緒佇列

            ForkJoinCalculate right =
 
 new ForkJoinCalculate(middle+1, end);
            right.fork();

            return left.join() + right.join();
        }

    }
}

測試程式碼如下：

    @Test
    public void test() {
        Instant start = Instant.now();
        ForkJoinPool pool = new ForkJoinPool();
        ForkJoinTask<Long> task = new ForkJoinCalculate(0, 100000000L);
        Long sum = pool.invoke(task);
        System.out.println(sum);
        Instant end = Instant.now();
        System.out.println("耗費時間為："+Duration.between(start, end).toMillis());
    }

執行結果如下圖：

數值越大，它的效率體現的就越明顯;
在Java8裡面可以利用並行流就可以這樣來寫：它的底層就是Fork/Join

	@Test
    public void test3() {
        Instant start = Instant.now();
        LongStream.rangeClosed(0, 100000000L)
                .parallel()
                .reduce(0, Long::sum);
        Instant end = Instant.now();
        System.out.println("耗費時間為："+Duration.between(start, end).toMillis());
    }

---

Optional容器類

什麼是Optional類

Optional類的常用方法

一、Optional 容器類：用於儘量避免空指標異常

• Optional.of(T t) : 建立一個 Optional 例項
• Optional.empty() : 建立一個空的 Optional 例項
• Optional.ofNullable(T t):若 t 不為 null,建立 Optional 例項,否則建立空例項
• isPresent() : 判斷是否包含值
• orElse(T t) : 如果呼叫物件包含值，返回該值，否則返回t
• orElseGet(Supplier s) :如果呼叫物件包含值，返回該值，否則返回 s 獲取的值
• map(Function f): 如果有值對其處理，並返回處理後的Optional，否則返回 Optional.empty()
• flatMap(Function mapper):與 map 類似，要求返回值必須是Optional

---

• Optional.of(T t) : 建立一個 Optional 例項

	@Test
    public void test1() {
        Optional<Employee> op = Optional.of(new Employee());
        Employee employee = op.get();
        System.out.println(employee);
    }

執行結果如下：沒有傳任何的引數，這個時候，結果就是預設的值

Employee [id=0, name=null, age=0, salary=0.0, status=null]

需要注意的地方就是：
如果這裡面傳入了一個Null值，那麼這裡就是會發生空指標異常，原來的我們定位空指標異常要一行一行的去定位，非常的麻煩。它的思想就是：如果傳進來了一個Null，在這一行就會發生空指標的異常，方便我們快速定位到空指標異常發生的地方：

Optional<Employee> op = Optional.of(null);

---

• Optional.empty() : 建立一個空的 Optional 例項

	@Test
    public void test2() {
        Optional<Employee> op = Optional.empty();
        System.out.println(op.get());
    }

在這一行發生了空指標異常：

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

---

Optional.ofNullable(T t):若 t 不為 null,建立 Optional 例項,否則建立空例項

• 若 t 不為 null,建立 Optional 例項

	@Test
    public void test3() {
        Optional<Employee> op = Optional.ofNullable(new Employee());
        System.out.println(op.get());
    }

• 若t為Null,那麼則建立空的例項

	@Test
    public void test3() {
        Optional<Employee> op = Optional.ofNullable(null);
        System.out.println(op.get());
    }

---

• isPresent() : 判斷是否包含值
  我們可以進行判斷：有值的時候，就正常的呼叫;如果沒有值的話，那麼就什麼都不做;

	@Test
    public void test4() {
        Optional<Employee> op = Optional.ofNullable(null);
        if (op.isPresent()) {
            System.out.println(op.get());
        }
    }

---

• orElse(T t) : 如果呼叫物件包含值，返回該值，否則返回t
  如果有值的話，那麼就返回值，如果沒有值的話，那麼我們就返回這個備用的值：T
  如果有值的話，那麼就是返回了這個值：

	@Test
    public void test5() {
        Optional<Employee> op = Optional.ofNullable(new Employee());
        if (op.isPresent()) {
            System.out.println(op.get());
        }
        Employee employee = op.orElse(new Employee(1, "張三", 18, 888.88, Employee.Status.FREE));
        System.out.println(employee);
    }

結果如下：

Employee [id=0, name=null, age=0, salary=0.0, status=null]
Employee [id=0, name=null, age=0, salary=0.0, status=null]

如果沒有值的話，那麼就是返回我們備用的值

	@Test
    public void test5() {
        Optional<Employee> op = Optional.ofNullable(null);
        if (op.isPresent()) {
            System.out.println(op.get());
        }
        Employee employee = op.orElse(new Employee(1, "張三", 18, 888.88, Employee.Status.FREE));
        System.out.println(employee);
    }

這個時候，就是隻輸出一個值：也就是當為空時候，輸出我們備用的值

Employee [id=1, name=張三, age=18, salary=888.88, status=FREE]

---

• orElseGet(Supplier s) :如果呼叫物件包含值，返回該值，否則返回 s 獲取的值
  orElseGet這個方法裡面的引數是一個供給型的介面，可以實現具體的功能：

	@Test
    public void test6() {
        Optional<Employee> op = Optional.ofNullable(null);
        Employee employee = op.orElseGet(() -> new Employee());
        System.out.println(employee);
    }

---

• map(Function f): 如果有值對其處理，並返回處理後的Optional，否則返回 Optional.empty()

	@Test
    public void test7() {
        Optional<Employee> op = Optional.ofNullable(new Employee(1, "張三", 18, 888.88, Employee.Status.FREE));
        Optional<String> str = op.map((e) -> e.getName());
        System.out.println(str.get());
    }

---

• flatMap(Function mapper):與 map 類似，要求返回值必須是Optional
  進一步避免空指標異常

    @Test
    public void test8() {
        Optional<Employee> op = Optional.ofNullable(new Employee(1, "張三", 18, 888.88, Employee.Status.FREE));
        Optional<String> opStr = op.flatMap((e) -> Optional.of(e.getName()));
        System.out.println(opStr.get());
    }

一般我們在建立可能為空的屬性的時候，我們就是可以這樣來寫了：
我們就是可以用Optional這個類來進行封裝一下：

private Optional<Godness> godness = Optional.empty();

這個時候，就是可以避免空指標異常了：

這個時候，就是可以避免空指標異常了;
如果，我們傳了，就是我們傳的值，如果沒有傳的話，那麼也是有預設的值，就有效的避免了空指標的異常了：

---

介面中的預設方法與靜態方法

介面中的預設方法

介面中的預設方法有一個類優先的原則：

1. 有一個介面，裡面有一個預設的方法：

public interface MyFun {
    default String getName() {
        return "Hello World";
    }
}

2. 有一個類，裡面也有一個與上面介面同樣名字的方法：

public class MyClass {
    public String getName() {
        return "I love Java";
    }
}

3. 此時，有一個類同時繼承了上面的類和實現了上面的介面：

public class SubClass extends MyClass implements MyFun{

}

4. 現在，我們建立SubClass這個類的例項，並且呼叫了例項的getName方法：

    public static void main(String[]args){
        SubClass subClass = new SubClass();
        System.out.println(subClass.getName());
    }

5. 此時，執行的結果如下：
   

---

需要注意的地方：
如果一個類裡面實現了多個介面，而這多個接口裡面有重名的方法，那麼這個時候，在實現裡面必須指定重寫哪一個介面的對應的方法;

介面中的靜態方法：

public interface MyInterface {
    default String getName() {
        return "hello java";
    }

    public static void show() {
        System.out.println("介面中的靜態方法");
    }
}

用法還是和類裡面的靜態方法一樣用的：

    public static void main(String[]args){
        MyInterface.show();
    }

---

傳統時間格式化的執行緒安全問題

全新的時間都在這幾個包下面：

這些都是常用的：

---

	public static void main(String[]args) throws Exception{
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");

        Callable<Date> task = new Callable<Date>() {
            @Override
            public Date call() throws Exception {
                return sdf.parse("20181111");
            }
        };

        /** 建立長度為10的執行緒池 */
        ExecutorService pool = Executors.newFixedThreadPool(10);
        List<Future<Date>> results = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            results.add((pool.submit(task)));
        }
        for (Future<Date> future : results) {
            System.out.println(future.get());
        }
        pool.shutdown();
    }

如下圖：

看執行結果，是存線上程安全的問題的：

傳統的時間API都存線上程安全的問題;
原來，我們面對執行緒安全問題，我們可以對其加鎖;

• 我們可以使用ThreadLocal

public class DateFormatThreadLocal {
    private static final ThreadLocal<DateFormat> df = new ThreadLocal<>(){
        @Override
        protected DateFormat initialValue() {
            return new SimpleDateFormat("yyyyMMdd");
        }
    };

    public static Date convert(String source) throws ParseException {
        return df.get().parse(source);
    }
}

然後，我們就是可以這樣來用：

public static void main(String[]args) throws Exception{

        Callable<Date> task = new Callable<Date>() {
            @Override
            public Date call() throws Exception {
                return DateFormatThreadLocal.convert("20181111");
            }
        };

        /** 建立長度為10的執行緒池 */
        ExecutorService pool = Executors.newFixedThreadPool(10);
        List<Future<Date>> results = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            results.add((pool.submit(task)));
        }
        for (Future<Date> future : results) {
            System.out.println(future.get());
        }
        pool.shutdown();
    }

這個時候的執行結果就是：

---

Java8全新的API：它是執行緒安全的

public class TestSimpleDateFormat {
    public static void main(String[]args) throws Exception{

        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyyMMdd");

        Callable<LocalDate> task = new Callable<LocalDate>() {
            @Override
            public LocalDate call() throws Exception {
                return LocalDate.parse("20181111",dtf);
            }
        };

        /** 建立長度為10的執行緒池 */
        ExecutorService pool = Executors.newFixedThreadPool(10);
        List<Future<LocalDate>> results = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            results.add((pool.submit(task)));
        }
        for (Future<LocalDate> future : results) {
            System.out.println(future.get());
        }
        pool.shutdown();
    }
}

相關推薦