JUC学习

什么是JUC

源码+官方文档

面试高频问

java.util 工具包，包，类

业务：普通的线程代码，thread

Runnable 没有返回值，效率相对于Callable相对较低！

线程和进程

进程：一个程序

一个进程至少包含一个线程

java默认两个线程，main，GC

线程：

对于java：Thread。Runnable，Callable

java可以开启线程么不可以

调用native方法，底层的C++，java无法直接操作硬件

并发并行

并发编程：并发并行

并发（多线程操作同一个资源）

cpu一核，模拟出来多条线程

并发（多个人一起行走）

cpu多核，多个线程可以同时执行；线程池

System.out.println(Runtime.getRuntime().availableProcessors());//获取cpu的核数
//cpu密集型
//io密集型

并发编程的本质：充分利用cpu的资源

线程有几个状态

state：

new（新生）
runnable（运行）
blocked（阻塞）
waiting（等待）
timed_waiting(超时等待)
terminated（终止）

wait/sleep区别

来自不同的类

wait---Object

sleep---Thread

企业里，不用sleep

TimeUnit.DAYS.sleep(1);
TimeUnit.DAYS.sleep(1);
TimeUnit.SECONDS.sleep(1);

关于锁的释放

wait会释放锁，sleep不释放锁

使用的范围不同

wait只能在同步代码块，sleep可以在任何地方

Lock锁

Synchronized

synchronized  本质：队列，锁

Lock

公平锁：队列先来后到

非公平锁：可以插队（默认）

Lock lock = new ReentrantLock();
lock.lock();
try{
    
}catch(Exception e){
    e.printStackTrace();
}finally{
    lock.unlock();
}

lock 三部曲

new ReentrantLock();
lock.lock();
lock.unlock();

Synchronized 与Lock区别

Synchronized是内置的关键字，Lock是一个java类
Synchronized无法判断获取锁的状态，Lock可以判断是否获取到了锁
Synchronized会自动给释放锁，Lock需要手动释放，如果不释放锁，死锁
Synchronized 会一直等待，Lock会尝试获取锁，设置超时
Synchronized 可重入锁，不可中断的，非公平，Lock 可重入锁，可以判断锁，非公平，公平，可以设置
Synchronized适合少量的代码同步问题，Lock适合大量的代码同步

生产者消费者问题

Synchronized版

面试：单例模式，排序算法，生产者和消费者，死锁

/**
 * 线程之间的通信问题，生产者和消费者问题；  等待唤醒，等待通知
 * 线程交替执行      A B 操作同一个变量   num=0
 * A num+1
 * B num-1
 */


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

//判断等待，业务，通知
class Data{
    private int num = 0;
    public synchronized void increment() throws InterruptedException {

        if(num!=0){
            this.wait();
        }
        num++;
        System.out.println(Thread.currentThread().getName()+"=>"+num);
        this.notify();
        //通知其他线程，我+1完毕了
    }
    public synchronized void decrement() throws InterruptedException {
        if(num==0){
            this.wait();
        }
        num--;
        System.out.println(Thread.currentThread().getName()+"=>"+num);
        //通知其他线程，我-1完毕了
        this.notify();
    }
}

问题：A,B,C,D多个线程

防止虚假唤醒，等待应该总是出现在循环中

if只判断了一次，应该if改为while判断

JUC版的生产者和消费者

通过lock找到Condition

Lock替换synchronized方法和语句的使用，Condition取代了对象监视器方法的使用


import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

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

