一些java特性

狂神说JUC课程学习，图片来源课程视频

1. 函数式接口

函数式接口：只有一个方法的接口，比如Runnable 接口Callable接口，@FunctionInterface。 函数式接口都可以用lambda表达式简化。

原生的函数式接口：

• Function：函数型接口 一个输入参数一个输出

import java.util.function.Function;

public class FunctionalInterface {
    public static void main(String[] args) {
//        Function function = new Function<String, String>() {
//            @Override
//            public String apply(String str) {
//                return str;
//            }
//        };
        Function function = (str)->{return str;};
        System.out.println(function.apply("输入"));
    }
}

• Predicate：断定型接口 返回值布尔型

import java.util.function.Predicate;

public class FunctionalInterface {
    public static void main(String[] args) {
//        Predicate<String> predicate = new Predicate<String>() {
//            @Override
//            public boolean test(String s) {
//                return s.isEmpty();
//            }
//        };
        Predicate<String> predicate = (str) -> {return str.isEmpty();};
        System.out.println(predicate.test("输入"));
    }
}

• Consumer：消费型接口 只有输入没有返回值
• Supplier：供给型接口 只有返回值没有输入

2.Stream流式计算

存储 计算交给流

// User类
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private int id;
    private String name;
    private int age;
}



//stream类

import java.util.Arrays;
import java.util.List;

/*
* 现在有5个用户，筛选：
* 1 ID必须是偶数
* 2 年龄必须大于23
* 3 用户名转为大写
* 4 用户名字母倒着排序
* 5 只输出一个用户
 */
public class Test {
    public static void main(String[] args) {
        User u1 = new User( 1, "a", 21);
        User u2 = new User( 2, "b", 22);
        User u3 = new User( 3, "c", 23);
        User u4 = new User( 4, "d", 24);
        User u5 = new User( 5, "r", 25);
        // 使用集合存储
        List<User> list = Arrays.asList(u1, u2, u3, u4, u5);
        // 使用流计算
        // 链式编程
        list.stream()
                .filter(u -> {return u.getId()%2 ==0;})
                .filter(u -> {return u.getAge()>23;})
                .map(u -> {return u.getName().toUpperCase();})
                .sorted((uu1, uu2) ->{return uu2.compareTo(uu1);})
                .limit(1)
                .forEach(System.out::println);

    }
}

JUC并发编程

狂神说JUC课程学习，图片来源课程视频

1. 基础知识

• java默认有两个线程：main、GC
• java实际上不能开启线程，而是通过本地的native方法调用C++，java不能直接操作硬件
• 并发不是并行，并发指多线程操作同一个资源，可以通过单核cpu快速交替；并行是多个线程同时执行。
• 线程有六种状态：NEW RUNNABLE BLOCKED WAITING（一直等待） TIMED_WAITING（超时等待） TERMINATED
• wait/sleep区别：
  • 来自不同的类：wait Object sleep Thread
  • wait会释放锁，sleep不
  • wait必须在同步代码块中
  • wait不需要捕获异常，sleep必须要捕获异常

2. Lock锁

2.1 基本概念

首先注意：回顾先前线程的创建方式，更安全的方法：线程就是一个单独的资源类，没有任何附属的操作。（使用lambda表达式调用普通类的方法）

• 公平锁：先来后到
• 非公平锁：可以插队（默认）

Synchronized和Lock区别：

• Synchronized内部关键字，Lock是内置的类
• Synchronized无法判断获取锁的状态
• Synchronized会自动释放锁
• Synchronized在获得锁的线程阻塞之后，另外的线程需要等待；Lock锁的tryLock方法不一定等待下去
• Synchronized是非公平锁，Lock可以自己设置。都是可重入锁

2.2 发电话发短信问题

synchronized锁的是对象，即该方法的调用者，谁先拿到谁执行，所以下列代码永远先发短信。

package com.zhang.lock;

import java.util.concurrent.TimeUnit;

