JUC学习！
1、what？
JUC就是java.util.concurrent下面的类包，专门用于多线程的开发。
2、why？
解决多线程、高并发
3、how？
||
||
﹀
question1:多个线程共享资源时，彼此不可见； 可以给资源加锁，但是加锁，线程会阻塞，效率较低；如何在不使用锁的情况下，更新资源，即给资源加上volatile关键字。
point2：原子性
原子变量：Java提供了原子变量，在java.util.concurrent.atomic包下； 使用CAS(Compare And Swap)来保证原子性；当内存值==预估值时，我才会把更新值更新到内存。但此时会出现一个ABA问题，即一个线程修改变量A，为B再改回A，此时CAS察觉不到，被修改了，当然基本数据类型是不要紧的，但如果是引用数据呢？这个对象中有多个变量，我不知道有没有被修改。因此，增加版本号就成了一个很好的选择；
point3:锁分段机制
在java.util.concurrent包中提供了多种并发容器类来改进同步容器类的性能。其中最主要的就是ConcurrentHashMap。 ConcurrentHashMap采用了分段锁机制，是一个线程安全的hash表，我们知道HashMap不是线程安全的，HashTable加了锁，是线程安全的，因此他效率低。而ConcurrentHashMap默认分成了16个segment，每个segment对应一个hash表，且有自己独立的锁。所以每一个线程访问一个segment，就可以并行访问了，这大大的提高了效率；
point4:锁
1、传统锁synchronized关键字：
a、锁代码块、锁类； b、当这个关键字锁到一个带有static的方法时，锁的是这个类模板。
class X{ public Synchronized void f(){ methods body... } }
2、Lock接口：
是在juc包下的，首先要声明一个可重入锁； 有三个实现类：ReentrantLock（可重入锁 常用）、 ReentrantReadWriteLock.ReadLock(读锁)、ReentrantReadWriteLock.WriteLock（写锁）
class X{ Lock lock = new ReentrantLock(); public void f(){ lock.lock; try{ method body..... }finally{ lock.unlock; } } }
1、公平锁：十分公平，先来后到；
2、非公平锁：十分不公平，可以插队(默认)；
3.lock与Synchronized的区别
>1、Synchronized是内置关键字；Lock是接口；
>2、Synchronized无法判断获取锁的状态；Lock可以判断；
>3、Synchronized会自动释放锁;Lock需要手动释放，不释放会出现死锁现象；
>4、Synchronized（当a线程获取锁并阻塞，b线程会一直等）；Lock不会这样（tryLock（）方法，当目前可以获取锁时返回true，反之false）
>5、Synchronized是可重入锁、不可中断、非公平锁；Lock可重入、可判断锁、公平性（可以自定义），扩展性更好；
>6、Synchronized可以锁少量同步代码；Lock可以锁大量的同步代码；
4、锁的类型
可重入锁：拿到外面的锁后，会自动拿到里面的锁；
自旋锁：
point5:生产者和消费者问题
1、线程之间通信问题：生产者和消费者问题！
2、三部曲：判断是否需要等待 this.wait() 、业务、通知 this.notifyAll()
3、线程的虚假唤醒问题，将if()改为while()判断；
Condition condition = lock.newCondition();
condition.await();//等待
condition.signal()；//通知
Condition实现精确通知
Condition condition1 = lock1.newCondition();
Condition condition2 = lock2.newCondition();
Condition condition3 = lock3.newCondition();
例子：当前condition1，要通知condition3，则要condition3.signal();
point6:8锁现象
1、多个线程使用同一个对象，多个线程就是使用一把锁，先调用的先执行！
2、多个线程使用同一个对象，多个线程就是使用一把锁，先调用的先执行,即使在某方法中设置了阻塞。
3、多个线程，有的线程有锁，有的线程没锁，两者之间不存在竞争同一把锁的情况，先后执行顺序是随机的。
4、a被 synchronized 修饰的方法，锁的对象是方法的调用者；b调用者不同，它们之间用的不是同一个锁，相互之间没有关系。
5、被 synchronized 和 static 同时修饰的方法，锁的对象是类的 class 对象，是唯一的一把锁。线程之间是顺序执行。
锁Class和锁对象的区别：
a、Class 锁 ，类模版，只有一个；
b、对象锁 ， 通过类模板可以new 多个对象。
6、被 synchronized 修饰 和 static 修饰的方法，锁的对象是类的 class 对象，是唯一的一把锁。
Class锁是唯一的，所以多个对象使用的也是同一个Class锁。
如果全部都锁了Class，那么这个类下的所有对象都具有同一把锁。
7、被 synchronized和static修饰的方法，锁的对象是类的class对象！唯一的同一把锁；
只被synchronized修饰的方法，是普通锁（如对象锁），不是Class锁，所以进程之间执行顺序互不干扰。
解释见：https://blog.csdn.net/makyan/article/details/104524725
point7:集合不安全
异常：ConcurrentModificationException，并发修改异常；
解决方案:
List<String> list =new ArrayList<String>();
1、List<String> list = new Vector(); --->被synchronized修饰的方法效率很低；
2、List<String> list = Collections.syncronizedList(new ArrayList<>());
3、List<String> list = new CopyOnWriteArrayList<>();
Set<String> set = new HashSet<>()；
1、Set<String> set = Collections.synchroniazedSet(new HashSet<>());
2、Set<String> set = new CopyOnWriteArraySet<>(); HashSet本质就是用了HashMap的key不重复来实现去重的；
Map<String,String> map = new HashMap<>();
1、Map<String,String> map = Collections.synchronizedMap<>();
2、Map<String,String>map = new ConcurrentHashMap<>();--->详情见point3
point8:Callable与Runable
先看一下两个接口的定义：
Callable
public interface Callable<V> {
V call() throws Exception;
}
Runnable
interface Runnable {
public abstract void run();
}
和明显能看到区别：
1.Callable能接受一个泛型，然后在call方法中返回一个这个类型的值。而Runnable的run方法没有返回值
2.Callable的call方法可以抛出异常，而Runnable的run方法不会抛出异常。
point9:常用辅助类
1、CountDownLatch 减法计数器
CountDownLatch count=new CountDownLatch(5); for (int i = 1; i <=5 ; i++) { new Thread(()->{ System.out.println(Thread.currentThread().getName()+"go out"); count.countDown();//count-- },String.valueOf(i)).start(); } count.await();//等待计数器归零，然后向下执行 System.out.println("over");
2、CyclicBarrier 加法计数器（集齐七龙珠召唤神龙）
CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()-> System.out.println("召唤神龙")); for (int i = 1; i <=7 ; 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(); } },String.valueOf(i)).start(); }
3、Semaphore 流量
停车位，限流；三个车位，六辆车；
//有3个停车位，有六辆车 Semaphore semaphore = new Semaphore(3); for (int i = 1; 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(); }
point10:读写锁
ReentrantReadWriteLock 看一下jdk源码：
point11:阻塞队列BlockingQueue
1、使用情况：
2、四种API：
| 方法 | 抛出异常 | 有返回值，不抛异常 | 阻塞等待 | 超时等待 |
|---|---|---|---|---|
| 添加 | add() | offer() | put | offer(Object o,Long timeout,TimeUnit t) |
| 移除 | remove() | poll() | take | poll(Long timeout,TimeUnit t) |
| 检测队首 | element() | peek |
/** * 抛出异常 */ public static void test1(){ ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue(3); System.out.println(arrayBlockingQueue.add("a")); System.out.println(arrayBlockingQueue.add("b")); System.out.println(arrayBlockingQueue.add("c")); //检查队首元素 System.out.println(arrayBlockingQueue.element()); System.out.println("================="); System.out.println(arrayBlockingQueue.remove()); System.out.println(arrayBlockingQueue.remove()); System.out.println(arrayBlockingQueue.remove()); }
/** * 有返回值，不抛出异常 */ public static void test2(){ ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(3); System.out.println(blockingQueue.offer("a")); System.out.println(blockingQueue.offer("b")); System.out.println(blockingQueue.offer("c")); System.out.println(blockingQueue.offer("c")); //查看队首元素 System.out.println(blockingQueue.peek()); System.out.println("======================="); System.out.println(blockingQueue.poll()); System.out.println(blockingQueue.poll()); System.out.println(blockingQueue.poll()); System.out.println(blockingQueue.poll()); }
/** * 阻塞等待 */ public static void test3(){ ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(3); try { blockingQueue.put("a"); blockingQueue.put("b"); blockingQueue.put("c"); System.out.println("==="); blockingQueue.take(); blockingQueue.take(); blockingQueue.take(); } catch (InterruptedException e) { e.printStackTrace(); } }
/** * 超时等待 */ public static void test4(){ ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(3); try { System.out.println(blockingQueue.offer("a", 2, TimeUnit.SECONDS)); System.out.println(blockingQueue.offer("a", 2, TimeUnit.SECONDS)); System.out.println(blockingQueue.offer("a", 2, TimeUnit.SECONDS)); System.out.println(blockingQueue.offer("a", 2, TimeUnit.SECONDS)); System.out.println("===================="); System.out.println(blockingQueue.poll(2, TimeUnit.SECONDS)); System.out.println(blockingQueue.poll(2, TimeUnit.SECONDS)); System.out.println(blockingQueue.poll(2, TimeUnit.SECONDS)); } catch (InterruptedException e) { e.printStackTrace(); } }
point12:SynchronousQueue同步队列
同步队列和阻塞队列不同，同步队列不存储元素； 往里面put一个元素，必须要先take取出来；
point13：线程池（重点）
1、为什么要用线程池？线程池的好处？
>a、降低资源的消耗，不用频繁的创先销毁线程； >b、提高响应速度 >c、方便管理
2、三大方法、七大参数、四种拒绝策略
A、三大方法
//不要使用Executors工具类来创建线程池，用最原生的ThreadPoolExecutor； ExecutorService threadPool= Executors.newSingleThreadExecutor();//单个线程 ExecutorService threadPool1=Executors.newFixedThreadPool(5);//固定线程 ExecutorService threadPool2= Executors.newCachedThreadPool();//可变线程，遇强则强，遇弱则弱； try{ for(int i=0;i<10;i++){ //使用线程池创建线程 threadPool.execute(()->{ System.out.println(Thread.currentThread().getName()+"OK")； }) } }finally{ threadPool.shoutdown();//线程池用完，程序关闭，最后关闭线程池 }
B、七大参数
ThreadPoolExecutor
public ThreadPoolExecutor(int corePoolSize,//核心线程数 int maximumPoolSize,//允许最大线程数 long keepAliveTime,//当线程数大于核心线程数时，这就是多余空闲线程的存活时间 TimeUnit unit,//时间单位 BlockingQueue<Runnable> workQueue,//在执行任务之前用于保留任务的队列。 此队列将仅保存execute方法提交的Runnable任务 ThreadFactory threadFactory,//执行过程中创建新的线程所需要的工厂 RejectedExecutionHandler handler//拒绝策略，当线程满了、阻塞队列也满了时会执行的策略 )
C、4种拒绝策略RejectedExecutionHandler：
new ThreadPoolExecutor.AbortPolicy();//银行满了，还有人进来，不处理，抛异常； new ThreadPoolExecutor.CallerRunsPolicy();//哪里来的回哪里 new ThreadPoolExecutor.DiscardOldestPolicy();//队列满了尝试和最早的竞争，不会抛出异常； new ThreadPoolExecutor.DiscardPolicy();//队列满了丢掉任务，不会抛异常；
3、最大线程怎么定义（调优）
A、CPU密集型 获取当前CPU的核数：Runtime.getRuntime().availableProcessors() 最大线程==当前CPU核数
B、IO密集型 判断程序中十分耗IO的线程 最大线程 > 十分耗IO的线程数
point14:四大函数式接口（简化编程模型
函数型接口
Function function = (str)->{ return str;};//有参数、有返回值
断定型接口
Predicate<String> predicate =(str)->{return str.isEmpty();};//有参数，返回布尔值
消费性接口
Consumer<String> consumer =(str)->{ System.out.println("已消费"); };//有参数，无返回值
供给型接口
Supplier supplier=()->{return "你好";};//无参数，有返回值
ponit15:Stream流
/* 筛选条件 * 1、id为偶数 * 2、年龄大于22 * 3、名字转为大写 * 4、倒序 * 5、输出一个 */ User u1 =new User(1,"a",20); User u2 =new User(2,"b",21); User u3 =new User(3,"c",22); User u4 =new User(4,"d",23); User u5 =new User(5,"e",24); User u6 =new User(6,"f",25); List<User> list = Arrays.asList(u1, u2, u3, u4,u5,u6); list.stream().filter(u->{return u.getId()%2==0;}) .filter(u->{return u.getAge()>22;}) .map(u->{return u.getName().toUpperCase();}) .sorted((uu1,uu2)->{return uu2.compareTo(uu1);}) .limit(1) .forEach(System.out::println);
point16:ForkJoin
把一个大任务拆成多个小任务并行执行 例如：计算1-10亿内的数累加 使用ForkJoin可以提升速度，使用Stream流会更快
point17:异步回调