//判断等待，业务，通知
class Data2{
    private int num = 0;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    public  void increment() throws InterruptedException {
        lock.lock();
        try {
            while (num != 0) {
                condition.await();
            }
            num++;
            System.out.println(Thread.currentThread().getName() + "=>" + num);
            condition.signalAll();
            //通知其他线程，我+1完毕了
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            lock.unlock();
        }
    }
    public void decrement() throws InterruptedException {
        lock.lock();
        
        try {
            while (num == 0) {
                condition.await();
            }
            num--;
            System.out.println(Thread.currentThread().getName() + "=>" + num);
            //通知其他线程，我-1完毕了
            condition.signalAll();
        }catch(Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

}

condition

精准的通知和作用

设置多个condition监视器，精准通知执行



/**
 * A执行完调用B，B执行完调用C，C执行完调用A
 */


import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class C {



    public static void main(String[] args) {
        Data3 data3 = new Data3();
        new Thread(()->{for(int i=0;i<10;i++)data3.printA();},"A").start();
        new Thread(()->{for(int i=0;i<10;i++)data3.printB();},"B").start();
        new Thread(()->{for(int i=0;i<10;i++)data3.printC();},"C").start();

    }
}

class Data3{
    private Lock lock = new ReentrantLock();
    private Condition condition1  = lock.newCondition();
    private Condition condition2  = lock.newCondition();
    private Condition condition3  = lock.newCondition();
    private int num =1;
    public void printA(){
        lock.lock();
        try{
            //业务，判断，执行，通知
            while(num!=1)
                condition1.await();
            System.out.println(Thread.currentThread().getName()+"=》AAAAA");
            num = 2;
            //唤醒指定的人
            condition2.signal();
        }
        catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }
    public void printB(){
        lock.lock();
        try{
            //业务，判断，执行，通知
            while(num!=2)
                condition2.await();
            System.out.println(Thread.currentThread().getName()+"=》BBBBB");
            num = 3;
            //唤醒指定的人
            condition3.signal();
        }
        catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }
    public void printC(){
        lock.lock();
        try{
            //业务，判断，执行，通知
            while(num!=3)
                condition3.await();
            System.out.println(Thread.currentThread().getName()+"=》CCCCC");
            num = 1;
            //唤醒指定的人
            condition1.signal();
        }
        catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }
}

锁对象

synchronized锁的对象是方法的调用者，谁先拿到谁执行

static synchronized 锁的是类，与锁的普通方法不是一个锁

集合类不安全

//java.util.ConcurrentModificationException 并发修改异常

并发下集合不安全

list不安全

//解决方案
List<String> list1 = new Vector<>();
List<String> list2 = Collections.synchronizedList(new ArrayList<>());
List<String> list3 = new CopyOnWriteArrayList<>();
//copyonwrite 写入时复制，COW  计算机程序设计领域的一种优化
//多个线程调用的时候，list，读取的时候，固定的，写入（覆盖）
//在写入的时候避免覆盖，造成数据问题
//读写分离

set不安全

Set<String> set = new HashSet<>();
Set<String> set1 = Collections.synchronizedSet(new HashSet<>());
Set<String> set2 =new  CopyOnWriteArraySet<>();
//解决方案

HashSet 底层就是HashMap

public HashSet(){
    map = new HashMap<>();
}

//add set本质就是map   key是无法重复的
public boolean add(E e){
    return map.put(e,PRESENT)==null;
}
private static final Object PRESENT = new Object();//不变的值

Map不安全

ConcurrentHashMap

走进callable

callable接口类似于runnable，因为他们都是为其实例可能由另一个线程执行的类设计的，然而，runnable不返回结果，也不能抛出被检查的异常

Callable

可以有返回值
可以抛出异常
方法不同，run/call

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
//探究原理
//FutureTask是Runnable的实现类
public class CallableTest {


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

        MyThread myThread = new MyThread();
        FutureTask futureTask = new FutureTask<>(myThread);//适配类
        new Thread(futureTask,"A").start();
        new Thread(futureTask,"B").start();//结果会被缓存，只打印一次
        String str = (String) futureTask.get();//获取Callable的返回结果，get可能会阻塞，把他放到最后，或者使用异步通信
		System.out.println(str)
    }
}

class MyThread implements Callable<String>{
    @Override
    public String call() throws Exception {
        System.out.println("Call!");
        return "656562";
    }
}

有缓存
结果可能需要等待，阻塞

常用的辅助类

CountDownLatch

允许一个或多个线程等待直到在其他线程中执行的一组操作完成的同步辅助

import java.util.concurrent.CountDownLatch;

//计数器
public class CountDownLatchDemo {


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

        //总数是6，必须要执行任务的时候，再使用
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 0; i < 6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"Go out");
                countDownLatch.countDown();},String.valueOf(i)).start();
        }
        countDownLatch.await();//等待计数器归0，然后再向下进行
        System.out.println("关门");
    }
}
countDownLatch.countDown();//减一
countDownLatch.await();//等待清0，唤醒继续执行

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 < 7; i++) {
            //lambda 能操作到i么
            final int temp = i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"收集"+temp+"颗龙珠");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

