Java学习笔记（十一）——JUC并发编程（超详细）
线程和进程
进程：一个程序的集合，一个进程至少包含一个线程；
Java默认有两个进程，main、GC
线程：一个进程某个功能由线程负责
对于Java而言Thread、Runnable、Callable真的可以开启线程吗？
开不了，通过本地方法native()调用
并发和并行
并发编程：并发、并行，本质是充分利用CPU的资源
并发：多线程操作同一个资源
并行：多个线程同时执行；线程池
线程有几个状态？
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必须要捕获异常
Lock锁（重点）
Synchronized 和 Lock的区别
1.Synchronized 内置的Java关键字，Lock是一个java类
2.Synchronized 无法判断获取锁的状态，Lock可以判断是否获取到了锁
3.Synchronized 会自动释放锁，Lock必须要手动释放锁！（如果不释放锁会造成死锁）
4.Synchronized 线程1（获得锁，阻塞）、线程3（等待）；Lock锁就不一定会等待下去
5.Synchronized 可重入锁，不可以中断的，非公平；Lock可重入锁
，可以判断锁，非公平（可以自己设置）
6.Synchronized 适合锁少量的代码同步问题，Lock适合所大量的同步代码
锁是什么，如何判断锁的是谁
生产者和消费者问题
Synchronized 版
/**
* 线程之间的通信问题：生产者和消费者问题
* 线程交替执行 A B操作同一个变量 num=0
* A num+1
* B num-1
*/
public class demo01 {
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 num = 0;
//+1
public synchronized void increment() throws InterruptedException {
if (num != 0) {
//等待
this.wait();
}
num++;
System.out.println(Thread.currentThread().getName() + "->" + num);
//通知其他线程，我+1完毕
this.notifyAll();
}
//-1
public synchronized void decrement() throws InterruptedException {
if (num == 0) {
//等待
this.wait();
}
num--;
System.out.println(Thread.currentThread().getName() + "->" + num);
//通知其他线程，我-1完毕
this.notifyAll();
}
}
问题存在，A、B、C、D四个线程是否安全！虚假唤醒（以下是官方文档解释）
解决方法，将if判断改为while循环即可
Lock版
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 线程之间的通信问题：生产者和消费者问题
* 线程交替执行 A B操作同一个变量 num=0
* A num+1
* B num-1
*/
public class demo01 {
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 num = 0;
Lock lock=new ReentrantLock();
Condition con= lock.newCondition();
//+1
public void increment() throws InterruptedException {
lock.lock();
try {
while (num != 0) {
//等待
con.await();
}
num++;
System.out.println(Thread.currentThread().getName() + "->" + num);
//通知其他线程，我+1完毕
con.signalAll();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
//-1
public void decrement() throws InterruptedException {
lock.lock();
try {
while (num == 0) {
//等待
con.await();
}
num--;
System.out.println(Thread.currentThread().getName() + "->" + num);
//通知其他线程，我-1完毕
con.signalAll();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
Condition精准的通知和唤醒线程
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* A执行完调用B，B执行完调用C,C执行完调用A
*/
public class demo01 {
public static void main(String[] args) {
Data data = new Data();
new Thread(() -> {
for (int i = 0; i < 10; i++) {
data.printA();
}
}, "A").start();
new Thread(() -> {
for (int i = 0; i < 10; i++) {
data.printB();
}
}, "B").start();
new Thread(() -> {
for (int i = 0; i < 10; i++) {
data.printC();
}
}, "C").start();
}
}
class Data {
private Lock lock = new ReentrantLock();
private Condition con1 = lock.newCondition();
private Condition con2 = lock.newCondition();
private Condition con3 = lock.newCondition();
private int num = 1;
public void printA() {
lock.lock();
try {
while (num != 1) {
con1.await();
}
System.out.println(Thread.currentThread().getName() + "->" + num);
num = 2;
con2.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void printB() {
lock.lock();
try {
while (num != 2) {
con2.await();
}
System.out.println(Thread.currentThread().getName() + "->" + num);
num = 3;
con3.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void printC() {
lock.lock();
try {
while (num != 3) {
con3.await();
}
System.out.println(Thread.currentThread().getName() + "->" + num);
num = 1;
con1.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
八锁现象
如何判断锁的是谁！永远的知道什么是锁，所得到底是谁！
import java.util.concurrent.TimeUnit;
/**
* 8锁，就是关于锁的8个问题
* 1.标准情况下，两个线程先打印发短信还是打电话？ 1/发短信 2/打电话
* 2.sendSms延迟4s，两个线程先打印发短信还是打电话？ 1/发短信 2/打电话
*/
public class demo01 {
public static void main(String[] args) {
Phone phone = new Phone();
//锁的存在
new Thread(() -> {
phone.sendSms();
}, "A").start();
//捕获
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(() -> {
phone.call();
}, "B").start();
}
}
class Phone {
//Synchronized 锁的对象是方法的调用者
//两个方法用的是同一个锁，谁先拿到谁执行
public synchronized void sendSms() {
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public synchronized void call() {
System.out.println("打电话");
}
}
import java.util.concurrent.TimeUnit;
/**
* 8锁，就是关于锁的8个问题
* 3.增加了一个普通方法后，发短信还是hello？ 先执行普通方法
* 4.两个对象，两个同步方法，先执行打电话还是发短信？ 先打电话
*/
public class demo01 {
public static void main(String[] args) {
//两个对象，两个调用者，两把锁
Phone2 phone1 = new Phone2();
Phone2 phone2 = new Phone2();
//锁的存在
new Thread(() -> {
phone1.sendSms();
}, "A").start();
//捕获
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(() -> {
phone2.call();
}, "B").start();
}
}
class Phone2 {
//Synchronized 锁的对象是方法的调用者
//两个方法用的是同一个锁，谁先拿到谁执行
public synchronized void sendSms() {
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public synchronized void call() {
System.out.println("打电话");
}
//这里没有锁，不是同步方法，不受锁的影响
public void hello() {
System.out.println("hello");
}
}
import java.util.concurrent.TimeUnit;
/**
* 8锁，就是关于锁的8个问题
* 5.增加两个静态的同步方法，只有一个对象，先打印发短信还是打电话？ 先打印发短信
* 6.两个对象，增加两个静态的同步方法，先打印发短信还是打电话？ 先打印发短信
*/
public class demo01 {
public static void main(String[] args) {
//两个对象的Class类模板只有一个，static锁的是Class
Phone3 phone1 = new Phone3();
Phone3 phone2 = new Phone3();
//锁的存在
new Thread(() -> {
phone1.sendSms();
}, "A").start();
//捕获
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(() -> {
phone2.call();
}, "B").start();
}
}
class Phone3 {
//Synchronized 锁的对象是方法的调用者
//static 类一加载就有了，锁的是Class
public static synchronized void sendSms() {
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public static synchronized void call() {
System.out.println("打电话");
}
}
import java.util.concurrent.TimeUnit;
/**
* 8锁，就是关于锁的8个问题
* 7.1个静态的同步方法，一个普通的同步方法，一个对象，先执行哪一个？ 打电话
* 8.1个静态的同步方法，一个普通的同步方法，两个对象，先执行哪一个？ 打电话
*/
public class demo01 {
public static void main(String[] args) {
//两个对象的Class类模板只有一个，static锁的是Class
Phone4 phone1 = new Phone4();
Phone4 phone2 = new Phone4();
//锁的存在
new Thread(() -> {
phone1.sendSms();
}, "A").start();
//捕获
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(() -> {
phone2.call();
}, "B").start();
}
}
class Phone4 {
//静态同步方法 锁的是Class类模板
public static synchronized void sendSms() {
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
//普通同步方法 锁的是调用者
public synchronized void call() {
System.out.println("打电话");
}
}
小结
new this具体的一个Phone
static Class唯一的一个模板
集合类不安全
List不安全
import java.util.List;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArrayList;
//并发下ArrayList不安全
/**
* 解决方案：
* 1.List list = new Vector<>();
* 2.List list = Collections.synchronizedList(new ArrayList<>());
* 3.List list = new CopyOnWriteArrayList<>();
*/
public class demo01 {
public static void main(String[] args) {
//多个线程调用的时候，list，读取的时候是固定的，写入的时候存在覆盖问题
List<String> list = new ArrayList<>();
// CopyOnWrite 写入时复制（COW）计算机程序设计领域的一种优化策略
// CopyOnWriteArrayList比Vector好在哪里？
// Vector存在Synchronized锁会降低效率
// 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();
}
}
}
Set不安全
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArraySet;
/**
* 解决方案：
* 1.List list = Collections.synchronizedSet(new HashSet<>());
* 2.List list = new CopyOnWriteArraySet<>();
*/
public class Demo {
public static void main(String[] args) {
Set<String> set=new HashSet<>();
for (int i = 0; i < 10; i++) {
new Thread(()->{
set.add(UUID.randomUUID().toString().substring(0,5));
System.out.println(set);
},String.valueOf(i)).start();
}
}
}
HashSet底层是什么？
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不安全
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
/**
* 解决方案：
* 1.Map map=new ConcurrentHashMap<>();
*/
public class demo01 {
public static void main(String[] args) {
//map是这样用的吗？ 不是，工作中不用HashMap
//默认等价于什么？ new HashMap()(16,0.75);
Map<String,String> map=new HashMap<>();
for (int i = 0; i < 10; i++) {
new Thread(()->{
map.put(Thread.currentThread().getName(),UUID.randomUUID().toString().substring(0,5));
System.out.println(map);
},String.valueOf(i)).start();
}
}
}
Callable
1.可以有返回值
2.可以抛出异常
3.方法不同，run()/call()
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class demo01 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//new Thread(new Runnable()).start();
//new Thread(new FutureTask()).start();
//new Thread(new FutureTask(Callable)).start();
MyThread thread = new MyThread();
FutureTask fk = new FutureTask(thread);
new Thread(fk, "A").start();
new Thread(fk, "B").start();//结果会被缓存，效率高
Integer i = (Integer) fk.get();//这个get方法可能会产生阻塞，把它放在最后
System.out.println(i);
}
}
class MyThread implements Callable<Integer> {
@Override
public Integer call() {
System.out.println("call()");
return 1024;
}
}
常用的辅助类
CountDownLatch
import java.util.concurrent.CountDownLatch;
//减法计数器
public class demo01 {
public static void main(String[] args) throws InterruptedException {
//总数是6，必须要执行任务的时候，再使用！
CountDownLatch cd = new CountDownLatch(6);
for (int i = 1; i < 6; i++) {
new Thread(() -> {
System.out.print(Thread.currentThread().getName() + "Go Out");
cd.countDown();//数量减一
}, String.valueOf(i)).start();
}
cd.await();//等待计数器归零
System.out.println("Close");
}
}
CyclicBarrier
//加法计数器
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
/**
* 满足设置线程数才可以停止线程
*/
public class Test {
public static void main(String[] args) {
CyclicBarrier cy=new CyclicBarrier(7,()->{
System.out.println("停止");
});
for (int i = 0; i < 7; i++) {
final int temp=i;
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"--第"+temp+"个线程");
try {
cy.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}).start();
}
}
}
Semaphore
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
//3车六车位
public class demo01 {
public static void main(String[] args) throws InterruptedException {
//抢车位
Semaphore s = new Semaphore(3);
for (int i = 1; i <= 6; i++) {
new Thread(() -> {
//acquire() 得到
try {
s.acquire();
System.out.println(Thread.currentThread().getName() + "抢到车位");
TimeUnit.SECONDS.sleep(2);
System.out.println(Thread.currentThread().getName() + "离开车位");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
s.release();//释放
}
}, String.valueOf(i)).start();
}
}
}
读写锁
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* 独占锁（写锁） 一次只能被一个线程占有
* 共享锁（读锁） 多个线程可以同时占有
* ReadWriteLock读写锁
* 读-读 可以共存
* 读-写 不能共存
* 写-写 不能共存
*/
public class demo01 {
public static void main(String[] args) {
MyCacheLock mcl = new MyCacheLock();
//写入
for (int i = 1; i <= 5; i++) {
final int temp = i;
new Thread(() -> {
mcl.put(temp + "", temp + "");
}, String.valueOf(i)).start();
}
//读取
for (int i = 1; i <= 5; i++) {
final int temp = i;
new Thread(() -> {
mcl.get(temp + "");
}, String.valueOf(i)).start();
}
}
}
/**
* 加锁
*/
class MyCacheLock {
private volatile Map<String, Object> map = new HashMap<>();
//读写锁
private ReadWriteLock rwl = new ReentrantReadWriteLock();
//存，写
public void put(String key, Object value) {
rwl.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 {
rwl.writeLock().unlock();
}
}
//取，读
public void get(String key) {
rwl.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 {
rwl.readLock().unlock();
}
}
}
/**
* 自定义缓存
* 会产生读写混乱
*/
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");
}
}
阻塞队列
什么情况下我们会使用阻塞队列：多线程并发处理，线程池
package Demo;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;
public class demo01 {
public static void main(String[] args) throws InterruptedException {
test1();
}
/**
* 抛出异常
*/
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.element());//获取队首元素
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"));
System.out.println("************************");
System.out.println(blockingQueue.peek());//获取队首元素
System.out.println(blockingQueue.poll());
System.out.println(blockingQueue.poll());
System.out.println(blockingQueue.poll());
System.out.println(blockingQueue.poll());
}
/**
* 等待，阻塞（一直阻塞）
*/
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("************************");
System.out.println(blockingQueue.take());
System.out.println(blockingQueue.take());
System.out.println(blockingQueue.take());
System.out.println(blockingQueue.take());//没有这个元素一直阻塞
}
/**
* 等待，阻塞（等待超时）
*/
public static void test4() {
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());
System.out.println(blockingQueue.poll(2, TimeUnit.SECONDS));
}
}
同步队列
package Demo;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;
//同步队列和其他的BlockingQueue不一样，SynchronousQueue不存储元素，put了一个元素，必须从里面先take取出来，否则不能再put进去值
public class demo01 {
public static void main(String[] args) throws InterruptedException {
BlockingQueue<String> blockingQeque = new SynchronousQueue<>();
new Thread(() -> {
try {
System.out.println(Thread.currentThread().getName() + " put 1");
blockingQeque.put("1");
System.out.println(Thread.currentThread().getName() + " put 2");
blockingQeque.put("2");
System.out.println(Thread.currentThread().getName() + " put 3");
blockingQeque.put("3");
} catch (InterruptedException e) {
e.printStackTrace();
}
}, "T1").start();
new Thread(() -> {
try {
TimeUnit.SECONDS.sleep(3);
System.out.println(Thread.currentThread().getName() + "->" + blockingQeque.take());
TimeUnit.SECONDS.sleep(3);
System.out.println(Thread.currentThread().getName() + "->" + blockingQeque.take());
TimeUnit.SECONDS.sleep(3);
System.out.println(Thread.currentThread().getName() + "->" + blockingQeque.take());
} catch (InterruptedException e) {
e.printStackTrace();
}
}, "T2").start();
}
}
线程池（重点）
线程池：三大方法、七大参数、四种拒绝策略
池化技术
程序运行的本质：占用系统的资源！优化资源的使用->池化技术
池化技术：事先准备好一些资源，有人要用就来我这里拿，用完之后还给我。
线程池的好处：
1.降低资源的消耗
2.提高响应的速度
3.方便管理
线程复用、可以控制最大并发数、管理线程
三大方法
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//Executors工具类，三大方法
public class demo01 {
public static void main(String[] args) throws InterruptedException {
ExecutorService executorService = Executors.newSingleThreadExecutor();//单个线程
//ExecutorService executorService = Executors.newFixedThreadPool(5);//创建一个固定的线程池的大小
//ExecutorService executorService = Executors.newCachedThreadPool();//可伸缩的，遇强则强，遇弱则弱
try {
for (int i = 0; i < 100; i++) {
//使用了线程池之后，使用线程池来创建线程
executorService.execute(() -> {
System.out.println(Thread.currentThread().getName() + " ok");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//线程池用完，程序结束，关闭线程池
executorService.shutdown();
}
}
}
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;
}
自定义线程池及四种拒绝策略
import java.util.concurrent.*;
class test {
public static void main(String[] args) {
ExecutorService threadPool = new ThreadPoolExecutor(
2,
/**
* 最大线程数如何定义？
* 1.CPU密集型 计算机几核设置为几，可以保持效率最高
* Runtime.getRuntime().availableProcessors();
* 2.IO密集型 判断程序中十分消耗IO的线程，一般设置为两倍
*/
5,
3,
TimeUnit.SECONDS,
new LinkedBlockingDeque<>(3),
Executors.defaultThreadFactory(),
/**
* 四种拒绝策略
* new ThreadPoolExecutor.AbortPolicy() //超过最大负载，不处理后续载入线程，抛出异常
* new ThreadPoolExecutor.CallerRunsPolicy() //超过最大负载，后续载入线程返回原线程处
* new ThreadPoolExecutor.DiscardPolicy() //超过最大负载，丢弃后续载入线程，不抛出异常
* new ThreadPoolExecutor.DiscardOldestPolicy() //超出最大负载，后续载入线程尝试和最早线程竞争，不抛出异常
*/
);
try {
for (int i = 0; i < 5; i++) {
threadPool.execute(() -> {
System.out.println(Thread.currentThread().getName() + " ok");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
threadPool.shutdown();
}
}
}
四大函数式接口
函数式接口：只有一个方法的接口
import java.util.function.Function;
/**
* Function 函数式接口，有一个输入参数，有一个输出参数
*/
class test {
public static void main(String[] args) {
Function<String, String> function = new Function<String, String>() {
@Override
public String apply(String str) {
return str;
}
};
/**
* lambda表达式简化
* Function function = (str) -> {
* return str;
* };
*/
System.out.println(function.apply("test"));
}
}
import java.util.function.Predicate;
/**
* Predicate 断定型接口，返回值只能是布尔值
*/
class test {
public static void main(String[] args) {
Predicate<String> predicate = new Predicate<String>() {
@Override
public boolean test(String str) {
return str.isEmpty();
}
};
/**
* lambda表达式简化
* Predicate predicate = (str) -> {
* return str.isEmpty();
* };
*/
System.out.println(predicate.test("test"));
}
}
import java.util.function.Consumer;
/**
* Consumer 消费型接口，只有输入没有返回值
*/
class test {
public static void main(String[] args) {
Consumer<String> consumer = new Consumer<String>() {
@Override
public void accept(String str) {
System.out.println(str);
}
};
/**
* Consumer consumer=(str)->{
* System.out.println(str);
* };
*/
consumer.accept("test");
}
}
import java.util.function.Supplier;
/**
* Supplier 供给型接口，没有参数，只有返回值
*/
class test {
public static void main(String[] args) {
Supplier<Integer> supplier = new Supplier<Integer>() {
@Override
public Integer get() {
return 1024;
}
};
/**
* Supplier supplier=(str)->{
* System.out.println(str);
* };
*/
System.out.println(supplier.get());
}
}
Stream流式编程
什么是流式计算
大数据：存储+计算
集合、MySQL本质就是存储东西
计算都应该交给流来操作！
import java.util.Arrays;
import java.util.List;
/**
* 题目要求：一分钟内完成此题，只能用一行代码实现
* 现在有五个用户！
* 筛选：
* 1.ID必须是奇数
* 2.年龄必须大于21
* 3.用户名转为大写字母
* 4.用户名字母倒着排序
* 5.只输出一个用户
*/
class test {
public static void main(String[] args) {
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);
//集合就是存储
List<User> list = Arrays.asList(u1, u2, u3, u4, u5);
//计算交给Stream流
//lambda表达式、链式编程、函数式接口、Stream流式计算
list.stream()
.filter(u->{return u.getId()%2==1;})
.filter(u->{return u.getAge()>21;})
.map(u->{return u.getName().toUpperCase();})
.limit(1)
.forEach(System.out::println);
}
}
ForkJoin
ForkJoin在1.7之后，并行执行任务，提高效率（大数据量为前提）
ForkJoin特点：工作窃取
import java.util.concurrent.RecursiveTask;
/**
* 求和计算任务
*
* 如何使用ForkJoin
* 1.forkjoinpool通过它来执行
* 2.计算任务forkjoinpool.execute(ForkJoinTask task)
*/
public class ForkJoinDemo extends RecursiveTask<Long> {
private Long start;
private Long end;
//临界值
private Long temp = 10_0000L;
ForkJoinDemo(Long start, Long end) {
this.start = start;
this.end = end;
}
public void test() {
if ((end - start) > temp) {
//分支合并计算
}
}
@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;
ForkJoinDemo task1 = new ForkJoinDemo(start, middle);
task1.fork(); //拆分任务将任务压入线程队列
ForkJoinDemo task2 = new ForkJoinDemo(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;
class test {
public static void main(String[] args) throws ExecutionException, InterruptedException {
test1();
test2();
test3();
}
public static void test1() {
Long sum = 0L;
long start = System.currentTimeMillis();
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();
ForkJoinTask<Long> 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, Long::sum);
long end = System.currentTimeMillis();
System.out.println("sum=" + sum + "时间为：" + (end - start));
}
}
异步回调
Future设计初衷：对将来的某个事件的结果进行建模
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
/**
* 异步调用：
* 异步执行
* 正确回调
* 失败回调
*/
class test {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//没有返回值的异步回调
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("111");
completableFuture.get();//获取阻塞执行结果
//有返回值的supplyAsync异步回调
CompletableFuture<Integer> completableFuture1 = CompletableFuture.supplyAsync(() -> {
System.out.println(Thread.currentThread().getName() + "supplyAsync->Integer");
int i = 10 / 0;
return 1024;
});
System.out.println(completableFuture1.whenComplete((t, u) -> {
System.out.println("t->" + t); // 正常的返回结果
System.out.println("u->" + u); // 错误信息
}).exceptionally((e) -> {
System.out.println(e.getMessage());
return 404;
}).get());
}
}
什么是JMM
概念：
Java内存模型(Java Memory Model，JMM)JMM主要是为了规定了线程和内存之间的一些关系。根据JMM的设计，系统存在一个主内存(Main Memory)，Java中所有变量都储存在主存中，对于所有线程都是共享的。每条线程都有自己的工作内存(Working Memory)，工作内存中保存的是主存中某些变量的拷贝，线程对所有变量的操作都是在工作内存中进行，线程之间无法相互直接访问，变量传递均需要通过主存完成。
特性：
原子性
指一个操作是不可中断的，即使是多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程干扰
可见性
指当一个线程修改了某一个共享变量的值，其他线程是否能够立即知道这个修改。显然，对于串行程序来说，可见性问题 是不存在。因为你在任何一个操作步骤中修改某个变量，那么在后续的步骤中，读取这个变量的值，一定是修改后的新值。但是这个问题在并行程序中就不见得了。如果一个线程修改了某一个全局变量，那么其他线程未必可以马上知道这个改动
有序性
对于一个线程的执行代码而言，我们总是习惯地认为代码的执行时从先往后，依次执行的。这样的理解也不能说完全错误，因为就一个线程而言，确实会这样。但是在并发时，程序的执行可能就会出现乱序。给人直观的感觉就是：写在前面的代码，会在后面执行。有序性问题的原因是因为程序在执行时，可能会进行指令重排，重排后的指令与原指令的顺序未必一致
内存间交互
关于主内存与工作内存之间的具体交互协议，即一个变量如何从主内存拷贝到工作内存，如何从工作内存同步回主内存子类的细节实现，java内存模型定义了八种操作：（这八个操作都具有原子性）
lock（锁定）：作用于主内存的变量，把一个变量标识为一条线程独占的状态。
unclock（解锁）：作用于主内存的变量，把一个处于锁定的状态释放出来。
read（读取）：作用于主内存的变量，把一个变量的值从主内存传输到线程的工作内存中
load（载入）：作用于工作内存的变量，把read操作从主内存 得到的变量值放入工作内存的变量副本中。
use（使用）：作用于工作内存的变量，把工作内存中一个变量的值传递给执行引擎，每当虚拟机遇到一个需要使用到变量的值的字节码指令时将会执行这个操作。
assign（赋值）：作用于工作内存的变量，把一个从执行引擎接收到的值 赋值给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。
store（存储）：作用于工作内存的变量，把工作内存中的一个变量的值传递到主内存，以便write操作使用。
write（写入）：作用于主内存的变量，把store操作从工作内存中得到的变量的值放入主内存的变量中。
关于JMM的一些同步约定
1.线程解锁前，必须把共享变量立刻刷回主存
2.线程加锁前，必须读取主存中的最新值到工作内存中
3.加锁和解锁是同一把锁
Volatile
Volatile是Java虚拟机提供轻量级的同步机制
1.保证可见性
2.不保证原子性
3.禁止指令重排
保证可见性
import java.util.concurrent.TimeUnit;
class Demo {
//不加volatile程序会陷入死循环
//加volatile可以保证可见性
private volatile static int num = 0;
public static void main(String[] args) {
new Thread(() -> {
while (num == 0) {
}
}).start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
num = 1;
System.out.println(num);
}
}
不保证原子性
原子性：ACID原则，不可分割
线程A在执行任务的时候，不能被打扰的，也不能被分割，要么同时成功，要么同时失败
class Demo {
private static int num = 0;
public static void add() {
num++;//不是一个原子性操作
}
public static void main(String[] args) {
//理论上num结果是20000
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);
}
}
使用原子类解决原子性问题
class Demo {
private volatile static AtomicInteger num = new AtomicInteger();
public static void add() {
num.getAndIncrement();
}
public static void main(String[] args) {
//理论上num结果是20000
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);
}
}
指令重排
什么是指令重排：计算机并不是按照你写的程序去执行
源代码–>编译器优化的重排–>指令并行也可能会重排–>执行
处理器在进行指令重排的时候，考虑数据之间的依赖性
volatile可以避免指令重排
内存屏障、CPU指令 作用：
1.保证特定的操作的执行顺序
2.可以保证某些变量的内存可见性（利用这些特性volatile实现了可见性）
单例设计模式：
为了避免其他程序过多建立该类对象，先禁止其他程序建立该类对象。
还为了让其他程序可以访问到该类对象，在本类中自定义一个对象。
为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。
- 代码实现：
①将构造函数私有化
②在类中创建一个本类对象
③提供一个方法可以获取到该对象
//例：饿汉式：载入内存时初始化对象。
class Single {
private Single() {
}
private static Single s = new Single();
public static Single getInstance() {
return s;
}
}
//懒汉式：对象被方法调用时才初始化，也称为对象的延时加载。
class Single {
private Single() {
}
private static Single s = null;
public static Single getInstance() {
if (s == null)
s = new Single();
}
}
DCL懒汉式
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
//懒汉式单例
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
public class LazyMan {
private static boolean code = false;
private LazyMan() {
synchronized (LazyMan.class) {
if (code == false) {
code = true;
} else {
throw new RuntimeException("不要试图使用反射破坏异常");
}
}
}
private volatile static LazyMan lazyMan;
//双重检测锁模式 懒汉式单例 DCL懒汉式
public static LazyMan getInstance() {
if (lazyMan == null) {
synchronized (LazyMan.class) {
if (lazyMan == null) {
/**
* 1.分配内存空间
* 2.执行构造方法，初始化对象
* 3.把对象指向这个空间
*/
lazyMan = new LazyMan(); //不是一个原子性操作
}
}
}
return lazyMan;
}
//反射
public static void main(String[] args) throws Exception {
Field code = LazyMan.class.getDeclaredField("code");
code.setAccessible(true);
Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
declaredConstructor.setAccessible(true);
LazyMan instance = declaredConstructor.newInstance();
code.set(instance, false);
LazyMan instance2 = declaredConstructor.newInstance();
}
}
静态内部类
public class Holder {
private Holder() {
}
public static Holder getInstance() {
return InnerClass.HOLDER;
}
public static class InnerClass {
private static final Holder HOLDER = new Holder();
}
}
单例不安全，存在反射
import java.lang.reflect.Constructor;
//enum本身也是一个Class类
public enum EnumSingle {
INSTANCE;
public EnumSingle getInstance(){
return INSTANCE;
}
}
class Test{
public static void main(String[] args) throws Exception {
EnumSingle instance1=EnumSingle.INSTANCE;
Constructor<EnumSingle> constructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
constructor.setAccessible(true);
EnumSingle instance2=constructor.newInstance();
System.out.println(instance1);
System.out.println(instance2 );
}
}
深入理解CAS
import java.util.concurrent.atomic.AtomicInteger;
public class CASDemo {
//CAS compareAndSet 比较并交换
public static void main(String[] args) {
AtomicInteger atomicInteger = new AtomicInteger(2000);
atomicInteger.getAndIncrement();//相当于++
//如果达到期望值那么就更新，否则就不更新，CAS是CPU的并发原语
System.out.println(atomicInteger.compareAndSet(2020, 2021));
System.out.println(atomicInteger.get());
atomicInteger.getAndIncrement();
System.out.println(atomicInteger.compareAndSet(2020, 2021));
System.out.println(atomicInteger.get());
}
}
CAS：比较当前工作内存中的值和主内存中的值，如果这个值是期望的，那么则执行操作！如果不是就一直循环！
缺点：
1.循环会耗时
2.一次性只能保证一个共享变量的原子性
3.ABA问题
CAS：ABA问题（狸猫换太子）
import java.util.concurrent.atomic.AtomicInteger;
public class CASDemo {
//CAS compareAndSet 比较并交换
public static void main(String[] args) {
AtomicInteger atomicInteger = new AtomicInteger(2020);
//如果达到期望值那么就更新，否则就不更新，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, 2021));
System.out.println(atomicInteger.get());
}
}
原子引用
解决ABA问题，引入原子引用！对应的思想：乐观锁
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicStampedReference;
public class CASDemo {
//CAS compareAndSet 比较并交换
public static void main(String[] args) {
//AtomicStampedReference 注意，如果泛型是一个包装类，注意对象的引用问题
//正常在业务操作，这里面比较的都是一个个对象
AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(1, 1);
new Thread(() -> {
int stamp = atomicStampedReference.getStamp();//获得版本号
System.out.println("a1->" + stamp);
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(atomicStampedReference.compareAndSet(1, 2, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
System.out.println("a2->" + atomicStampedReference.getStamp());
System.out.println(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();
}
System.out.println(atomicStampedReference.compareAndSet(1, 2, stamp, stamp + 1));
System.out.println("b1->" + stamp);
}, "b").start();
}
}
Integer使用了对象缓存机制，默认范围是-128~127，推荐使用静态工厂方法valueOf获取对象实例，而不是new，因为valueOF使用缓存，而new一定胡创建新的对象分配新的内存空间
各种锁的理解
公平锁、非公平锁
公平锁：非常公平，不能够插队，必须先来后到！
非公平锁：非常不公平，可以插队（默认都是非公平）
public ReentrantLock() {
sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
可重入锁（递归锁）
拿到了外面的锁，就可以自动获得里面的锁
//Synchronized版
public class Demo {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(() -> {
phone.sms();
}, "A").start();
new Thread(() -> {
phone.call();
}, "B").start();
}
}
class Phone {
public synchronized void sms() {
System.out.println(Thread.currentThread().getName() + " sms");
call();
}
public synchronized void call() {
System.out.println(Thread.currentThread().getName() + " call");
}
}
//Lock版
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Demo {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(() -> {
phone.sms();
}, "A").start();
new Thread(() -> {
phone.call();
}, "B").start();
}
}
class Phone {
Lock lock = new ReentrantLock();
public void sms() {
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + " sms");
call();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void call() {
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + " call");
call();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
自旋锁
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
/**
* 自旋锁
*/
class Demo {
AtomicReference<Thread> 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() + "-->myUnLock");
atomicReference.compareAndSet(thread, null);
}
}
class Test {
public static void main(String[] args) throws InterruptedException {
Demo d = new Demo();
new Thread(() -> {
d.myLock();
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
d.myUnLock();
}
}, "T1").start();
TimeUnit.SECONDS.sleep(1);
new Thread(() -> {
d.myLock();
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
d.myUnLock();
}
}, "T2").start();
}
}
死锁排查
死锁的四个前提条件：
互斥条件：进程要求对所分配的资源（如打印机）进行排他性控制，即在一段时间内某资源仅为一个进程所占有。此时若有其他进程请求该资源，则请求进程只能等待。
不剥夺条件：进程所获得的资源在未使用完毕之前，不能被其他进程强行夺走，即只能由获得该资源的进程自己来释放（只能是主动释放)。
请求和保持条件：进程已经保持了至少一个资源，但又提出了新的资源请求，而该资源已被其他进程占有，此时请求进程被阻塞，但对自己已获得的资源保持不放。
循环等待条件：存在一种进程资源的循环等待链，链中每一个进程已获得的资源同时被链中下一个进程所请求。即存在一个处于等待状态的进程集合{Pl, P2, …, pn}，其中Pi等 待的资源被P(i+1)占有（i=0, 1, …, n-1)，Pn等待的资源被P0占有。
解决死锁
1.使用jps -l定位进程号
2.使用jstack 进程号找到死锁问题