public class Lock8 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(()->{phone.sendSms();}, "A").start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{phone.call();}, "B").start();
    }
}

class Phone{
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized  void call() {
        System.out.println("打电话");
    }
}

使用一个普通方法hello，是先发短信还是hello？

• hello，普通方法不受锁的影响

两个对象，先发短信还是打电话？

• 打电话

在同步方法里加static，先发短信还是先打电话？

• 发短信，static方法在类一加载就有了，但此时锁的是class模版

在同步方法里加static，且用两个对象？

• 发短信，class模版只有一个

静态同步方法发短信，同步方法打电话？

• 打电话，因为锁的对象不一样

2.3 读写锁ReadWriteLock

ReadWriteLock readWriteLock = new ReetrantReadWriteLock();

更细粒度的控制，分别控制读和写。写的时候只允许一个线程写。而且先写后读。

独占锁（写锁）：一次只能被一个线程占有

共享锁（读锁）：多个线程可以同时占有

3.生产者消费者Lock版本

3.1 Synchronized版：wait notify方法

package com.zhang.pc;

public class A {
        public static void main(String[] args) {
                Data data = new Data();
                new Thread( ()->{
                        for (int i = 0; i < 10; i++) {
                                try {
                                        data.increment();
                                } catch (InterruptedException e) {
                                        e.printStackTrace();
                                }
                        }
                }, "A").start();

                new Thread( ()->{
                        for (int i = 0; i < 10; i++) {
                                try {
                                        data.decrement();
                                } catch (InterruptedException e) {
                                        e.printStackTrace();
                                }
                        }
                }, "B").start();

        }
}

class  Data {
        private int number = 0;

        public synchronized void increment() throws InterruptedException {
                if(number != 0)  this.wait();
                number++;
                System.out.println(Thread.currentThread().getName() + "==>" +number);
                this.notifyAll();
        }

        public synchronized void decrement() throws InterruptedException {
                if(number == 0) this.wait();
                number--;
                System.out.println(Thread.currentThread().getName() + "==>" + number);
                this.notifyAll();
        }

}

问题：多个线程呢？

不会0101了！

虚假唤醒问题：wait方法放在while循环里，将上面代码的if换成while即可

3.2 JUC版PC问题

Condition await signal代替

问题：线程直接没有顺序？A-->B-->C-->A？

3.3 JUC版+

新建多个condition监视器

4.集合类不安全

4.1 List多线程不安全

ConcurrentModificationException 并发修改异常

// java.util.ConcurrentModificationException 并发修改异常
public class Unsafe {
    public static void main(String[] args) {
        /*
         1. Vector<>是安全的
         2. Collections.synchronizedList(new ArrayList<>())
         3. new CopyOnWriteArrayList<>();
        */
        List<String> list = new CopyOnWriteArrayList<>();
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0, 5));
                System.out.println(list);
            }, String.valueOf(i)).start();

        }
    }
}

CopyOnWrite（COW），写入时复制，在写入的时候避免覆盖

CopyOnWriteArrayList比Vector优点：sychronized方法较低

4.2 Set、Map不安全

和BlockingQueue、List都是实现Collection接口

方式1:Collections.synchronizedSet(new HashSet<>());

2.new CopyOnWriteArraySet<>();

ps：HashSet底层是什么？

Ans：就是Hashmap<>用键值

map默认参数？

Ans：初始化容量16，0.75加载因子

HashMap也不安全，所以公司中也不会用

方式1:Collections.synchronizedMap(new HashSet<>());

2.new ConcurrentHashMap<>();

5.Callable接口的使用

有返回值可以抛出异常，相比Runnable接口的优势

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // new Thread(new Runnable()).start();
        // new Thread(new FutureTask<V>()).start();
        // new Thread(new FutureTask<V>(Callable)).start();
        MyThread thread = new MyThread();
        FutureTask futureTask = new FutureTask(thread);
        new Thread(futureTask, "A").start();
        Integer o = (Integer) futureTask.get();// get()方法可能会产生阻塞，把他放到最后或者使用异步通信
        System.out.println(o);
    }
}