Semaphore

一个计数信号量，在概念上，信号量维持一组许可证，如果有必要，每个acquire（）都会阻塞，直道许可证可用，然后才能使用它

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(()->{
                //acquire() 得到
                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();//将当前信号量+1，然后唤醒
                }
                

                //release() 释放
            },String.valueOf(i)).start();
        }
    }
}

读写锁

ReentranReadWriteLock

读可以被多线程同时读

写的时候只能一个线程去写


import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockDemo {

    public static void main(String[] args) {
        /**
         * 自定义缓存
         */

        /**独占锁
         * 共享锁
         * 读-读  可以共存
         * 读-写  不能共存
         * 写-写  不能共存
         */
        MyCache2 myCache = new MyCache2();

        //写入
        for (int i = 0; i < 5; i++) {
            final int temp = i;
            new Thread(()->{
                myCache.put(temp+"",temp+"");
            },String.valueOf(i)).start();
        }
        //读取
        for (int i = 0; i < 5; i++) {
            final int temp = i;
            new Thread(()->{
                myCache.get(temp+"");
            },String.valueOf(i)).start();
        }



    }

}
class MyCache{
    private volatile Map<String,Object> map= new HashMap<>();
    //存
    public void put(String key,Object value){
        System.out.println(Thread.currentThread().getName()+"写入"+key);
        map.put(key,value);
        System.out.println(Thread.currentThread().getName()+"写入完毕");
    }
    //取
    public void get(String key){
        System.out.println(Thread.currentThread().getName()+"读取"+key);
        Object o = map.get(key);
        System.out.println(Thread.currentThread().getName()+"读取完毕");
    }

}

class MyCache2{
    private ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
    private ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock();
    private ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();
    private volatile Map<String,Object> map= new HashMap<>();
    //存
    public void put(String key,Object value){
        writeLock.lock();
        try{
            System.out.println(Thread.currentThread().getName()+"写入"+key);
            map.put(key,value);
            System.out.println(Thread.currentThread().getName()+"写入完毕");
        }
        catch(Exception e){
            e.printStackTrace();
        }finally {
            writeLock.unlock();
        }

    }
    //取
    public void get(String key){
        readLock.lock();

        try {
            System.out.println(Thread.currentThread().getName()+"读取"+key);
            Object o = map.get(key);
            System.out.println(Thread.currentThread().getName()+"读取完毕");
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            readLock.unlock();;
        }

    }

}

阻塞队列BlockingQueue

写入：如果队列满了，就必须阻塞等待

取：如果是队列是空的，必须阻塞等待生产

阻塞队列：

什么情况下会使用阻塞队列

添加，移除

四组API

抛出异常
不抛出异常
阻塞等待

超时等待

ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);

	抛出异常	有返回值，不抛出异常	阻塞等待	超时等待
添加	add	offer	put	offer("f",1,TimeUnit.SECONDS)
移除	remove	poll	take	poll(1,TimeUnit.SECONDS)
判断队列首	element	peek

同步队列SynchronusQueue

没有容量

进去一个元素，必须等待取出之后才能操作

BlockingQueue<Object> objects = new SynchronousQueue<>();
put()
take()

线程池

池化技术

程序的运行，本质：占用系统的资源，优化资源的使用！=》池化技术

线程池，连接池，内存池，对象池

池化技术：实现准备号一些资源，有人要用，就来拿，拿完之后还

线程池的好处

降低资源的消耗
提高响应的速度
方便管理

线程复用，可以控制最大并发数，管理线程

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }
//本质
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.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

四种拒绝策略

new ThreadPoolExecutor.CallerRunsPolicy();//哪来的回哪儿去
new ThreadPoolExecutor.DiscardOldestPolicy();//队列满了，尝试和最早的结束，失败丢弃不抛出异常
new ThreadPoolExecutor.DiscardPolicy();//丢弃，不抛出异常
new ThreadPoolExecutor.AbortPolicy());//抛出异常，一种拒绝策略

import java.util.concurrent.*;

public class Test {


    public static void main(String[] args) {
            //自定义线程池~工作中ThreadPoolExcutor
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                2,
                5,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());//抛出异常，一种拒绝策略

        try {
            for (int i = 0; i < 9; i++) {
                threadPoolExecutor.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"ok");
                });
            }
        } finally {
        threadPoolExecutor.shutdown();
        }
        //线程池用完关闭
    }



}

