JUC-并发源码学习
JUC并发包源码分析(1.8)
线程的一些状态
线程之间状态的跳转
Executor源码解析
ThreadPoolExecutor源码解析
1. 什么是JUC
JUC就是
java.util工具包
业务: 普通的线程代码 Thread
Runnable: 没有返回值、效率相比于Callable相对较低
2. 线程和进程
线程和进程
进程: 就是一个程序 比如QQ,鼠标驱动
一个进程可以包含多个线程，至少包含一个线程！
Java默认有几个线程？2个线程！ main线程、GC线程
线程: 开了一个Typora等
对于Java而言：Thread、Runable、Callable进行开启线程的，我们之前。
Java是没有权限去开启线程、操作硬件的，这是一个native的一个本地方法，它调用的底层的C++代码。
并发和并行
并发： 多线程操作同一个资源。
- CPU 只有一核，模拟出来多条线程，天下武功，唯快不破。那么我们就可以使用CPU快速交替，来模拟多线程。
并行： 多个人一起行走
- CPU多核，多个线程可以同时执行。 我们可以使用线程池
并发编程的本质: 充分利用CPU的资源
线程有几个状态
public enum State {
/**
* Thread state for a thread which has not yet started.
*/
//运行
NEW,
/**
* Thread state for a runnable thread. A thread in the runnable
* state is executing in the Java virtual machine but it may
* be waiting for other resources from the operating system
* such as processor.
*/
//运行
RUNNABLE,
/**
* Thread state for a thread blocked waiting for a monitor lock.
* A thread in the blocked state is waiting for a monitor lock
* to enter a synchronized block/method or
* reenter a synchronized block/method after calling
* {@link Object#wait() Object.wait}.
*/
//阻塞
BLOCKED,
/**
* Thread state for a waiting thread.
* A thread is in the waiting state due to calling one of the
* following methods:
*
* - {@link Object#wait() Object.wait} with no timeout
* - {@link #join() Thread.join} with no timeout
* - {@link LockSupport#park() LockSupport.park}
*
*
* A thread in the waiting state is waiting for another thread to
* perform a particular action.
*
* For example, a thread that has called Object.wait()
* on an object is waiting for another thread to call
* Object.notify() or Object.notifyAll() on
* that object. A thread that has called Thread.join()
* is waiting for a specified thread to terminate.
*/
//等待
WAITING,
/**
* Thread state for a waiting thread with a specified waiting time.
* A thread is in the timed waiting state due to calling one of
* the following methods with a specified positive waiting time:
*
* - {@link #sleep Thread.sleep}
* - {@link Object#wait(long) Object.wait} with timeout
* - {@link #join(long) Thread.join} with timeout
* - {@link LockSupport#parkNanos LockSupport.parkNanos}
* - {@link LockSupport#parkUntil LockSupport.parkUntil}
*
*/
//超时等待
TIMED_WAITING,
/**
* Thread state for a terminated thread.
* The thread has completed execution.
*/
//终止
TERMINATED;
}
wait/sleep的区别
1、来自不同的类
wait => Object
sleep => Thread
一般情况企业中使用休眠是：
TimeUnit.DAYS.sleep(1)//休眠一天
TimeUnit.SECONDS.sleep(1) //休眠一秒
2、关于锁的释放
wait 会释放锁；
sleep 睡眠，不会释放锁；
3、使用的范围是不同的
wait 必须在同步代码块中；
sleep 可以在任何地方睡；
4、是否需要捕获异常
wait是不需要捕获异常；
sleep必须要捕获异常；
3. Lock锁(重点)
普通的加锁 (Synchronize)
public class SaleTicketDemo01 {
public static void main(String[] args) {
//并发: 多个线程操作同一个资源类
Ticket ticket = new Ticket();
//@FunctionalInterface 函数式接口, jdk1.8 lambda表达式 (参数)->{代码}
new Thread(()-> {
for (int i = 0; i < 60; i++) {
ticket.sale();
}
},"A").start();
new Thread(()-> {
for (int i = 0; i < 60; i++) {
ticket.sale();
}
},"B").start();
new Thread(()-> {
for (int i = 0; i < 60; i++) {
ticket.sale();
}
},"C").start();
}
}
//资源类 OOP的思想
class Ticket{
//属性,方法
private int nummber = 50;
//买票的方式
public synchronized void sale(){
if (nummber > 0){
System.err.println(Thread.currentThread().getName() + "卖出了" + (nummber--) + "票,剩余" + nummber);
}
}
}
Lock锁
public class SaleTicketDemo02 {
public static void main(String[] args) {
//并发: 多个线程操作同一个资源类
Ticket2 ticket = new Ticket2();
//@FunctionalInterface 函数式接口, jdk1.8 lambda表达式 (参数)->{代码}
new Thread(()-> { for (int i = 0; i < 60; i++) ticket.sale(); },"A").start();
new Thread(()-> { for (int i = 0; i < 60; i++) ticket.sale(); },"B").start();
new Thread(()-> { for (int i = 0; i < 60; i++) ticket.sale(); },"C").start();
}
}
//Lock锁 三部曲
//1. new ReentrantLock();
//2. lock.lock();加锁
//3. lock.unlock();解锁
class Ticket2{
//属性,方法
private int nummber = 50;
//重入锁
Lock lock = new ReentrantLock();
//买票的方式
public void sale(){
//加锁
lock.lock();
try {
if (nummber > 0){
System.err.println(Thread.currentThread().getName() + "卖出了" + (nummber--) + "票,剩余" + nummber);
}
} catch (Exception e) {
e.printStackTrace();
}finally {
//解锁
lock.unlock();
}
}
}
Lock接口
公平锁： 十分公平，必须先来后到~；
非公平锁： 十分不公平，可以插队；(默认为非公平锁)
public class SaleTicketDemo02 {
public static void main(String[] args) {
//多线程操作
//并发：多线程操作同一个资源类，把资源类丢入线程
Ticket2 ticket = new Ticket2();
new Thread(()->{for(int i=0;i<40;i++) ticket.sale(); },"A").start();
new Thread(()->{for(int i=0;i<40;i++) ticket.sale(); },"B").start();
new Thread(()->{for(int i=0;i<40;i++) ticket.sale(); },"C").start();
}
}
//lock三部曲
//1、 Lock lock=new ReentrantLock();
//2、 lock.lock() 加锁
//3、 finally=> 解锁：lock.unlock();
class Ticket2{
private int number=50;
Lock lock=new ReentrantLock();
//卖票的方式
// 使用Lock 锁
public void sale(){
//加锁
lock.lock();
try {
//业务代码
if(number>=0){
System.out.println(Thread.currentThread().getName()+" 卖出了第"+number+" 张票,剩余："+number+" 张票");
number--;
}
}catch (Exception e) {
e.printStackTrace();
}
finally {
//解锁
lock.unlock();
}
}
}
Synchronized 和 Lock区别
1、Synchronized 内置的Java关键字，Lock是一个Java类
2、Synchronized 无法判断获取锁的状态，Lock可以判断
3、Synchronized 会自动释放锁，lock必须要手动加锁和手动释放锁！可能会遇到死锁
4、Synchronized 线程1(获得锁->阻塞)、线程2(等待)；
lock就不一定会一直等待下去，lock会有一个trylock去尝试获取锁，不会造成长久的等待。
5、Synchronized 是可重入锁，不可以中断的，非公平的；Lock，可重入的，可以判断锁，可以自己设置公平锁和非公平锁；
6、Synchronized 适合锁少量的代码同步问题，Lock适合锁大量的同步代码；
4. 生产者和消费者问题
Synchronized wait notify可以实现，该方法是传统版本；
我们这次使用lock版本
Synchronized版本
public class A {
public static void main(String[] args) {
Data data = new Data();
new Thread(()->{for(int i=0;i<10;i++) {
try {
data.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"A").start();
new Thread(()->{for(int i=0;i<10;i++) {
try {
data.decrement();
} catch (InterruptedException e) {
e.printStackTrace();
}
}},"B").start();
}
}
class Data{
//数字 资源类
private int number = 0;
//+1
public synchronized void increment() throws InterruptedException {
if(number!=0){
//等待操作
this.wait();
}
number++;
System.out.println(Thread.currentThread().getName()+"=>"+number);
//通知其他线程 我+1完毕了
this.notifyAll();
}
//-1
public synchronized void decrement() throws InterruptedException {
if(number==0){
//等待操作
this.wait();
}
number--;
System.out.println(Thread.currentThread().getName()+"=>"+number);
//通知其他线程 我-1完毕了
this.notifyAll();
}
}
存在的问题: 目前是有两个线程 但当有四个线程时会出现
解决方案: if 改为while即可，防止虚假唤醒
JUC版本的生产者和消费者问题
await、signal 替换 wait、notify
通过Lock找到Condition
public class B {
public static void main(String[] args) {
Data2 data = new Data2();
new Thread(()->{for(int i=0;i<10;i++) {
data.increment();
}
},"A").start();
new Thread(()->{for(int i=0;i<10;i++) {
data.decrement();
}},"B").start();
new Thread(()->{for(int i=0;i<10;i++) {
data.increment();
}
},"C").start();
new Thread(()->{for(int i=0;i<10;i++) {
data.decrement();
}
},"D").start();
}
}
class Data2{
//数字 资源类
private int number = 0;
//lock锁
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
//+1
public void increment() {
lock.lock();
try{
//业务
while (number!=0){
//等待操作
condition.await();
}
number++;
System.out.println(Thread.currentThread().getName()+"=>"+number);
//通知其他线程 我+1完毕了
condition.signalAll();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
//-1
public void decrement() {
lock.lock();
try{
//业务
while (number==0){
//等待操作
condition.await();
}
number--;
System.out.println(Thread.currentThread().getName()+"=>"+number);
//通知其他线程 我+1完毕了
condition.signalAll();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
Condition的优势：精准的通知和唤醒的线程！
如果我们要指定通知的下一个进行顺序怎么办呢？ 我们可以使用Condition来指定通知进程~
/**
* 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++){
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 number = 1; //1A 2B 3C
public void printA(){
lock.lock();
try {
//业务 判断 -> 执行 -> 通知
while(number!=1){
//等待
condition1.await();
}
//操作
System.out.println(Thread.currentThread().getName()+",AAAAA");
//唤醒指定的线程
number=2;
condition2.signal(); // 唤醒2
} 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()+",BBBBB");
//唤醒3
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()+",CCCCC");
//唤醒1
number=1;
condition1.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
5. 8个锁现象
如何判断锁的是谁！锁到底锁的是谁？
锁会锁住：对象、Class
深刻理解我们的锁
-
第一种
发短信
打电话
-
第二种
我们让发短信 延迟4s
结果：还是先发短信，然后再打电话！
原因：并不是顺序执行！是因为synchronized 锁的对象是方法的调用！对于两个方法用的是同一个锁，谁先拿到谁先执行！另外一个则等待！
-
第三种
如果我们添加一个普通方法，那么先执行哪一个呢？
答案是：**先执行hello，然后再执行发短信！*原因是hello是一个*普通方法，不受synchronized锁的影响
-
第四种
如果我们使用的是两个对象，一个调用发短信，一个调用打电话，那么整个顺序是怎么样的呢？
答案是：先打电话，后发短信。原因：在发短信方法中延迟了4s，又因为synchronized锁的是对象，但是我们这使用的是两个对象，所以每个对象都有一把锁，所以不会造成锁的等待。正常执行
-
第五、六种
如果我们把synchronized的方法加上static变成静态方法！那么顺序又是怎么样的呢？
（1）我们先来使用一个对象调用两个方法！
答案是：先发短信,后打电话
（2）如果我们使用两个对象调用两个方法！
答案是：还是先发短信，后打电话
原因是什么呢？ 为什么加了static就始终前面一个对象先执行呢！为什么后面会等待呢？
原因是：对于static静态方法来说，对于整个类Class来说只有一份，对于不同的对象使用的是同一份方法，相当于这个方法是属于这个类的，如果静态static方法使用synchronized锁定，那么这个synchronized锁会锁住整个对象！不管多少个对象，对于静态的锁都只有一把锁，谁先拿到这个锁就先执行，其他的进程都需要等待！
-
第七种
如果我们使用一个静态同步方法、一个同步方法、一个对象调用顺序是什么？
明显答案是：先打电话，后发短信了。
因为一个锁的是Class类模板，一个锁的是对象调用者。后面那个打电话不需要等待发短信，直接运行就可以了。
-
第八种
如果我们使用一个静态同步方法、一个同步方法、两个对象调用顺序是什么呢？
当然答案是：先打电话、后发短信！
因为两个对象，一样的原因：两把锁锁的不是同一个东西，所以后面的第二个对象不需要等待第一个对象的执行。
小结
new 出来的 this 是具体的一个对象
static Class 是唯一的一个模板
6. 集合类不安全
List不安全
//java.util.ConcurrentModificationException 并发修改异常！
public class ListTest {
public static void main(String[] args) {
List<Object> arrayList = new ArrayList<>();
for(int i=1;i<=10;i++){
new Thread(()->{
arrayList.add(UUID.randomUUID().toString().substring(0,5));
System.out.println(arrayList);
},String.valueOf(i)).start();
}
}
}
会造成并发修改异常
ArrayList 在并发情况下是不安全的！
解决方案：
1、切换成Vector就是线程安全的啦！
2、使用Collections.synchronizedList(new ArrayList<>()); 工具类对List加锁
public class ListTest {
public static void main(String[] args) {
List<Object> arrayList = Collections.synchronizedList(new ArrayList<>());
for(int i=1;i<=10;i++){
new Thread(()->{
arrayList.add(UUID.randomUUID().toString().substring(0,5));
System.out.println(arrayList);
},String.valueOf(i)).start();
}
}
}
3、使用JUC中的包：List arrayList = new CopyOnWriteArrayList<>( )
public class ListTest {
public static void main(String[] args) {
List<Object> arrayList = new CopyOnWriteArrayList<>();
for(int i=1;i<=10;i++){
new Thread(()->{
arrayList.add(UUID.randomUUID().toString().substring(0,5));
System.out.println(arrayList);
},String.valueOf(i)).start();
}
}
}
CopyOnWriteArrayList：写入时复制！ COW 计算机程序设计领域的一种优化策略
多个线程调用的时候，list，读取的时候，固定的，写入（存在覆盖操作）；在写入的时候避免覆盖，造成数据错乱的问题；
CopyOnWriteArrayList比Vector厉害在哪里？
Vector底层是使用synchronized关键字来实现的：效率特别低下。
CopyOnWriteArrayList使用的是Lock锁，效率会更加高效
Set不安全
和List、Set同级的还有一个BlockingQueue 阻塞队列；
Set和List同理可得: 多线程情况下，普通的Set集合是线程不安全的；
解决方案还是两种：
- 使用Collections工具类的synchronized包装的Set类
- 使用CopyOnWriteArraySet 写入复制的JUC解决方案
//同理：java.util.ConcurrentModificationException
// 解决方案：
public class SetTest {
public static void main(String[] args) {
// Set hashSet = Collections.synchronizedSet(new HashSet<>()); //解决方案1
Set<String> hashSet = new CopyOnWriteArraySet<>();//解决方案2
for (int i = 1; i < 100; i++) {
new Thread(()->{
hashSet.add(UUID.randomUUID().toString().substring(0,5));
System.out.println(hashSet);
},String.valueOf(i)).start();
}
}
}
HashSet底层是什么
hashSet底层就是一个HashMap；
Map不安全
同样的HashMap基础类也存在并发修改异常！
public static void main(String[] args) {
//map 是这样用的吗？ 不是，工作中不使用这个
//默认等价什么？ new HashMap<>(16,0.75);
Map<String, String> map = new HashMap<>();
//加载因子、初始化容量
for (int i = 1; i < 100; i++) {
new Thread(()->{
map.put(Thread.currentThread().getName(),UUID.randomUUID().toString().substring(0,5));
System.out.println(map);
},String.valueOf(i)).start();
}
}
结果同样的出现了：异常java.util.ConcurrentModificationException 并发修改异常
解决方案：
- 使用**Collections.synchronizedMap(new HashMap<>());**处理；
- 使用ConcurrentHashMap进行并发处理
7. Callable
- 可以有返回值
- 可以抛出异常
- 方法不同, Runnable重写的是run()方法, Callable重写的是call()方法
8. 常用辅助类
8.1 CountDownLatch
减法计数器
//计数器
public class CountDownLatchDemo {
public static void main(String[] args) throws InterruptedException {
//总数为5
CountDownLatch countDownLatch = new CountDownLatch(5);
for (int i = 0; i <= 5; i++) {
new Thread(()->{
System.err.println(Thread.currentThread().getName() + "go to");
countDownLatch.countDown();
},String.valueOf(i)).start();
}
countDownLatch.await();
System.err.println("Close Door");
}
}
主要方法：
- countDown 减一操作；
- await 等待计数器归零。
await等待计数器为0，就唤醒，再继续向下运行。
8.2 CyclicBarrier
相当于是加法计数器
public static void main(String[] args) {
CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
System.err.println("召唤神龙");
});
for (int i = 1; i < 8; i++) {
final int temp = i;
new Thread(()->{
System.err.println(Thread.currentThread().getName() + "收集了" + temp + "龙珠");
try {
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}).start();
}
}
8.3 Semaphore
public static void main(String[] args) {
//线程数: 就相当于3个停车位 限流
Semaphore semaphore = new Semaphore(3);
//模拟有6个车抢车位
for (int i = 1; i <= 6; i++) {
new Thread(()->{
try {
//acquire 得到
//release 释放
semaphore.acquire();
System.err.println(Thread.currentThread().getName() + "抢到车位");
TimeUnit.SECONDS.sleep(2);
System.err.println(Thread.currentThread().getName() + "离开车位");
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
semaphore.release();
}
},String.valueOf(i)).start();
}
}
semaphore.acquire();获得,假设如果已经满了, 等待, 等待被释放为止
semaphore.release(); 释放, 会将当前的信号量释放 + 1, 然后唤醒等待的线程
作用: 多个共享资源互斥的使用！ 并发限流，控制最大的线程数！
9. 读写锁
/**
* 独占锁(写锁): 一次只能有一个线程占有
* 共享锁(读锁): 多个线程可以同时占有
* ReadWriteLock
* 读-读 可以共存
* 读-写 不能共存
*/
public class ReadWriteLockDemo {
public static void main(String[] args) {
MyCache myCache = new MyCache();
//写入
for (int i = 1; i <= 5; i++) {
final int temp = i;
new Thread(()->{
myCache.put(temp + "",temp+"");
},String.valueOf(temp)).start();
}
//读取
for (int i = 1; i <= 5; i++) {
final int temp = i;
new Thread(()->{
myCache.get(temp + "");
},String.valueOf(temp)).start();
}
}
}
//自定义缓存 加锁的
class MyCache{
private HashMap<String,Object> map = new HashMap<>();
//读写锁 : 更加细粒度的控制
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() + "写入success");
}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() + "读取success");
}catch (Exception e){
e.printStackTrace();
}finally {
readWriteLock.readLock().unlock();
}
}
}
10. 阻塞队列
BlockingQueue
阻塞队列:
BlockingQueue 有四组 API
| 方式 | 抛出异常 | 不会抛出异常 | 阻塞等待 | 超时等待 |
|---|---|---|---|---|
| 添加 | add | offer | put | offer（timenum,timeUnit） |
| 移出 | remove | poll | take | poll（timenum,timeUnit） |
| 判断队首元素 | element | peek | - | - |
public class BlockingQueueDemo {
@Test
public void test01(){
ArrayBlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);
System.out.println(blockingQueue.add("a"));
System.out.println(blockingQueue.add("b"));
System.out.println(blockingQueue.add("c"));
//超出容量继续add的话
//抛出异常 java.lang.IllegalStateException: Queue full
System.out.println(blockingQueue.remove());
System.out.println(blockingQueue.remove());
System.out.println(blockingQueue.remove());
// 如果移除一个
// 这也会造成 java.util.NoSuchElementException
}
/*
* 不抛出异常，offer、poll、peek
* */
@Test
public void test02(){
ArrayBlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);
System.out.println(blockingQueue.offer("a"));
System.out.println(blockingQueue.offer("b"));
System.out.println(blockingQueue.offer("c"));
// 添加不会抛出异常，返回false
System.out.println(blockingQueue.offer("d"));
System.out.println(blockingQueue.poll());
System.out.println(blockingQueue.poll());
System.out.println(blockingQueue.poll());
// 移除不会抛出异常，返回null
System.out.println(blockingQueue.poll());
}
/*
* 等待，一直阻塞
* */
@Test
public void test03() throws InterruptedException {
ArrayBlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);
// 一直阻塞，不会返回值
blockingQueue.put("a");
blockingQueue.put("b");
blockingQueue.put("c");
// 若队列已满，再添加，则阻塞等待添加,返回被取出的值
System.out.println(blockingQueue.take());
System.out.println(blockingQueue.take());
System.out.println(blockingQueue.take());
// 移除不会抛出异常，返回null
}
/*
* 超时等待
* 这种情况也会发生阻塞等待，但会超时结束
* */
@Test
public void test04() throws InterruptedException {
ArrayBlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);
blockingQueue.offer("a");
blockingQueue.offer("b");
blockingQueue.offer("c");
System.out.println("开始等待");
blockingQueue.offer("d",2, TimeUnit.SECONDS);
System.out.println("等待结束");
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);//超过两秒，我们就不等待了
System.out.println("取值结束等待");
}
}
同步队列 SynchronousQueue
SynchronousQueue 同步队列
没有容量:
进去一个元素, 必须等待取出来后, 才能在往里面放一个元素 put take
/**
* 同步队列
* 和其他的BlockingQueue 不一样 SynchronousQueue不能存储元素
* put了一个值 必须从里面先take取出来 否则不能put进去值
*/
public class SynchronousQueueDemo {
public static void main(String[] args) {
SynchronousQueue<String> synchronousQueue = new SynchronousQueue<>();
new Thread(()->{
try {
System.err.println(Thread.currentThread().getName() + " put 1");
synchronousQueue.put("1");
System.err.println(Thread.currentThread().getName() + " put 2");
synchronousQueue.put("2");
System.err.println(Thread.currentThread().getName() + " put 3");
synchronousQueue.put("3");
} catch (InterruptedException e) {
e.printStackTrace();
}
},"A").start();
new Thread(()->{
try {
TimeUnit.SECONDS.sleep(3);
System.err.println(Thread.currentThread().getName() + "=>" + synchronousQueue.take());
TimeUnit.SECONDS.sleep(3);
System.err.println(Thread.currentThread().getName() + "=>" + synchronousQueue.take());
TimeUnit.SECONDS.sleep(3);
System.err.println(Thread.currentThread().getName() + "=>" + synchronousQueue.take());
} catch (InterruptedException e) {
e.printStackTrace();
}
},"B").start();
}
}
11. 线程池
线程池 : 三大方法、7大参数、4种拒绝策略
池化技术
程序运行的本质就是: 占用系统的资源
优化资源的使用 -> 池化技术
线程池、连接池、内存池、对象池 (创建,销毁 十分浪费资源)
池化技术: 事先准备好一些资源, 如果有人要用, 就在这里拿, 用完之后返还
线程池的好处
- 降低资源的消耗
- 提高响应速度
- 方便管理
线程复用、可以控制最大并发数、管理线程
线程
//Executors 线程池工具类 3大方法
//使用了线程池之后,用线程池来创建线程
public class Demo1 {
public static void main(String[] args) {
ExecutorService threadPool = Executors.newSingleThreadExecutor();//单个线程
Executors.newCachedThreadPool(); //可伸缩的,遇强则强, 遇弱则弱
Executors.newFixedThreadPool(5); //创建一个固定大小的线程池
try {
for (int i = 1; i < 10; i++) {
threadPool.execute(()->{
System.err.println(Thread.currentThread().getName() + " ok");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//线程池用完 程序结束需要关闭
threadPool.shutdown();
}
}
}
使用Executors.newSingleThreadExecutor();//单个线程
使用Executors.newCachedThreadPool(); //可伸缩的,遇强则强, 遇弱则弱
使用Executors.newFixedThreadPool(5); //创建一个固定大小的线程池
七大参数
源码分析
//newSingleThreadExecutor()
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
//newFixedThreadPool()
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
//newCachedThreadPool()
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
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;
}
手动创建一个线程池
一般都是使用ThreadPoolExecutor创建线程池 不使用Executors创建
- 第一种拒绝策略
new ThreadPoolExecutor.AbortPolicy() //比如银行满了,还有人进来,不处理这个人,抛出异常
- 第二种拒绝策略
new ThreadPoolExecutor.CallerRunsPolicy() //哪儿来的去哪儿执行
- 第三种拒绝策略
new ThreadPoolExecutor.DiscardPolicy() //队列满了,丢掉任务 不会抛出异常
- 第四种拒绝策略
new ThreadPoolExecutor.DiscardOldestPolicy() //队列满了, 尝试去和最早的竞争,也不会抛出异常
小结
了解: IO密集型, CPU密集型 (调优)
**问题: ** 池的最大的大小如何设置
- CPU密集型, 几核 就是几 可以保持CPU的效率最高
- IO 密集型 > 判断你程序中十分耗IO的线程
程序
//获取CPU核数
Runtime.getRuntime().availableProcessors();
12. 四大函数式接口(必掌)
需要掌握的: lambda表达式, 链式编程, 函数式接口, Stream流式计算
函数式接口: 只有一个方法的接口
@FunctionalInterface
public interface Runnable {
public abstract void run();
}
//FunctionalInterface
//简化编程模型
Function函数式接口
测试:
/**
* Function 函数式接口 有一个输入参数 有一个输出
* 只要是 函数型接口 可以用Lambda表达式简化
*/
public class Demo1 {
public static void main(String[] args) {
// Function function = new Function() {
// @Override
// public String apply(String o) {
// return o;
// }
// };
// System.err.println(function.apply("a"));
//lambda表达式简化
Function function = (str)->{return str;};
System.err.println(function.apply("a"));
}
}
断定性接口
有一个输入参数, 返回值只能是 布尔值
/**
* 判定性接口: 有一个输入参数, 返回值只能是 布尔值
*/
public class Demo2 {
public static void main(String[] args) {
//判断字符串是否为空
// Predicate stringPredicate = new Predicate(){
// @Override
// public boolean test(String str) {
// return str.isEmpty();
// }
// };
// System.err.println(stringPredicate.test("ss"));
Predicate<String> stringPredicate = (str) ->{ return str.isEmpty(); };
System.err.println(stringPredicate.test("ss"));
}
}
Consumer 消费型接口
/**
* Consumer 消费性接口: 只有输入, 没有返回值
*/
public class Demo3 {
public static void main(String[] args) {
// Consumer objectConsumer = new Consumer(){
// @Override
// public void accept(String str) {
// System.err.println(str);
// }
// };
// objectConsumer.accept("aaa");
Consumer<String> objectConsumer = (str)->{ System.err.println(str); };
objectConsumer.accept("aaa");
}
}
13. Supplier 供给型接口
/**
* Supplier 供给型接口: 没有参数, 只有返回值
*/
public class Demo4 {
public static void main(String[] args) {
// Supplier supplier = new Supplier() {
// @Override
// public Integer get() {
// System.err.println("get()");
// return 1024;
// }
// };
// System.out.println(supplier.get());
Supplier<Integer> supplier = ()->{ return 1024; };
System.out.println(supplier.get());
}
}
13. Stream流式计算
什么是Stream流式计算
集合、MySQL本质就是存储东西的
计算都应该交给流来操作
public class Test {
public static void main(String[] args) {
/**
* 题目要求:一分钟内完成此题，只能用一行代码实现!现在有5个用户!筛选:
* 1、ID必须是偶数
* 2、年龄必须大于23岁
* 3、用户名转为大写字母
* 4、用户名字母倒着排序
* 5、只输出一个用户!
*/
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(5, "e", 25);
User user6 = new User(6, "f", 26);
List<User> list = Arrays.asList(user1, user2, user3, user4, user5);
//计算交给Stream流
//链式编程
list.stream()
.filter(u->{return u.getId()%2 == 0;}) //得到ID必须是偶数
.filter(u->{return u.getAge() > 23;}) //年龄必须大于23岁
.map(u->{return u.getName().toUpperCase();})//用户名转为大写字母
.sorted((uu1,uu2)->{return uu1.compareTo(uu2);})//用户名字母倒着排序
.limit(1)//分页只要一个用户
.forEach(System.out::println);
}
}
14. ForkJoin
ForkJoin在 jdk1.7 并行执行任务 提高效率 大数据量
大数据: Map Reduce(把大任务拆分为小任务)
ForkJoin 特点：工作窃取！
ForkJoin
- 计算的类需要ForkJoinTask
/**
* 求和计算任务
* 3000 6000 9000(Stream并行流)
* 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;
}
//计算方法
@Override
protected Long compute() {
if ((end - start) < temp){
Long sum = 0l;
for (int i = 1; i < 10_0000_0000; 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();
}
}
}
测试:
public class Test {
public static void main(String[] args) throws ExecutionException, InterruptedException {
test1();
test2();
test3();
}
/**
* 普通计算
*/
public static void test1(){
long star = System.currentTimeMillis();
long sum = 0L;
for (long i = 1; i < 20_0000_0000; i++) {
sum+=i;
}
long end = System.currentTimeMillis();
System.out.println("sum="+"时间："+(end-star));
System.out.println(sum);
}
/**
* 使用ForkJoin
*/
public static void test2() throws ExecutionException, InterruptedException {
long star = System.currentTimeMillis();
ForkJoinPool forkJoinPool = new ForkJoinPool();
ForkJoinTask<Long> task = new ForkJoinDemo(0L, 20_0000_0000L);
ForkJoinTask<Long> submit = forkJoinPool.submit(task);
Long aLong = submit.get();
System.out.println(aLong);
long end = System.currentTimeMillis();
System.out.println("sum="+"时间："+(end-star));
}
/**
* 使用Stream 并行流
*/
public static void test3(){
long star = System.currentTimeMillis();
//Stream并行流()
long sum = LongStream.range(0L, 20_0000_0000L).parallel().reduce(0, Long::sum);
System.out.println(sum);
long end = System.currentTimeMillis();
System.out.println("sum="+"时间："+(end-star));
}
}
.parallel().reduce(0, Long::sum)使用一个并行流去计算整个计算，提高效率。
15. 异步回调
Future 设计的初衷：对将来的某个事件结果进行建模！
将类似于 前端发ajax请求给后端
但是我们平时都使用CompletableFuture
-
没有返回值的
runAsync异步回调public static void main(String[] args) throws ExecutionException, InterruptedException { // 发起 一个 请求 System.out.println(System.currentTimeMillis()); System.out.println("---------------------"); CompletableFuture<Void> future = CompletableFuture.runAsync(()->{ //发起一个异步任务 try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+"....."); }); System.out.println(System.currentTimeMillis()); System.out.println("------------------------------"); //输出执行结果 System.out.println(future.get()); //获取执行结果 } -
有返回值的异步回调
supplyAsync//有返回值的异步回调 CompletableFuture<Integer> completableFuture=CompletableFuture.supplyAsync(()->{ System.out.println(Thread.currentThread().getName()); try { TimeUnit.SECONDS.sleep(2); int i=1/0; } catch (InterruptedException e) { e.printStackTrace(); } return 1024; }); System.out.println(completableFuture.whenComplete((t, u) -> { //success 回调 System.out.println("t=>" + t); //正常的返回结果 System.out.println("u=>" + u); //抛出异常的 错误信息 }).exceptionally((e) -> { //error回调 System.out.println(e.getMessage()); return 404; }).get());whenComplete: 有两个参数，一个是t 一个是u
T：是代表的 正常返回的结果；
U：是代表的 抛出异常的错误信息；
如果发生了异常，get可以获取到exceptionally返回的值；
16. JMM
谈谈对Volatile的理解
Volatile 是Java虚拟机提供 轻量级的同步机制
- 保证可见性
- 不保证原子性
- 禁止指令重排
什么是JMM?
JMM：JAVA内存模型，不存在的东西，是一个概念，也是一个约定！
关于JMM的一些同步的约定：
1、线程解锁前，必须把共享变量立刻刷回主存；
2、线程加锁前，必须读取主存中的最新值到工作内存中；
3、加锁和解锁是同一把锁；
线程中分为 工作内存、主内存
8种操作:
- Read（读取）：作用于主内存变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用；
- load（载入）：作用于工作内存的变量，它把read操作从主存中变量放入工作内存中；
- Use（使用）：作用于工作内存中的变量，它把工作内存中的变量传输给执行引擎，每当虚拟机遇到一个需要使用到变量的值，就会使用到这个指令；
- assign（赋值）：作用于工作内存中的变量，它把一个从执行引擎中接受到的值放入工作内存的变量副本中；
- store（存储）：作用于主内存中的变量，它把一个从工作内存中一个变量的值传送到主内存中，以便后续的write使用；
- write（写入）：作用于主内存中的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中；
- lock（锁定）：作用于主内存的变量，把一个变量标识为线程独占状态；
- unlock（解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定；
JMM对这8种操作给了相应的规定：
- 不允许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. Volatile
1. 保证可见性
public class JMMDemo01 {
// 如果不加volatile 程序会死循环
// 加了volatile是可以保证可见性的
private volatile static Integer number = 0;
public static void main(String[] args) {
//main线程
//子线程1
new Thread(()->{
while (number==0){
}
}).start();
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
//子线程2
new Thread(()->{
while (number==0){
}
}).start();
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
number=1;
System.out.println(number);
}
}
2. 不保证原子性
原子性：不可分割；
线程A在执行任务的时候，不能被打扰的，也不能被分割的，要么同时成功，要么同时失败。
//volatile不保证原子性
public class Demo {
private volatile static int num = 0;
//结束应该为20000
public static void add(){
num++;
}
public static void main(String[] args) {
for (int i = 0; i < 20; i++) {
new Thread(()->{
for (int j = 0; j < 1000; j++) {
add();
}
}).start();
}
while (Thread.activeCount() > 2){ //main gc线程
Thread.yield();
}
System.err.println(num);
}
}
如果不加lock和synchronized关键字, 怎么掌握原子性
num++ 不是一个操作, 其实是三个
- get取到num的值
- 进行加一操作
- put重写num的值
解决方法：使用JUC下的原子包下的class；
public class VDemo02 {
private static volatile AtomicInteger number = new AtomicInteger();
public static void add(){
// number++;
number.incrementAndGet(); //底层是CAS保证的原子性
}
public static void main(String[] args) {
//理论上number === 20000
for (int i = 1; i <= 20; i++) {
new Thread(()->{
for (int j = 1; j <= 1000 ; j++) {
add();
}
}).start();
}
while (Thread.activeCount()>2){
//main gc
Thread.yield();
}
System.out.println(Thread.currentThread().getName()+",num="+number);
}
}
这些类的底层都直接和操作系统挂钩！是在内存中修改值。
Unsafe类是一个很特殊的存在；
指令重排
什么是指令重排？
我们写的程序，计算机并不是按照我们自己写的那样去执行的
源代码–>编译器优化重排–>指令并行也可能会重排–>内存系统也会重排–>执行
处理器在进行指令重排的时候，会考虑数据之间的依赖性！
int x=1; //1
int y=2; //2
x=x+5; //3
y=x*x; //4
//我们期望的执行顺序是 1_2_3_4 可能执行的顺序会变成2134 1324
//可不可能是 4123？ 不可能的
可能造成的影响结果：前提：a b x y这四个值 默认都是0
| 线程A | 线程B |
|---|---|
| x=a | y=b |
| b=1 | a=2 |
正常的结果： x = 0; y =0;
| 线程A | 线程B |
|---|---|
| x=a | y=b |
| b=1 | a=2 |
可能在线程A中会出现，先执行b=1,然后再执行x=a；
在B线程中可能会出现，先执行a=2，然后执行y=b；
那么就有可能结果如下：x=2; y=1.
volatile可以避免指令重排：
volatile中会加一道内存的屏障，这个内存屏障可以保证在这个屏障中的指令顺序。
内存屏障：CPU指令。作用：
1、保证特定的操作的执行顺序；
2、可以保证某些变量的内存可见性（利用这些特性，就可以保证volatile实现的可见性）
总结
- volatile可以保证可见性；
- 不能保证原子性
- 由于内存屏障，可以保证避免指令重排的现象产生
18. 单例模式
饿汉式、DCL懒汉式
饿汉式
/**
* 饿汉式单例
*/
public class Hungry {
/**
* 可能会浪费空间
*/
private byte[] data1=new byte[1024*1024];
private byte[] data2=new byte[1024*1024];
private byte[] data3=new byte[1024*1024];
private byte[] data4=new byte[1024*1024];
private Hungry(){
}
private final static Hungry hungry = new Hungry();
public static Hungry getInstance(){
return hungry;
}
}
DCL懒汉式
//懒汉式单例模式
public class LazyMan {
private static boolean key = false;
private LazyMan(){
synchronized (LazyMan.class){
if (key==false){
key=true;
}
else{
throw new RuntimeException("不要试图使用反射破坏异常");
}
}
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、把这个对象指向这个空间
*
* 就有可能出现指令重排问题
* 比如执行的顺序是1 3 2 等
* 我们就可以添加volatile保证指令重排问题
*/
}
}
}
return lazyMan;
}
//单线程下 是ok的
//但是如果是并发的
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
//Java中有反射
// LazyMan instance = LazyMan.getInstance();
Field key = LazyMan.class.getDeclaredField("key");
key.setAccessible(true);
Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
declaredConstructor.setAccessible(true); //无视了私有的构造器
LazyMan lazyMan1 = declaredConstructor.newInstance();
key.set(lazyMan1,false);
LazyMan instance = declaredConstructor.newInstance();
System.out.println(instance);
System.out.println(lazyMan1);
System.out.println(instance == lazyMan1);
}
}
静态内部类
//静态内部类
public class Holder {
private Holder(){
}
public static Holder getInstance(){
return InnerClass.holder;
}
public static class InnerClass{
private static final Holder holder = new Holder();
}
}
单例不安全, 因为有反射
枚举enum
//enum 是什么？ enum本身就是一个Class 类
public enum EnumSingle {
INSTANCE;
public EnumSingle getInstance(){
return INSTANCE;
}
}
class Test{
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
EnumSingle instance1 = EnumSingle.INSTANCE;
Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
declaredConstructor.setAccessible(true);
//java.lang.NoSuchMethodException: com.ogj.single.EnumSingle.()
EnumSingle instance2 = declaredConstructor.newInstance();
System.out.println(instance1);
System.out.println(instance2);
}
}
使用枚举, 我们就可以防止反射破坏了
枚举类型使用JAD最终反编译后源码：
如果我们看idea 的文件：会发现idea骗了我们，居然告诉我们是有有参构造的，我们使用jad进行反编译。
反编译后的java文件
发现没有无参构造 有一个private EnumSingle(String s, int i)有参构造
public final class EnumSingle extends Enum
{
public static EnumSingle[] values()
{
return (EnumSingle[])$VALUES.clone();
}
public static EnumSingle valueOf(String name)
{
return (EnumSingle)Enum.valueOf(com/ogj/single/EnumSingle, name);
}
private EnumSingle(String s, int i)
{
super(s, i);
}
public EnumSingle getInstance()
{
return INSTANCE;
}
public static final EnumSingle INSTANCE;
private static final EnumSingle $VALUES[];
static
{
INSTANCE = new EnumSingle("INSTANCE", 0);
$VALUES = (new EnumSingle[] {
INSTANCE
});
}
}
19. CAS
什么是CAS
public class casDemo {
//CAS : compareAndSet 比较并交换
public static void main(String[] args) {
AtomicInteger atomicInteger = new AtomicInteger(2020);
//boolean compareAndSet(int expect, int update)
//期望值、更新值
//如果实际值 和 我的期望值相同，那么就更新
//如果实际值 和 我的期望值不同，那么就不更新
System.out.println(atomicInteger.compareAndSet(2020, 2021));
System.out.println(atomicInteger.get());
//因为期望值是2020 实际值却变成了2021 所以会修改失败
//CAS 是CPU的并发原语
atomicInteger.getAndIncrement(); //++操作
System.out.println(atomicInteger.compareAndSet(2020, 2021));
System.out.println(atomicInteger.get());
}
}
Unsafe类
总结：
CAS：比较当前工作内存中的值 和 主内存中的值，如果这个值是期望的，那么则执行操作！如果不是就一直循环，使用的是自旋锁。
缺点：
- 循环会耗时；
- 一次性只能保证一个共享变量的原子性；
- 它会存在ABA问题
CAS：ABA问题？(狸猫换太子)
线程1：期望值是1，要变成2；
线程2：两个操作：
- 1、期望值是1，变成3
- 2、期望是3，变成1
所以对于线程1来说，A的值还是1，所以就出现了问题，骗过了线程1；
public class casDemo {
//CAS : compareAndSet 比较并交换
public static void main(String[] args) {
AtomicInteger atomicInteger = new AtomicInteger(2020);
System.out.println(atomicInteger.compareAndSet(2020, 2021));
System.out.println(atomicInteger.get());
//boolean compareAndSet(int expect, int update)
//期望值、更新值
//如果实际值 和 我的期望值相同，那么就更新
//如果实际值 和 我的期望值不同，那么就不更新
System.out.println(atomicInteger.compareAndSet(2021, 2020));
System.out.println(atomicInteger.get());
//因为期望值是2020 实际值却变成了2021 所以会修改失败
//CAS 是CPU的并发原语
// atomicInteger.getAndIncrement(); //++操作
System.out.println(atomicInteger.compareAndSet(2020, 2021));
System.out.println(atomicInteger.get());
}
}
20. 原子引用
解决ABA问题，对应的思想：就是使用了乐观锁~
带版本号的 原子操作！
Integer 使用了对象缓存机制，默认范围是-128~127，推荐使用静态工厂方法valueOf获取对象实例，而不是new，因为valueOf使用缓存，而new一定会创建新的对象分配新的内存空间。
带版本号的原子操作
package com.marchsoft.lockdemo;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicStampedReference;
public class CASDemo {
/**AtomicStampedReference 注意，如果泛型是一个包装类，注意对象的引用问题
* 正常在业务操作，这里面比较的都是一个个对象
*/
static AtomicStampedReference<Integer> atomicStampedReference = new
AtomicStampedReference<>(1, 1);
// CAS compareAndSet : 比较并交换！
public static void main(String[] args) {
new Thread(() -> {
int stamp = atomicStampedReference.getStamp(); // 获得版本号
System.out.println("a1=>" + stamp);
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 修改操作时，版本号更新 + 1
atomicStampedReference.compareAndSet(1, 2,
atomicStampedReference.getStamp(),
atomicStampedReference.getStamp() + 1);
System.out.println("a2=>" + atomicStampedReference.getStamp());
// 重新把值改回去， 版本号更新 + 1
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, 3,
stamp, stamp + 1));
System.out.println("b2=>" + atomicStampedReference.getStamp());
}, "b").start();
}
}
21. 锁的理解
1. 公平锁、非公平锁
公平锁: 非常公平、不能够插队、必须先来后到
非公平锁: 非常不公平、可以插队(默认都是非公平)
//非公平锁
public ReentrantLock() {
sync = new NonfairSync();
}
//公平锁
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
2. 可重入锁
Synchronized 版
//Synchronized
public class Demo01 {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(()->{
phone.sms();
},"A").start();
new Thread(()->{
phone.sms();
},"B").start();
}
}
class Phone{
public synchronized void sms(){
System.err.println(Thread.currentThread().getName() + "sms");
call();
}
public synchronized void call(){
System.err.println(Thread.currentThread().getName() + "call");
}
}
Lock锁 版
//Lock锁
public class Demo02 {
public static void main(String[] args) {
Phone1 phone = new Phone1();
new Thread(()->{
phone.sms();
},"A").start();
new Thread(()->{
phone.sms();
},"B").start();
}
}
class Phone1{
Lock lock = new ReentrantLock();
public void sms(){
lock.lock(); //细节问题: lock.lock(); lock.lock(); //lock 锁必须配对,否则就会死在里面
lock.lock();
try {
System.err.println(Thread.currentThread().getName() + "sms");
call(); //这里也有锁
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
lock.unlock();
}
}
public void call(){
lock.lock();
try {
System.err.println(Thread.currentThread().getName() + "call");
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
3. 自旋锁
spinlock
自定义一个自旋锁测试
/**
* 自旋锁
*/
public class SpinlockDemo {
//例 当为int类型时 空值为0
// 包装类时 Thread 空值为null
AtomicReference<Thread> atomicReference = new AtomicReference<>();
//加锁
public void mylock(){
Thread thread = Thread.currentThread();
System.err.println(Thread.currentThread().getName() + "-> mylock");
//自旋锁
while (!atomicReference.compareAndSet(null,thread)){
}
}
//解锁
public void myUnlock() {
Thread thread = Thread.currentThread();
System.err.println(Thread.currentThread().getName() + "-> myUnlock");
atomicReference.compareAndSet(thread,null);
}
}
测试
public class TestSpinlock {
public static void main(String[] args) throws InterruptedException {
// ReentrantLock reentrantLock = new ReentrantLock();
// reentrantLock.lock();
// reentrantLock.unlock();
//底层使用自旋锁 CAS
SpinlockDemo lock = new SpinlockDemo();
new Thread(()->{
lock.mylock();
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.myUnlock();
}
},"T1").start();
TimeUnit.SECONDS.sleep(1);
new Thread(()->{
lock.mylock();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.myUnlock();
}
},"T2").start();
}
}
4. 死锁
代码测试
public class DeadLockDemo {
public static void main(String[] args) {
String lockA = "lockA";
String lockB = "lockB";
new Thread(new MyThread(lockA,lockB),"T1").start();
new Thread(new MyThread(lockB,lockA),"T2").start();
}
}
class MyThread implements Runnable{
private String lockA;
private String lockB;
public MyThread(String lockA, String lockB) {
this.lockA = lockA;
this.lockB = lockB;
}
@Override
public void run() {
synchronized (lockA){
System.err.println(Thread.currentThread().getName() + "lock:" + lockA + "-> get:" + lockB);
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (lockB){
System.err.println(Thread.currentThread().getName() + "lock:" + lockB + "-> get:" + lockA);
}
}
}
}
解决问题
-
使用
jps -l定位进程号
-
使用
jstack进程号找到死锁问题