class MyThread implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        System.out.println("call()");
        return 1024;
    }
}

6.常用的辅助类

6.1 CountDownLatch

import java.util.concurrent.CountDownLatch;

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(6);

        for (int i = 0; i < 6; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "go out");
                countDownLatch.countDown();//数量-1
            }, String.valueOf(i)).start();
        }
        countDownLatch.await(); // 等待计数器归零
        System.out.println("关门");
    }
}

6.2 CyclicBarrier

累加计数器

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7, ()->{
            System.out.println("召唤神龙");
        });

        for (int i = 0; i <= 6; i++) {
            final int temp = i; // 操作i需要这样做
            new Thread(()->{
                System.out.println(Thread.currentThread().getName() + "收集" + temp);
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.println("???");

            }).start();
        }


    }
}

6.3 Semaphore（信号量）

限流

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class SemaphoreDemo {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3);
        for (int i = 0; i < 6; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + "抢到车位");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName() + "离开车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                }
            }, String.valueOf(i)).start();
        }
    }
}

7.阻塞队列

7.1 BlockingQueue的API

7.2 SynchronousQueue

没有容量，进去一个必须出来才能进入，大小固定为1

put take

8.线程池

程序占用系统的资源，为了优化资源的使用==>池化技术，比如线程池、内存池、对象池、连接池（创建销毁十分浪费资源）

池化技术：事先准备好一些资源，有人要用就拿

线程池的好处：

• 降低资源的消耗，提高速度
• 线程复用，可以控制最大并发数，管理线程

8.1 Executors类的方法

注意：