最大线程应该如何定义

cpu密集型，几核，就是几，可以保证cpu的效率最高

System.out.println(Runtime.getRuntime().availableProcessors());//获取cpu的核数

IO密集型，IO十分占用资源，判断十分耗IO资源的线程，大于这个线程数，一般为2倍（调优）

四大函数式接口（必须掌握）

新时代的程序员：lambda表达式/链式编程/函数式接口/Stream流式计算

函数式接口：只有一个方法的接口

Runnable

@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface {@code Runnable} is used
     * to create a thread, starting the thread causes the object's
     * {@code run} method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method {@code run} is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}
//超级多FunctionalInterface
//简化编程模型，在新版本的框架底层大量应用
//foreach（消费者类型的函数式接口）

Function接口

import java.util.Arrays;
import java.util.List;
import java.util.function.Function;

public class Test {

    /**
     *
     * Funciton 函数型接口  有一个输入参数，有一个输出
     * 只要是函数型接口，可以用lambda表达式简化
     */
    public static void main(String[] args) {

        List<String> list = Arrays.asList("2","3","4");
        list.forEach(System.out::println);

        //工具类，输出输入的值
        Function<String,String> function = new Function<String,String>() {
            @Override
            public String apply(String str) {
                return str;
            }
        };
        Function<String,String> function1 = (str)->{return str;}
    }

}

Predicate断定型接口返回值是布尔型

import java.util.function.Predicate;

public class Test {

    /**
     *
     * Predicate 断定型接口  有一个输入参数，有一个输出
     * 只要是函数型接口，可以用lambda表达式简化
     */
    public static void main(String[] args) {


        //判断字符串是否为空

        Predicate<String> predicate = new Predicate<>() {
            @Override
            public boolean test(String o) {
                return o.isEmpty();
            }
        };
        Predicate<String> predicate1 = (str)->{
            return str.isEmpty();
        }
        
        System.out.println(predicate.test("gg"));

    }

}

Consumer消费型接口

import java.util.function.Consumer;

public class Test {

    /**
     *
     * Consumer 消费型接口  只有输入，没有返回
     * 只要是函数型接口，可以用lambda表达式简化
     */
    public static void main(String[] args) {


        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String o) {
                System.out.println(o);
            }
        };

        Consumer<String> consumer1 = (str)->{
            System.out.println(str);
        };
        consumer.accept("gg");
        consumer1.accept("gg");
    }

}

Supplier供给型接口

import java.util.function.Supplier;

public class Test {

    /**
     *
     * Supplier 供给型接口  没有参数，只有返回值
     * 只要是函数型接口，可以用lambda表达式简化
     */
    public static void main(String[] args) {


        Supplier<String> supplier = new Supplier<String>() {
            @Override
            public String get() {
                System.out.println("get()");
                return "1024";
            }
        };
        Supplier supplier1 = ()->{
            return "1024";
        };
        System.out.println(supplier.get());
    }

}

Stream流式计算

什么式Stream流式计算

大数据：存储+计算

集合，MySQL本质就是存储东西的

计算都应该交给流来计算

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

public class Test {

    /**
     * 题目要求，一分钟内完成此题，只能用一行代码实现
     * 现在有5个用户，筛选
     * 1.ID必须是偶数
     * 2.年龄必须大于23岁
     * 3.用户名转为大写字母
     * 4.用户名字母倒着排序
     * 5.只输出一个用户
     *
     *
     */
    public static void main(String[] args) {

        User user1 = new User(1, "a", 21);
        User user2 = new User(2,"b",22);
        User user3 = new User(3,"c",23);
        User user4 = new User(4,"d",24);
        User user5 = new User(6,"e",25);

        List<User> users = Arrays.asList(user1, user2, user3, user4, user5);
        //集合用来存储，
        // 计算交给Stream
        //lambda表达式，链式编程，函数式接口，Stream流式计算

        users.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);
    }

}

ForkJoin

分支合并

ForkJoin 在JDK1.7，并行执行任务，提高效率吗，大数据量！

大数据：Map Reduce （大任务拆分为小任务）

ForkJoin特点：工作窃取

这个里面维护的都是双端队列

import java.util.concurrent.RecursiveTask;

public class Test extends RecursiveTask<Long> {

