了解juc源码有用么（JUC学习笔记）
java.util工具包、包、分类Runnable 没有返回值、效率相比Callable低，我来为大家科普一下关于了解juc源码有用么?下面希望有你要的答案，我们一起来看看吧!
了解juc源码有用么
1.什么是JUCjava.util工具包、包、分类
Runnable 没有返回值、效率相比Callable低
2.线程和进程进程：一个程序
一个进程往往可以包含多个线程，至少包含一个。
java默认有2个线程 main、GC
对于java而言: Thread、Runnable、Callable
java真的可以开线程吗？开不了
本地方法，底层的c ，java无法直接操作硬件
private native void start0();
并发编程:并发、并行
并发(多线程操作同一资源)
- CPU一核，模拟出来多条线程，快速交替
并行:(多个人一起行走)
CPU多核，多个线程可以同时执行;线程池
public class Test01 {
public static void main(String[] args) {
//获取cpu的核数
//CPU 密集型,IO密集型
System.out.println(Runtime.getRuntime().availableProcessors());
}
}
并发编程本质:充分利用CPU的资源
线程有几个状态？6个
public enum State { //新生 NEW, //运行 RUNNABLE, //阻塞 BLOCKED, //等待,死死地等 WAITING, //超时等待 TIMED_WAITING, //终止 TERMINATED; }wait/sleep区别
1.来自不同的类
wait => Object
sleep =>Thread
2.关于锁的释放
wait会释放锁，sleep不会
3.使用的范围不同
wait必须在同步代码块中
sleep可以在任何地方
4.是否需要捕获异常
wait不需要捕获异常
sleep必须要捕获异常
3.LOCK锁(重点)传统Synchronized
package com.yueyi.demo01; //基本的买票例子 /** * 真正的多线程开发，公司中的开发，降低耦合性 * 线程就是一个资源类，没有任何附属操作！ * 1. 属性、方法 * @author zyy * @create 2021-10-22 20:01 */ public class SaleTicketDemo01 { public static void main(String[] args) { //并发:多线程操作同一个资源类 Ticket ticket = new Ticket(); new Thread(()->{ for (int i = 1; i < 40; i ){ ticket.sale(); } },"A").start(); new Thread(()->{ for (int i = 1; i < 40; i ){ ticket.sale(); } },"B").start(); new Thread(()->{ for (int i = 1; i < 40; i ){ ticket.sale(); } },"C").start(); } } //资源类 OOP class Ticket { //属性、方法 private int number = 30; //卖票方式 //synchronized 本质: 队列、锁 public synchronized void sale(){ if (number > 0){ System.out.println(Thread.currentThread().getName() "卖出了" (number--) "票,剩余:" number); } } }Lock接口
l.lock()加锁 l.unlock()解锁
ReentrantLock(可重入锁)；
ReentrantReadWriteLock.ReadLock(读锁)；
ReentrantReadWriteLock.WriteLock(写锁)；
public ReentrantLock() { sync = new NonfairSync();//非公平锁 } /** * Creates an instance of {@code ReentrantLock} with the * given fairness policy. * * @param fair {@code true} if this lock should use a fair ordering policy */ public ReentrantLock(boolean fair) { // 公平锁 sync = fair ? new FairSync() : new NonfairSync(); }公平锁:十分公平：可以先来后到
非公平锁:十分不公平:可以插队(默认)
package com.yueyi.demo01; //基本的买票例子 import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * 真正的多线程开发，公司中的开发，降低耦合性 * 线程就是一个资源类，没有任何附属操作！ * 1. 属性、方法 * @author zyy * @create 2021-10-22 20:01 */ public class SaleTicketDemo02 { public static void main(String[] args) { //并发:多线程操作同一个资源类 Ticket2 ticket2 = new Ticket2(); new Thread(()->{for (int i = 1; i < 40; i ) ticket2.sale();},"A").start(); new Thread(()->{for (int i = 1; i < 40; i ) ticket2.sale();},"B").start(); new Thread(()->{for (int i = 1; i < 40; i ) ticket2.sale();},"C").start(); } } //资源类 OOP //Lock三部曲 //1.new ReentrantLock(); //2.lock.lock(); 加锁 //3.finally=>lock.unlock();解锁 class Ticket2 { //属性、方法 private int number = 30; Lock lock = new ReentrantLock(); //卖票方式 public void sale(){ lock.lock(); try { if (number > 0){ System.out.println(Thread.currentThread().getName() "卖出了" (number--) "票,剩余:" number); } } catch (Exception e) { e.printStackTrace(); } finally { lock.unlock(); } } }Synchronized 和 Lock区别
Synchronized 是java内置的关键字;Lock是类 Synchronized 无法判断获取锁的状态，Lock可以判断是否获取到了锁 Synchronized 会自动释放锁，Lock必须要手动释放锁，不释放会死锁 Synchronized 如果线程1（获得锁，阻塞）线程2（等待），lock不一定会等待下去 Synchronized 可重入锁，不可以中断，是非公平的,Lock 可重入锁，可判断锁，非公平(可 以自己设置) Synchronized 适合锁少量的代码同步问题,Lock 适合锁大量的同步代码
锁是什么, 如何判断锁的是谁？
4.生产者和消费者问题生产者和消费者 Synchronized 版
/** *线程之间的通信问题:生产者和消费者问题. 等待唤醒， 通知唤醒 * 线程交替执行 * @author zyy * @create 2021-10-23 8:54 */ 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(); new Thread(()->{ for (int i = 0; i < 10; i ) { try { data.increment(); } catch (InterruptedException e) { e.printStackTrace(); } } },"C").start(); new Thread(()->{ for (int i = 0; i < 10; i ) { try { data.decrement(); } catch (InterruptedException e) { e.printStackTrace(); } } },"D").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); //通知其它线程,我 1完毕了 this.notifyAll(); } public synchronized void decrement() throws InterruptedException { if (number == 0){ //等待 this.wait(); } number --; System.out.println(Thread.currentThread().getName() "=>" number); //通知其它线程,我-1完毕了 this.notifyAll(); } }问题存在， A B C D 4个线程!
出现虚假唤醒
if改为while
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(); new Thread(()->{ for (int i = 0; i < 10; i ) { try { data.increment(); } catch (InterruptedException e) { e.printStackTrace(); } } },"C").start(); new Thread(()->{ for (int i = 0; i < 10; i ) { try { data.decrement(); } catch (InterruptedException e) { e.printStackTrace(); } } },"D").start(); } } //判断等待，业务，通知 class Data{ private int number = 0; public synchronized void increment() throws InterruptedException { while (number != 0){ //等待 this.wait(); } number ; System.out.println(Thread.currentThread().getName() "=>" number); //通知其它线程,我 1完毕了 this.notifyAll(); } public synchronized void decrement() throws InterruptedException { while (number == 0){ //等待 this.wait(); } number --; System.out.println(Thread.currentThread().getName() "=>" number); //通知其它线程,我-1完毕了 this.notifyAll(); } }JUC版 生产者和消费者问题
import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** *线程之间的通信问题:生产者和消费者问题. 等待唤醒， 通知唤醒 * 线程交替执行 * @author zyy * @create 2021-10-23 8:54 */ public class B { public static void main(String[] args) { Data2 data2 = new Data2(); new Thread(()->{ for (int i = 0; i < 10; i ) { try { data2.increment(); } catch (InterruptedException e) { e.printStackTrace(); } } },"A").start(); new Thread(()->{ for (int i = 0; i < 10; i ) { try { data2.decrement(); } catch (InterruptedException e) { e.printStackTrace(); } } },"B").start(); new Thread(()->{ for (int i = 0; i < 10; i ) { try { data2.increment(); } catch (InterruptedException e) { e.printStackTrace(); } } },"C").start(); new Thread(()->{ for (int i = 0; i < 10; i ) { try { data2.decrement(); } catch (InterruptedException e) { e.printStackTrace(); } } },"D").start(); } } //判断等待，业务，通知 class Data2{ private int number = 0; Lock lock = new ReentrantLock(); Condition condition = lock.newCondition(); public void increment() throws InterruptedException { lock.lock(); try { while (number != 0){ //等待 condition.await(); } number ; condition.signalAll(); System.out.println(Thread.currentThread().getName() "=>" number); } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); } //通知其它线程,我 1完毕了 } public synchronized void decrement() throws InterruptedException { lock.lock(); try { while (number == 0){ //等待 condition.await(); } number --; System.out.println(Thread.currentThread().getName() "=>" number); condition.signalAll(); } catch (Exception e) { e.printStackTrace(); } finally { lock.unlock(); } //通知其它线程,我-1完毕了 } }任何一个新技术，绝对不是仅仅值时覆盖了原来的技术，一定会有优势和补充！
Condition 精准的通知和唤醒线程
5. 8锁现象
import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * @author zyy * @create 2021-10-24 9:01 * A执行完调用B, B执行完调用C， C执行完调用A */ public class C { public static void main(String[] args) { Data3 data3 = new Data3(); new Thread(()->{ for (int i = 0; i < 10; i ) { try { data3.printA(); } catch (Exception e) { e.printStackTrace(); } } },"A").start(); new Thread(()->{ for (int i = 0; i < 10; i ) { try { data3.printB(); } catch (Exception e) { e.printStackTrace(); } } },"B").start(); new Thread(()->{ for (int i = 0; i < 10; i ) { try { data3.printC(); } catch (Exception e) { e.printStackTrace(); } } },"C").start(); } } class Data3{//资源类 Lock private Lock lock = new ReentrantLock(); private Condition condition1 = lock.newCondition(); private Condition condition2 = lock.newCondition(); private Condition condition3 = lock.newCondition(); private int number = 1; //1A 2B 3C public void printA(){ lock.lock(); try { //业务， 判断->执行->通知 while(number != 1){ //等待 condition1.await(); } System.out.println(Thread.currentThread().getName() "=>A"); //唤醒，唤醒指定的人，B number = 2; condition2.signal(); } catch (Exception e) { e.printStackTrace(); } finally { lock.unlock(); } } public void printB(){ lock.lock(); try { //业务， 判断->执行->通知 while (number != 2){ condition2.await(); } System.out.println(Thread.currentThread().getName() "=>B"); number = 3; condition3.signal(); } catch (Exception e) { e.printStackTrace(); } finally { lock.unlock(); } } public void printC(){ lock.lock(); try { //业务， 判断->执行->通知 while (number != 3){ condition3.await(); } System.out.println(Thread.currentThread().getName() "=>C"); number = 1; condition1.signal(); } catch (Exception e) { e.printStackTrace(); } finally { lock.unlock(); } } }如何判断锁的是谁
对象、Class
/** * 8锁，就是关于锁的8个问题 * * * @author zyy * @create 2021-10-24 10:21 */ public class Test1 { public static void main(String[] args) { Phone phone = new Phone(); new Thread(()->{ phone.sendSms(); }).start(); try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } new Thread(()->{ phone.call(); }).start(); } } class Phone{ //synchronized 锁的对象是方法的调用者 //两个方法用的是同一个锁,谁先拿到谁执行 public synchronized void sendSms(){ System.out.println("发短信"); } public synchronized void call(){ System.out.println("打电话"); } }小结
new this 具体的一个手机
static Class唯一的一个模板
6.集合类不安全List不安全
import java.util.*; import java.util.concurrent.CopyOnWriteArrayList; /** * @author zyy * @create 2021-10-24 15:13 */ public class ListTest { public static void main(String[] args) { //并发下ArrayList 不安全的吗？，Synchronized /** * 解决方案： * 1、List<String> list = new Vector<>(); * 2、List<String> list = Collection.synchronizedList(new ArrayList<>); * List<String> list = new CopyOnWriteArrayList<>(); */ //CopyOnWrite 写入时复制 COW 计算机程序设计领域的一种优化策略; //多个线程调用的时候,list,读取的时候，固定的，写入(覆盖); //在写入的时候避免覆盖，造成数据问题 //读写分离 //CopyOnWriteArrayList 比 Vector 好在哪里？ List<String> list = new CopyOnWriteArrayList<>(); for (int i = 1; i <= 10; i ){ new Thread(()->{ list.add(UUID.randomUUID().toString().substring(0,5)); System.out.println(list); },String.valueOf(i)).start(); } } }Set不安全
import java.util.Collections; import java.util.HashSet; import java.util.Set; import java.util.UUID; import java.util.concurrent.CopyOnWriteArraySet; /** * @author zyy * @create 2021-10-24 16:04 * * 1.Collections.synchronizedSet(new HashSet<>()); * 2. */ public class SetTest { public static void main(String[] args) { // Set<String> set = new HashSet<>(); // Set<String> set = Collections.synchronizedSet(new HashSet<>()); Set<String> set = new CopyOnWriteArraySet<>(); for (int i = 0; i <= 30; i ) { new Thread(()->{ set.add(UUID.randomUUID().toString().substring(0,5)); System.out.println(set); },String.valueOf(i)).start(); } } }Map不安全
7.Callable(简单)
/** * @author zyy * @create 2021-10-24 16:25 */ public class MapTest { public static void main(String[] args) { //map 是这样用吗？ 不是，工作中不用HashMap //默认等价于什么？ new HashMap<>(16,0.75); //Map<String,String>map = new HashMap<>(); Map<String,String>map = new ConcurrentHashMap<>(); for (int i = 0; i <= 30; i ) { new Thread(()->{ map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5)); System.out.println(map); },String.valueOf(i)).start(); } } }1.可以有返回值
2.可以抛出异常
3.方法不同 run()/call()
代码测试
import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.Future; import java.util.concurrent.FutureTask; /** * @author zyy * @create 2021-10-24 20:05 */ 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(); // new Thread().start();//怎样启动Callable MyThread myThread = new MyThread(); FutureTask futureTask = new FutureTask(myThread); new Thread(futureTask,"A").start(); String o = (String)futureTask.get(); System.out.println(o); } } class MyThread implements Callable<String>{ @Override public String call() throws Exception { System.out.println("call"); return "1024"; } }
package com.yueyi.callable; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.Future; import java.util.concurrent.FutureTask; /** * @author zyy * @create 2021-10-24 20:05 */ 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(); // new Thread().start();//怎样启动Callable MyThread myThread = new MyThread(); FutureTask futureTask = new FutureTask(myThread); new Thread(futureTask,"A").start(); new Thread(futureTask,"B").start();//结果会被缓存，效率高 String o = (String)futureTask.get();//get()方法可能产生阻塞 System.out.println(o); } } class MyThread implements Callable<String>{ @Override public String call() throws Exception { System.out.println("call"); return "1024"; } }细节:
1.有缓存
2.结果可能需要等待
8.常用的辅助类(必会)8.1.CountDownLatch
import java.util.concurrent.CountDownLatch; /** * @author zyy * @create 2021-10-25 8:29 */ 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();//数量-1 },String.valueOf(i)).start(); } countDownLatch.await();//等待计数器归零，然后再向下执行 System.out.println("Close Door"); } }减法计数器
原理:
countDownLatch.countDown();//数量-1
countDownLatch.await();//等待计数器归零，然后再向下执行每次有线程调用countDown()数量-1,假设计数器变为0，countDownLatch.await()就会被唤醒,继续执行
8.2.CyclicBarrier加法计数器
8.3.Semaphore
import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier; /** * @author zyy * @create 2021-10-25 8:44 */ public class CyclicBarrierDemo { public static void main(String[] args) { CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{ System.out.println("召唤神龙成功"); }); new Thread(new Runnable() { @Override public void run() { } }).start(); 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(); } }).start(); } } }Semaphore：信号量
import java.util.concurrent.Semaphore; import java.util.concurrent.TimeUnit; /** * @author zyy * @create 2021-10-25 9:32 */ public class SemaphoreDemo { public static void main(String[] args) { //线程数量:停车位 限流 Semaphore semaphore = new Semaphore(3); for (int i = 1; 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();//release()//释放 } },String.valueOf(i)).start(); } } }原理:
semaphore.acquire();获得，假设如果满了,等待,等待被释放为止
semaphore.release();释放，会将当前的信号量释放 1，然后唤醒等待的线程
作用:多个共享资源互斥的使用，并发限流，控制最大线程数
9.读写锁10.阻塞队列
import java.util.HashMap; import java.util.Map; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantLock; import java.util.concurrent.locks.ReentrantReadWriteLock; /** * 独占锁(写锁) 一次只能被一个线程占有 * 共享锁（读锁）多个线程可以同时占有 * ReadWriteLock * 读-读 可以共存 * 读-写 不能共存 * 写-写 不能共存 * * * @author zyy * @create 2021-10-25 9:50 */ public class ReadWriteLockDemo { public static void main(String[] args) { MyCacheLock myCache = new MyCacheLock(); //写入 for (int i = 1; i <= 5; i ) { final int temp = i; new Thread(()->{ myCache.put(temp "",temp); },String.valueOf(i)).start(); } //读取 for (int i = 1; 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() "写入ok"); } //读，取 public void get(String key){ System.out.println(Thread.currentThread().getName() "读取" key); Object o = map.get(key); System.out.println(Thread.currentThread().getName() "读取ok"); } } class MyCacheLock{ private volatile Map<String,Object> map = new HashMap<>(); //读写锁 private ReadWriteLock readWriteLock = new ReentrantReadWriteLock(); //存，写入的时候，只希望同时只有一个线程写 public void put(String key,Object value){ readWriteLock.writeLock().lock(); try { System.out.println(Thread.currentThread().getName() "写入" key); map.put(key,value); System.out.println(Thread.currentThread().getName() "写入ok"); } catch (Exception e) { e.printStackTrace(); } finally { readWriteLock.writeLock().unlock(); } } //读，所有人都可以读 public void get(String key){ readWriteLock.readLock().lock(); try { System.out.println(Thread.currentThread().getName() "读取" key); Object o = map.get(key); System.out.println(Thread.currentThread().getName() "读取ok"); } catch (Exception e) { e.printStackTrace(); } finally { readWriteLock.readLock().unlock(); } } }BlockingQueue BlockingQueue不是新东西
什么情况下我们会使用阻塞队列：多i线程并发处理，线程池！
学会使用队列
添加、移除
四组API
方式
抛出异常
有返回值
阻塞等待
超时等待
添加
add
offer
put
offer(,,)
移除
remove
poll
take
poll(,)
检测队首元素
element
peek
-
-
/** * 抛出异常 */ public static void test1(){ //队列大小 ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3); System.out.println( blockingQueue.add("a")); System.out.println( blockingQueue.add("b")); System.out.println( blockingQueue.add("c")); //java.lang.IllegalStateException: Queue full //System.out.println( blockingQueue.add("d")); System.out.println("======================="); System.out.println(blockingQueue.remove()); System.out.println(blockingQueue.remove()); System.out.println(blockingQueue.remove()); //java.util.NoSuchElementException 没有元素继续删除抛出异常 System.out.println(blockingQueue.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("d"));//false 不抛出异常 System.out.println("======================="); System.out.println( blockingQueue.poll()); System.out.println( blockingQueue.poll()); System.out.println( blockingQueue.poll()); System.out.println( blockingQueue.poll());//null 不抛出异常 }
/** * 等待，阻塞(一直等待) */ public static void test3() throws InterruptedException { //队列大小 ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3); //一直阻塞 blockingQueue.put("a"); blockingQueue.put("b"); blockingQueue.put("c"); //blockingQueue.put("d");//队列没有位置了，一直等待 System.out.println(blockingQueue.take()); System.out.println(blockingQueue.take()); System.out.println(blockingQueue.take()); System.out.println(blockingQueue.take()); }
/** * 等待，阻塞(等待超时) */ public static void test4() throws InterruptedException { //队列大小 ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3); blockingQueue.offer("a"); blockingQueue.offer("b"); blockingQueue.offer("c"); // blockingQueue.offer("d", 2,TimeUnit.SECONDS);//等待超过两秒退出 System.out.println("============="); System.out.println(blockingQueue.poll()); System.out.println(blockingQueue.poll()); System.out.println(blockingQueue.poll()); blockingQueue.poll(2,TimeUnit.SECONDS);//等待超过两秒退出 }Synchronized同步队列
没有容量,
进去一个元素必须等待取出来之后才能再往里面放一个元素。
put\take
11.线程池(重点)
import java.util.concurrent.SynchronousQueue; import java.util.concurrent.TimeUnit; /** * 同步队列 * 和其它的BlockingQueue 不一样，SynchronousQueue 不存储元素 * put了一个元素进去，必须从里面先take取出来，否则不能put进去值 * @author zyy * @create 2021-10-25 16:47 */ public class SynchronizedDemo { public static void main(String[] args) { SynchronousQueue<String> synchronousQueue = new SynchronousQueue<String>(); new Thread(()->{ try { System.out.println(Thread.currentThread().getName() " put 1"); synchronousQueue.put("1"); System.out.println(Thread.currentThread().getName() " put 2"); synchronousQueue.put("2"); System.out.println(Thread.currentThread().getName() " put 3"); synchronousQueue.put("3"); } catch (InterruptedException e) { e.printStackTrace(); } }).start(); new Thread(()->{ try { TimeUnit.SECONDS.sleep(3); System.out.println(Thread.currentThread().getName() "=>" synchronousQueue.take()); TimeUnit.SECONDS.sleep(3); System.out.println(Thread.currentThread().getName() "=>" synchronousQueue.take()); TimeUnit.SECONDS.sleep(3); System.out.println(Thread.currentThread().getName() "=>" synchronousQueue.take()); } catch (InterruptedException e) { e.printStackTrace(); } }).start(); } }线程池：三大方法、7大参数、4种拒绝策略
池化技术
程序的运行，本质：占用系统资源！ 优化资源的使用=>池化技术
线程池、连接池、内存池、对象池......
池化技术：事先准备好一些资源，有人要用，就来我这里拿，用完之后还给我。
线程池的好处
1、降低资源的消耗
2、提高响应速度
3、方便管理
线程复用、可以控制最大并发数、管理线程
线程池：三大方法
public class Demo01 { 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(); } } }7大参数
源码分析:
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,//21亿 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>()); } //本质：ThreadPoolExecutor() 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; }手动创建线程池
public class Demo01 { public static void main(String[] args) { //自定义线程池 ExecutorService threadPool = new ThreadPoolExecutor( 2, 5, 3, TimeUnit.SECONDS, new LinkedBlockingDeque<>(3), Executors.defaultThreadFactory(), new ThreadPoolExecutor.DiscardOldestPolicy()//队列满了，尝试和最早的竞争，也不会抛出异常 ); try { for (int i = 1; i <= 9; i ) { //使用了线程池之后，使用线程池来创建线程 //超过java.util.concurrent.RejectedExecutionException threadPool.execute(()->{ System.out.println(Thread.currentThread().getName() " ok"); }); } } catch (Exception e) { e.printStackTrace(); } finally { threadPool.shutdown(); } } }4种拒绝策略
/** * @author zyy * @create 2021-10-26 7:53 * * new ThreadPoolExecutor.AbortPolicy() 不处理，抛出异常 * new ThreadPoolExecutor.CallerRunsPolicy() 哪来的去哪里执行 * new ThreadPoolExecutor.DiscardPolicy() 队列满了，丢掉任务，不会抛出异常 * new ThreadPoolExecutor.DiscardOldestPolicy()//队列满了，尝试和最早的竞争，也不会抛出异常 * */小结和拓展
最大线程到底该如何定义
1.CPU密集型，几核，就是几，可以保持CPU效率最高
2.IO密集型 >判断你程序中十分耗IO的线程
获取CPU核数
12.四大函数式接口
System.out.println(Runtime.getRuntime().availableProcessors());Consumer Function Predicate Supplier
函数式接口：只有一个方法的接口
@FunctionalInterface public interface Runnable { public abstract void run(); } //简化编程模型，在新版本的框架底层大量应用 //foreach(消费者类的函数式接口)代码测试：
Function函数型接口
/** * @author zyy * @create 2021-10-26 10:07 * * Function 函数型接口，有一个输入参数，有一个输出 * 只要是 函数型接口 可以用 lambda表达式简化 */ public class Demo01 { public static void main(String[] args) { Function function = (str)->{return str;}; System.out.println(function.apply("zyy")); } }Predicate断定型接口
/** * @author zyy * @create 2021-10-26 10:24 * * 断定型接口:有一个输入参数，返回值只能是 布尔值 */ public class Demo02 { public static void main(String[] args) { //判断字符串是否为空 // Predicate<String> predicate = new Predicate<String>() { // @Override // public boolean test(String str) { // return str.isEmpty(); // } // }; Predicate<String> predicate = str-> str.isEmpty(); System.out.println(predicate.test("")); } }Consumer消费型接口
/** * @author zyy * @create 2021-10-26 10:55 * * Consumer 消费型接口：只有输入，没有返回值 */ public class Demo03 { public static void main(String[] args) { // Consumer<String> consumer = new Consumer<String>() { // @Override // public void accept(String str) { // System.out.println(str); // } // }; Consumer<String> consumer = (str) -> System.out.println(str); consumer.accept("zyy"); } }Supplier供给型接口
13.Srteam流式计算
/** * @author zyy * @create 2021-10-26 14:27 * * Supplier 供给型接口没有参数只有返回值 */ public class Demo04 { public static void main(String[] args) { // Supplier<Integer> supplier = new Supplier<Integer>() { // @Override // public Integer get() { // System.out.println("get()"); // return 1024; // } // }; Supplier<Integer> supplier = ()->1024; System.out.println(supplier.get()); } }什么是Stream流式计算
14.ForkJoin
/** * @author zyy * @create 2021-10-26 14:57 * 现在有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(6,"e",25); List<User> list = Arrays.asList(u1,u2,u3,u4,u5); list.stream() .filter(u->u.getId()%2 == 0) .filter(u->u.getAge()>23) .map(u->u.getName().toUpperCase()) .sorted((uu1,uu2)->{return uu2.compareTo(uu1);}) .limit(1) .forEach(System.out::println); } }什么是ForkJoin
并行执行任务，提高效率，大数据量
把大任务拆分成小任务
ForkJoin的特点：工作窃取
这里面维护的都是双端队列
先执行完任务的线程会把还没执行完任务的线程的任务偷过来继续执行
ForkJoin
import java.util.concurrent.RecursiveTask; /** * @author zyy * @create 2021-10-26 16:10 * 求和计算的任务 * 如何使用ForkJoin * 1.ForkJoinPool 通过它来执行 * 2.计算任务 ForkJoinPool.execute(ForkJoinTask task) * 3.计算类要继承ForkJoinTask */ public class ForkJoinDemo extends RecursiveTask<Long> { private Long start; private Long end; private Long temp = 10000L; public ForkJoinDemo(Long start, Long end) { this.start = start; this.end = end; } public ForkJoinDemo(Long start, Long end, Long temp) { this.start = start; this.end = end; this.temp = temp; } @Override protected Long compute() { if ((end - start) < temp){ Long sum = 0L; for (Long i = start; i <= end; i ) { sum = i; } return sum; }else{//forkjoin Long middle = (start end) / 2;//中间值 ForkJoinDemo task1 = new ForkJoinDemo(start,middle); task1.fork();//拆分任务，把任务压入线程队列 ForkJoinDemo task2 = new ForkJoinDemo(middle 1,end); task2.fork();//拆分任务，把任务压入线程队列 return task1.join() task2.join(); } } }测试:
15.异步回调
** * @author zyy * @create 2021-10-26 19:32 */ public class Test { public static void main(String[] args) throws ExecutionException, InterruptedException { // test1();//7347 // test2();//5665 test3();//298 } public static void test1(){ long start = System.currentTimeMillis(); Long sum = 0L; for (Long i = 1L; i <= 10_0000_0000; i ) { sum = i; } long end = System.currentTimeMillis(); System.out.println("sum=" sum " 时间:" (end-start)); } public static void test2() throws ExecutionException, InterruptedException { long start = System.currentTimeMillis(); ForkJoinPool forkJoinPool = new ForkJoinPool(); ForkJoinDemo task = new ForkJoinDemo(0L,10_0000_0000L); ForkJoinTask<Long> submit = forkJoinPool.submit(task);//提交任务 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 sum = LongStream.rangeClosed(0L, 10_0000_0000L).parallel().reduce(0, (x, y) -> x = y); long end = System.currentTimeMillis(); System.out.println("sum=" sum " 时间:" (end-start)); } }Future设计的初衷:对将来的某个事件结果进行建模
16.JMM
/** * @author zyy * @create 2021-10-27 7:56 * 异步执行 * 成功回调 * 失败回调 */ public class Demo01 { public static void main(String[] args) throws ExecutionException, InterruptedException { //没有返回值的 runAsync 异步回调 // CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> { // try { // TimeUnit.SECONDS.sleep(2); // } catch (InterruptedException e) { // e.printStackTrace(); // } // System.out.println(Thread.currentThread().getName() "runAsync=>Void"); // }); // System.out.println("zyy"); // completableFuture.get();//获取执行结果 // 有返回值的 supplyAsync 异步回调 CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(()->{ System.out.println(Thread.currentThread().getName() "supplyAsync=>Integer"); int i = 10/0; return 1024; }); System.out.println(completableFuture.whenComplete((t, u) -> { System.out.println("t=>" t);//正常返回结果 System.out.println("u=>" u);//错误信息 }).exceptionally((e) -> { System.out.println(e.getMessage()); return 233;//可以获取到错误的返回结果 }).get()); } }请你谈谈对Volatile的理解
Volatile 是 java虚拟机提供轻量级的同步机制
1.保证可见性
2.不保证原子性
3.禁止指令重排
什么是JMM
JMM：java内存模型，不存在的东西。概念，约定。
关于JMM的一些同步约定:
1.线程解锁前，必须把共享变量立刻刷回主存
2.线程解锁前，必须读取主存中的最新值到工作内存中
3.加锁和解锁是同一把锁
线程:工作内存、主内存
内存交互操作有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操作之前，必须把此变量同步回主内存
问题：程序不知道主内存的值被修改过了
17.Volatile1.保证可见性
/** * @author zyy * @create 2021-10-27 8:57 */ public class JMMDemo { //不加 volatile 程序就会死循环 //加 volatile 可以保证可见性 private volatile static int num = 0; public static void main(String[] args) { new Thread(()->{//线程1对主内存的变化不知道的 while(num == 0){ } }).start(); try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } num = 1; System.out.println(num); } }2.不保证原子性
原子性：不可分割
线程A在执行任务的时候，不能被打扰的，也不能被分割。要么同时成功，要么同时失败。
/** * @author zyy * @create 2021-10-27 9:43 * * 不保证原子性 */ public class VDemo02 { //volatile 不保证原子性 private volatile static int num = 0; public static void add(){ num ; } public static void main(String[] args) { for (int i = 1; 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,怎样保证原子性？
原子类
/** * @author zyy * @create 2021-10-27 9:43 */ public class VDemo02 { //volatile 不保证原子性 //原子类的Integer private volatile static AtomicInteger num = new AtomicInteger(); public static void add(){ //num ;//不是一个原子性操作 num.getAndIncrement();//AtomicInteger 1方法 CAS } public static void main(String[] args) { for (int i = 1; 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); } }指令重排
什么是指令重排：你写的程序，计算机并不是按照你写的那样去执行的。
源代码 ---> 编译器优化的重排 ---> 指令并行也可能会重排 ---> 内存系统也会重排 --->执行
处理器在进行指令重排的时候，考虑:数据之间的依赖性
int x = 1; //1 int y = 2; //2 x = x 5; //3 y = x * x; //4 我们所期望的: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指令 作用:
1.保证特定的操作执行顺序！
2.可以保证某些变量的内存可见性(利用这些特性volatile实现了可见性)
普通读
↓
普通写
↓
内存屏障:禁止上面指令和下面指令顺序交换
↓
volatile写
↓
内存屏障:禁止上面指令和下面指令顺序交换
volatile是可以保持可见性，不能保证原子性，由于内存屏障，可以保证避免指令重排的现象产生
18.彻底玩转单例模式饿汉式 DCL懒汉式
饿汉式
/** * @author zyy * @create 2021-10-27 14:57 */ public class Hungry { //可能会浪费空间 private byte [] data = new byte[1024*1024]; private Hungry(){ } private final static Hungry HUNGRY = new Hungry(); public static Hungry getInstance(){ return HUNGRY; } }DCL懒汉式
/** * @author zyy * @create 2021-10-27 15:02 * 懒汉式单例 */ public class LazyMan { private LazyMan(){ System.out.println(Thread.currentThread().getName() " ok"); } private volatile static LazyMan lazyMan; //双重检测锁模式 DCL懒汉式 public static LazyMan getInstance(){ if (lazyMan == null){ synchronized (LazyMan.class){ if (lazyMan == null){ lazyMan = new LazyMan();//不是一个原子性操作 /** * 1.分配内存空间 * 2.执行构造方法，初始化对象 * 3.把这个对象指向这个空间 * * 123 * 132 A * B 此时lazyMan还没有完成构造 */ } } } return lazyMan; } //多线程并发 public static void main(String[] args) { for (int i = 0; i <= 10; i ) { new Thread(()->{ lazyMan.getInstance(); }).start(); } } }单例不安全
枚举单例
19.深入理解CAS
/** * @author zyy * @create 2021-10-27 20:27 */ public enum EnumDemo { INSTANCE; public EnumDemo getInstance(){ return INSTANCE; } } class Test{ public static void main(String[] args) { EnumDemo.INSTANCE.getInstance(); } }什么是CAS
public class CASDemo { //compareAndSet public static void main(String[] args) { AtomicInteger atomicInteger = new AtomicInteger(2020); //期望、更新 //public final boolean compareAndSet(int expect, int update) //如果我期望的值达到了，那么就更新，否则就不更新。CAS 是CPU的并发原语 System.out.println(atomicInteger.compareAndSet(2020, 2021)); System.out.println(atomicInteger.get()); System.out.println(atomicInteger.compareAndSet(2020, 2021)); System.out.println(atomicInteger.get()); } }CAS:比较当前工作内存中的值，如果这个值是期望的，那么则执行操作！如果不是就一直循环！
缺点:
1.循环会耗时
2.一次性只能保证一个共享变量的原子性
3.ABA问题
CAS:ABA (狸猫换太子)
20.原子引用
/** * @author zyy * @create 2021-10-28 7:57 */ public class CASDemo { //compareAndSet public static void main(String[] args) { AtomicInteger atomicInteger = new AtomicInteger(2020); //期望、更新 //public final boolean compareAndSet(int expect, int update) //如果我期望的值达到了，那么就更新，否则就不更新。CAS 是CPU的并发原语 //==================捣乱的线程============================================ System.out.println(atomicInteger.compareAndSet(2020, 2021)); System.out.println(atomicInteger.get()); System.out.println(atomicInteger.compareAndSet(2021, 2020)); System.out.println(atomicInteger.get()); //==================期望的线程============================================ System.out.println(atomicInteger.compareAndSet(2020, 6666)); System.out.println(atomicInteger.get()); } }带版本号的原子操作
解决ABA问题 乐观锁
21.各种锁的理解1.公平锁、非公平锁
/** * @author zyy * @create 2021-10-28 7:57 */ public class CASDemo { //compareAndSet public static void main(String[] args) { // AtomicInteger atomicInteger = new AtomicInteger(2020); AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference(10,1); new Thread(()->{ int stamp = atomicStampedReference.getStamp();//获得版本号 System.out.println("A1=>" stamp); try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); } atomicStampedReference.compareAndSet(10,20,atomicStampedReference.getStamp(),atomicStampedReference.getStamp() 1); System.out.println("A2=>" atomicStampedReference.getStamp()); atomicStampedReference.compareAndSet(20,10,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(10,60,stamp,stamp 1); System.out.println("B1=>" atomicStampedReference.getStamp()); },"B").start(); } }公平锁:非长公平，不能够插队，必须先来后到
非公平锁：非常不公平，可以插队（默认非公平锁）
2.可重入锁可重入锁(递归锁):拿到外面的锁就可以拿到里面的锁，自动获得。
3.自旋锁自旋锁（spinlock）：是指当一个线程在获取锁的时候，如果锁已经被其它线程获取，那么该线程将循环等待，然后不断的判断锁是否能够被成功获取，直到获取到锁才会退出循环。
获取锁的线程一直处于活跃状态，但是并没有执行任何有效的任务，使用这种锁会造成busy-waiting。
,
public class SpinLock { private AtomicReference cas = new AtomicReference(); public void lock() { Thread current = Thread.currentThread(); // 利用CAS while (!cas.compareAndSet(null, current)) { // DO nothing } } public void unlock() { Thread current = Thread.currentThread(); cas.compareAndSet(current, null); } }
免责声明：本文仅代表文章作者的个人观点，与本站无关。其原创性、真实性以及文中陈述文字和内容未经本站证实，对本文以及其中全部或者部分内容文字的真实性、完整性和原创性本站不作任何保证或承诺，请读者仅作参考，并自行核实相关内容。文章投诉邮箱：anhduc.ph@yahoo.com