• 不能使用Executors工具类创建，因为默认值是21亿左右的intmax

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Pool {
    public static void main(String[] args) {
        //ExecutorService threadPool = Executors.newSingleThreadExecutor();//单个
        ExecutorService threadPool = Executors.newFixedThreadPool(5);//固定大小
        //ExecutorService threadPool = Executors.newCachedThreadPool();//尽量满足的大小
        try {
            for (int i = 0; i < 10; i++) {
                //使用线程池创建线程
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName() + " ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();//使用完一定要关闭
        }

    }
}

8.2 参数

//具体实现：
    public ThreadPoolExecutor(int corePoolSize,//核心线程池大小
                              int maximumPoolSize,//最大线程池大小
                              long keepAliveTime,//超时没有人调用就会释放
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,//线程工厂，创建线程的一般不用动
                              ThreadFactory threadFactory,//拒绝策略
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

拒绝策略默认：

• AbortPolicy 不处理并抛出异常
• CallerRunsPolicy 哪里来的回哪去
• DiscardPolicy 不处理不抛出异常
• DiscardOldestPolicy 队列满了，尝试去和最早的竞争，不抛出异常

如何选择最大线程：

1. cpu密集型 几核

Runtime.getRuntime().availableProcessors();

2. io密集型 大型任务io十分占用资源，大于这个任务数即可

9.ForkJoin

并行执行任务，提高效率，大数据量

大数据： Map Reduce 把大任务拆成小任务

特点：工作窃取

里面维护的都是双端队列

import java.util.concurrent.RecursiveTask;

public class ForkJoin extends RecursiveTask<Long> {
    private Long start;
    private Long end;
    private Long temp = 10000L;

    public ForkJoin(Long start, Long end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
        if(end - start < temp) {
            Long sum = 0L;
            for (Long i = start; i < end; i++) {
                sum += i;
            }
            return sum;
        } else {
            Long middle = (start + end) / 2;
            ForkJoin task1 = new ForkJoin(start, middle);
            task1.fork(); // 拆分任务，把任务压入线程队列
            ForkJoin task2 = new ForkJoin(middle + 1, end);
            task2.fork();

            return task1.join() + task2.join();
        }
    }
}

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.stream.LongStream;

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        test1();
        test2();
        test3();
    }

    public static void test1() {
        long start = System.currentTimeMillis();
        Long sum = 0L;
        for (Long i = 1L; i < 10_0000_0000L; i++) {
            sum += i;
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
    public static void test2() throws ExecutionException, InterruptedException {
        long start = System.currentTimeMillis();

        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Long> task = new ForkJoin(0L, 10_0000_0000L);
        ForkJoinTask<Long> submit = forkJoinPool.submit(task);
        Long sum = submit.get();

        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
    public static void test3() {
        long start = System.currentTimeMillis();
        // stream并行流
        LongStream.rangeClosed(0L, 10_0000_0000L).parallel().reduce(0, Long::sum);
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}

10.异步回调

eg.Ajax

11.Volatile关键字

Volatile是Java虚拟机提供的轻量级的同步机制

• 保证可见性
• 不保证原子性
• 禁止指令重排

11.1 什么是JMM

JMM--java内存模型，是一种概念，约定。

关于JMM的一些同步的约定：

• 线程解锁前，必须把共享变量 立刻 刷回

• 线程加锁前，必须读取主存中的最新值到工作内存中

• 加锁和解锁是同一把锁

主存，工作内存

内存交互操作

　内存交互操作有8种，虚拟机实现必须保证每一个操作都是原子的，不可在分的（对于double和long类型的变量来说，load、store、read和write操作在某些平台上允许例外）

• lock （锁定）：作用于主内存的变量，把一个变量标识为线程独占状态

• unlock （解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定

• read （读取）：作用于主内存变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用

• load （载入）：作用于工作内存的变量，它把read操作从主存中变量放入工作内存中

• use （使用）：作用于工作内存中的变量，它把工作内存中的变量传输给执行引擎，每当虚拟机遇到一个需要使用到变量的值，就会使用到这个指令

• assign （赋值）：作用于工作内存中的变量，它把一个从执行引擎中接受到的值放入工作内存的变量副本中

• store （存储）：作用于主内存中的变量，它把一个从工作内存中一个变量的值传送到主内存中，以便后续的write使用

• write 　（写入）：作用于主内存中的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中

　JMM对这八种指令的使用，制定了如下规则：

• 不允许read和load、store和write操作之一单独出现。即使用了read必须load，使用了store必须write

• 不允许线程丢弃他最近的assign操作，即工作变量的数据改变了之后，必须告知主存

• 不允许一个线程将没有assign的数据从工作内存同步回主内存

• 一个新的变量必须在主内存中诞生，不允许工作内存直接使用一个未被初始化的变量。就是怼变量实施use、store操作之前，必须经过assign和load操作

• 一个变量同一时间只有一个线程能对其进行lock。多次lock后，必须执行相同次数的unlock才能解锁

• 如果对一个变量进行lock操作，会清空所有工作内存中此变量的值，在执行引擎使用这个变量前，必须重新load或assign操作初始化变量的值

• 如果一个变量没有被lock，就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量

• 对一个变量进行unlock操作之前，必须把此变量同步回主内存

问题：主内存的值发生了改变，工作的线程不知道？

11.2 volatile三大特性

可见性：

import java.util.concurrent.TimeUnit;

public class JMMDemo {
  	//不加volatile程序就会死循环
  	//保证可见性
    private volatile static int num = 0;
    public static void main(String[] args) throws InterruptedException {
         new Thread(()-> {
             while(num==0) {}
         }).start();

        TimeUnit.SECONDS.sleep(1);
        num = 1;
        System.out.println(num);
    }
}

不保证原子性：（原子性：不可分割，线程A执行任务不能被打扰，要么同时成功，要么同时失败）

加不加关键字，都每次结果不一样：

public class JMMDemo {
    private volatile static int num = 0;

    public static void add() {num++;}

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }

        while(Thread.activeCount() > 2) { // main gc
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() +" : "+num);
    }
}

如果不加lock和synchronized，怎么保证原子性：

javap -c class文件看底层：num++不是一个原子性操作

使用原子类，解决原子性问题，比lock等消耗资源小

private volatile static AtomicInteger num = new AtomicInteger();

public static void add() {num.getAndIncrement();} // +1方法，底层用CAS

这些类的底层直接和操作系统挂钩

禁止指令重排：

指令重排：计算机并不是按照写的代码进行执行

源代码--编译器优化的重排--指令并行也可能重排--内存系统也会重排--执行

int x = 1;
int y = 2;
x = x + 5;
y = x*x;

1234  2134 1324 
4123？no，考虑数据之间的依赖性

xy都等于0，但如果指令重排，xy的值就变了

虽然指令重排很少发生，但还是有可能的。

volatile利用如下特性：

内存屏障，cpu指令。作用：

• 保证特定操作的执行顺序
• 保证某些变量的内存可见性

11.3 单例模式

饿汉式 DCL懒汉式

构造器私有


如果不加DCL，每次新建的对象数量不一定

需要避免指令重排，使用volatile，如果132，下一个直接返回对象，但还是空的

通过反射还可以破坏单例模式

在构造器锁避免：

如果注释掉getinstance创建对象，直接new了两个对象，又破坏了

使用标志位：

但反射又能破坏私有变量...

解决：

enum本身也是一个Class类，规定enum不可以newinstance

12.CAS

什么是CAS：compareAndSet()方法，比较当前工作内存中的值和主内存的值，如果这个值是期望的，执行操作；如果不是一直循环，循环会耗时

getAndIncrement()也就是++操作

内存地址偏离值

Unsafe类

java无法操作内存，而是调用c++（native方法）来操作内存。unsafe类--java的后门，可以通过这个类操作内存

ABA问题：

解决ABA问题，使用原子引用

13.各种锁的理解

13.1 公平锁、非公平锁

公平锁： 不能插队

非公平锁（默认）：比如3h的线程和3s的线程

13.2 可重入锁（递归锁）

拿到外面的锁，自动拿到了内部的锁

13.3 自旋锁

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

public class SpinLock {
    AtomicReference<Thread> atomicReference = new AtomicReference<>();


    // 加锁
    public void myLock() {
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName() + "get");

        while(!atomicReference.compareAndSet(null, thread)){

        }
    }

    // 解锁
    public void myUnLock() {
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName());

        atomicReference.compareAndSet(thread, null);
    }
}