    /**
     * 求和计算的任务
     *
     * 初级 for 循环
     * 中级ForkJoin
     * 高级Stream并行流
     *如何使用ForkJoin
     * 1.ForkJoinPool
     * 2.计算任务  forkjoinpool.execute(ForkJoin Task)
     * 3.计算类要继承 forkjointask
     */

    private long start;//1
    private long end;//1990900000
    private long temp = 10000L;

    public Test(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;//中间值
            Test test1 = new Test(start, middle);
            test1.fork();//拆分任务，把任务压入线程队列
            Test test2 = new Test(middle+1, end);
            test2.fork();
            return test1.join()+test2.join();
        }

    }
}


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

public class ForkTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
       // test1();//8225
      //  test2();//392
        test3();//238
    }
    public static void test1(){
        Long sum = 0l;
        long start = System.currentTimeMillis();

        for (Long i = 0l; i < 10_0000_0000l; i++) {
            sum+=i;

        }


        long end = System.currentTimeMillis();
        System.out.println("sum="+sum+"时间："+(end-start));
    }

//会使用forkjoin
    public static void test2() throws ExecutionException, InterruptedException {
        long start = System.currentTimeMillis();
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Long> forkJoinTask = new Test(0l,10_0000_0000l);
        ForkJoinTask<Long> submit = forkJoinPool.submit(forkJoinTask);
        Long sum = submit.get();
        long end = System.currentTimeMillis();
        System.out.println("sum="+sum+"时间："+(end-start));
    }




    public static void test3(){
        long start = System.currentTimeMillis();

        //Stream并行流

        long reduce = LongStream.rangeClosed(0L, 10_0000_0000L).parallel().reduce(0, Long::sum);
        long end = System.currentTimeMillis();
        System.out.println("sum="+reduce+"时间："+(end-start));
    }
}

异步回调

Future设计的初衷：对将来的某个事件的结果进行建模

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class Test {

    /**
     * 异步调用  Ajax
     */

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //发起一个请求

//没有返回值的异步回调
       /* CompletableFuture<Void> voidCompletableFuture = CompletableFuture.runAsync(() -> {


            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"runAsync");
        });*/


        //有返回值的异步回调 supplyAsync
        //ajax 成功和返回的回调
        //返回的是错误信息
        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread().getName()+"supplyAsync=>Integer");
            return "1024";
        });

        System.out.println(completableFuture.whenComplete((t, u) -> {
            System.out.println("t=>" + t);//正常的返回结果
            System.out.println("u=>" + u);//错误的 信息，获取到错误的返回结果
        }).exceptionally((e)->{
            e.printStackTrace();
            return "false";
        }).get());

    }
}

JMM

请你谈谈对Votatile

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

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

JMM

Java内存模型，不存在的东西，概念，约定

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

线程解锁前，必须把共享变量立刻刷回主存
线程加锁前，必须读取主存中的最新值到工作内存中
加锁和解锁是同一把锁

线程工作内存，主内存

线程b修改了共享值，线程a对该值不可见

内存交互操作

　内存交互操作有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操作之前，必须把此变量同步回主内存

Volatile

保证可见性

import java.util.concurrent.TimeUnit;

public class Test {
//不加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);


    }
}

不保证原子性

public class Test {

    private volatile static int num=0;

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


        //理论上num结果应该为20000
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                for (int i1 = 0; i1 < 1000; i1++) {
                    add();
                }

            }).start();
        }

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


    }

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

原子性：不可分割

num++

读，加一，写

不是原子操作

不加lock和Synchronized怎样保证原子性

使用原子类解决原子性问题

import java.util.concurrent.atomic.AtomicInteger;

public class Test {

    //volatile不保证原子性
    //原子类
    private  static AtomicInteger num=new AtomicInteger();

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


        //理论上num结果应该为20000
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                for (int i1 = 0; i1 < 1000; i1++) {
                    add();
                }

            }).start();
        }

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


    }

    public static void add(){
        //num++;  不是原子操作
        num.getAndIncrement();//加1方法    CAS方法
    }
}

原子类为什么能解决

这些类的底层都直接和操作系统挂钩，在内存中修改值Unsafe类是一个很特殊的存在

指令重排

你写的程序闭关不是按照你写的那样去执行

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

处理器在进行指令重排的时候，考虑：数据之间的依赖性

int x=1;
int y=2;
x = x+5;
y = x+x;
我们所期望的： 1234    执行的时候 可能会是2134    1324
可不可能  4123

可能造成影响的结果：a b x y 这四个默认值都是0

线程A	线程B
x=a	y=b
b=1	a=2

正常的结果：x=0,y=0,但是可能由于指令重排

线程A	线程B
b=1	a=2
x=a	y=b

指令重排的诡异结果：x=2,y=1

volatile可以避免指令重排

内存屏障，CPU指令，作用：

保证特定的操作的执行
可以保证某些变量的内存可见性（利用这些特性，就可以保证volatile实现了可见性）

内存屏障：

禁止上面指令和下面指令顺序交换

在volatile写的前后都增加一个屏障

单例模式

饿汉式

//饿汉式单例
public class Hungry {
    private Hungry(){
    }
    private final static Hungry hungry = new Hungry();
    public static Hungry getInsance(){
        return hungry;
    }
}

懒汉式

//懒汉式单例
public class Lazy {
    private Lazy(){
        System.out.println(Thread.currentThread().getName()+"ok");
    }
    private static Lazy lazy;



    //双重检测锁模式的，懒汉式单例，DCL懒汉式
    public static Lazy getInstance(){
        if(lazy==null){
            synchronized (Lazy.class) {
                if (lazy==null) {
                    lazy = new Lazy();//不是原子性操作，也会出现问题
                }
            }
        }
        return lazy;
    }

//多线程并发
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                Lazy.getInstance();
            }).start();
        }
    }
}

加volatile禁止指令重排

//懒汉式单例
public class Lazy {

	private static boolean flag = false;//还是会被反射破坏
    private Lazy(){
    	
    	synchronized(Lazy.class)
    	{
    	if (flag==false){
    	flag=true;
    	}
    	else
    	{
    	thow new RuntimeException("不要试图使用反射破坏异常");
    	   }
    	}  
    }
    private volatile static Lazy lazy;



    //双重检测锁模式的，懒汉式单例，DCL懒汉式
    public static Lazy getInstance(){
        if(lazy==null){
            synchronized (Lazy.class) {
                if (lazy==null) {
                    lazy = new Lazy();//不是原子性操作，也会出现问题
                    /**
                     * 1分配内存空间
                     * 2执行构造方法，初始化对象
                     * 3把这个对象指向这个空间
                     * 
                     * 正常123
                     * 异常132      指向为null
                     * 
                     * 解决 ，加volatile禁止指令重排
                     */
                }
            }
        }
        return lazy;
    }

//多线程并发
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                Lazy.getInstance();
            }).start();
        }
    }
}

静态内部类

//静态内部类

public class Holder {
    private Holder(){

    }

    public static Holder getInstance(){
        return InnerClass.holder;
    }
    public static class InnerClass{
        private static final Holder holder = new Holder();
    }

}

枚举

有参构造

//enum是什么，本身也是一个Class 类
public enum EnumClass {


    INSATANCE;

    public EnumClass getInsatance(){
        return INSATANCE;
    }
}

class Test{


    public static void main(String[] args) {
        EnumClass insatance1 = EnumClass.INSATANCE;
        EnumClass insatance2 = EnumClass.INSATANCE;
        System.out.println(insatance1);
        System.out.println(insatance2);


    }
}

深入理解CAS

什么是CAS

大厂必须深入研究底层有所突破

import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo {



    //CAS  compareAndSet   比较并交换

    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(1);

        //public final boolean compareAndSet(int expectedValue, int newValue)
        //期望 更新
        //期望值达到了就更新，否则就不更新  CAS是CPU的并发原语
        //Java无法操作内存
        //Java可以调用C++，Native
        //C++可以操作内存
        //Java的后门，可以通过这个类操作
        //设计到自旋锁
        atomicInteger.compareAndSet(1,2021);
        System.out.println(atomicInteger.get());

        atomicInteger.compareAndSet(1,2021);
        System.out.println(atomicInteger.get());
    }
}

CAS：比较当前工作内存中的值和主内存中的值，如果这个值的是期望的，那么则执行操作，否则循环，自旋锁

缺点：

循环耗时
一次性只能保证一个共享变量的原子性
ABA问题

ABA问题（狸猫换太子）

原子引用解决ABA问题