class Test{
    public static void main(String[] args) throws InterruptedException {
        SpinLock lock = new SpinLock();
        new Thread(()->{
            lock.myLock();
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.myUnLock();
            }
        }, "T1").start();

        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{
            lock.myLock();
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.myUnLock();
            }
        }, "T2").start();
    }
}

T1 T2(自旋) T1 T2

13.4 死锁

import java.util.concurrent.TimeUnit;

public class DeadLock {
    public static void main(String[] args) {
        String lockA = "lockA";
        String lockB = "lockB";
        new Thread(new MyThread(lockA, lockB), "T1").start();
        new Thread(new MyThread(lockB, lockA), "T2").start();
    }


}

class MyThread implements Runnable{
    private String lockA;
    private String lockB;

    public MyThread(String lockA, String lockB) {
        this.lockA = lockA;
        this.lockB = lockB;
    }

    @Override
    public void run() {
        synchronized (lockA) {
            System.out.println(Thread.currentThread().getName());

            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lockB) {
                System.out.println(Thread.currentThread().getName());
            }
        }
    }
}

解决问题：

1.使用jps -l 定位进程号

2.使用jstack 进程号 查看堆栈信息

排查问题：

日志

堆栈信息！

JavaSE：JUC并发编程

原文：https://www.cnblogs.com/xuzhangzhang/p/JavaSE5.html