带版本号的原子操作

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

public class CASDemo {



    //CAS  compareAndSet   比较并交换

    public static void main(String[] args) {
        //如果泛型是包装类，注意对象的引用问题
        AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference(1,1);
        new Thread(()->{
        int stamp = atomicStampedReference.getStamp();//获得版本号
            System.out.println("a1=>"+stamp);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            atomicStampedReference.compareAndSet(1,2,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println("a2=>"+atomicStampedReference.getStamp());
            atomicStampedReference.compareAndSet(2,1,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println("a3=>"+atomicStampedReference.getStamp());
            },"A").start();



        new Thread(()->{
            int stamp = atomicStampedReference.getStamp();//获得版本号
            System.out.println("b1=>"+stamp);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            atomicStampedReference.compareAndSet(1,6,stamp,atomicStampedReference.getStamp()+1);
            System.out.println("b2=>"+atomicStampedReference.getStamp());
        },"B").start();
    }
}

可重入锁

各种锁的理解

公平锁，非公平锁

公平锁：非常公平，不能够插队，必须先来后到

非公平锁：非常不公平，可以插队，默认是非公平锁

public ReentrantLock() {
    sync = new NonfairSync();
}

Lock lock1 = new ReentrantLock(true);

可以修改

可重入锁

lock.lock();//细节问题，lock.lock();lock.unlock()
//一个锁必须配对，否则就会死在里面

Synchronized也是可重入锁

自旋锁

自定义锁测试

import java.util.concurrent.atomic.AtomicReference;

/**
 * 自旋锁
 */
public class SpinLock {


    AtomicReference atomicReference = new AtomicReference();
    public void mylock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"--> mylock");
        while (!atomicReference.compareAndSet(null,thread)){

        };
    }


    public void myunlock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"--> mylock");
        while (!atomicReference.compareAndSet(thread,null)){

        };
    }


}

import java.util.concurrent.TimeUnit;

public class Test {
    public static void main(String[] args) {
        SpinLock lock = new SpinLock();




        new Thread(()->{
            lock.mylock();
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch(Exception e){
                e.printStackTrace();
            }finally {
                lock.myunlock();
            }

        },"A").start();

        new Thread(()->{
            lock.mylock();
            try {
               TimeUnit.SECONDS.sleep(1);
            } catch (Exception e){
                e.printStackTrace();
            }finally {
                lock.myunlock();
            }

        },"B").start();
    }
}

死锁

死锁测试：

import lombok.SneakyThrows;

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;
    }

    @SneakyThrows
    @Override
    public void run() {
        synchronized (lockA){
            System.out.println(Thread.currentThread().getName()+"lock:"+lockA+"->get"+lockB);
            TimeUnit.SECONDS.sleep(2);
            synchronized (lockB){
                System.out.println(Thread.currentThread().getName()+"lock:"+lockB+"->get"+lockA);
                TimeUnit.SECONDS.sleep(2);
            }
        }
    }

1.使用jps定位进程号

2.使用jstack进程号找到死锁问题

面试，工作中，排查问题

日志
堆栈

posted @ 2020-09-28 20:39 yourText 阅读(196) 评论(0) 编辑收藏举报

刷新页面返回顶部

yourText

这个世界有70亿人，总有人愿意为你爬上月亮

JUC学习

什么是JUC

线程和进程

并发并行

线程有几个状态

wait/sleep区别

Lock锁

Synchronized

Lock

生产者消费者问题

Synchronized版

JUC版的生产者和消费者

condition

锁对象

集合类不安全

list不安全

set不安全

Map不安全

走进callable

常用的辅助类

CountDownLatch

CyclicBarrier

Semaphore

读写锁

阻塞队列BlockingQueue

同步队列SynchronusQueue

线程池

最大线程应该如何定义

四大函数式接口（必须掌握）

函数式接口：只有一个方法的接口

Function接口

Predicate断定型接口 返回值是布尔型

Consumer消费型接口

Supplier供给型接口

Stream流式计算

ForkJoin

异步回调

JMM

JMM

内存交互操作

Volatile

单例模式

饿汉式

懒汉式

静态内部类

枚举

深入理解CAS

原子引用解决ABA问题

可重入锁

公平锁，非公平锁

可重入锁

自旋锁

死锁

公告

Predicate断定型接口返回值是布尔型