多线程进阶=＞JUC并发编程

最新推荐文章于 2023-06-19 14:49:25 发布

dxj1016

最新推荐文章于 2023-06-19 14:49:25 发布

阅读量202

点赞数 2

分类专栏： javaEE高级阶段 java基础阶段文章标签： JUC

本文链接：https://blog.csdn.net/weixin_44718865/article/details/115732203

版权

java基础阶段同时被 2 个专栏收录

23 篇文章 0 订阅

订阅专栏

javaEE高级阶段

13 篇文章 0 订阅

订阅专栏

多线程进阶=>JUC并发编程

狂神视频JUC并发编程

准备环境：创建maven项目，修改项目配置为8，否则lambdas用不了。修改setting中的java compiler为8。
在这里插入图片描述

1、什么是JUC

JUC就是java.util.concurrent下面的工具包，专门用于多线程的开发。（源码+官方文档面试高频问）
在 Java 5.0 提供了 java.util.concurrent （简称JUC ）包,在此包中增加了在并发编程中很常用的实用工具类，用于定义类似于线程的自定义子系统，包括线程池、异步 IO 和轻量级任务框架。提供可调的、灵活的线程池。还提供了设计用于多线程上下文中的 Collection 实现等。

在这里插入图片描述
业务：普通的线程代码 Thread
Runable 没有返回值，效率相比Callable相对较低！

2、线程和进程

参考之前的多线程

一句话概括线程和进程
进程是操作系统中的应用程序、是资源分配的基本单位，线程是用来执行具体的任务和功能，是CPU调度和分派的最小单位

2.1、进程

进程： 在操作系统中运行的应用程序

一个进程往往可以包含多个线程，至少包含一个

在这里插入图片描述

2.2、线程

线程： 线程是CPU调度和执行的单位。开了一个进程Typora，写字，等待几分钟会进行自动保存(线程负责的)

对于Java而言：Thread、Runable、Callable进行开启线程的。
Java默认有几个线程？2个线程！ main线程、GC线程

提问？JAVA真的可以开启线程吗？开不了的！

Java是没有权限去开启线程、操作硬件的，点开start的原码可以看到这是一个线程安全的，通过add加入线程组，点开start0()方法发现这是一个native的一个本地方法，底层是C++。所以java是没有权限直接操作硬件的，由操作系统来开启线程。start()和strat0()方法的源码如下：

public synchronized void start() {
        /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }
	//这是一个C++底层，Java是没有权限操作底层硬件的
    private native void start0();

2.3、并发

并发编程：并发，并行

并发： 多线程操作同一个资源。

CPU 只有一核，只能操作一个线程，但是可以模拟出来多条线程。那么我们就可以使用CPU快速交替，来模拟多线程。看起来是同一时间操作多个线程操作同一个资源，其实本质还是一个线程执行，由于速度非常快，所以看起来是多个线程在执行。
并发编程的本质：充分利用CPU的资源！

2.4、并行

并行：多个人一起行走

CPU多核，多个线程可以同时执行。
提高并行效率我们可以使用线程池！

获取cpu的核数

public class Test1 {
    public static void main(String[] args) {
        //获取cpu的核数
        //CPU密集型，IO密集型
                System.out.println(Runtime.getRuntime().availableProcessors());
    }
}

2.5、线程的状态

6种状态，Thread.state查看源码如下：

public enum State {	
	//新生
    NEW,

	//运行
    RUNNABLE,

	//阻塞
    BLOCKED,

	//等待，死死等待
    WAITING,

	//超时等待
    TIMED_WAITING,

	//终止
    TERMINATED;
}

2.6、wait/sleep

1、来自不同的类

wait => Object

sleep => Thread

一般情况企业中使用休眠是：

TimeUnit.DAYS.sleep(1); //休眠1天
TimeUnit.SECONDS.sleep(1); //休眠1s

2、关于锁的释放

wait 会释放锁；
sleep睡觉了，不会释放锁；

3、使用的范围是不同的

wait 必须在同步代码块中；
sleep 可以在任何地方睡；

4、是否需要捕获异常

wait和sleep都需要捕获异常
notify和notifyall都不需要捕获异常

3、Lock锁（重点）

3.1、传统的 synchronized

package com.marchsoft.juctest;

import lombok.Synchronized;

/**
 * Description：synchronized
 * 基本的卖票例子
 * 真正的多线程开发，公司中的开发
 * 线程就是一个单独的资源类，没有任何附属的操作
 * 1、属性，方法。
 **/

public class Demo01 {
    public static void main(String[] args) {
    //并发：多线程操作同一个资源类
        final Ticket ticket = new Ticket();
    //new Runnable()看源码可以发现他是一个@FunctionalInterface函数式接口，接口不能实例化，但是可以用匿名内部类实现他，但是这个比价繁琐，所以在jdk1.8,可以使用lambdas表达式(参数)->{代码}实现。
    /*
       new Thread(new Runnable(){
              @Override
              public void run(){
              
              }                     
          }).start();
    */
        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();
    }
}
// 资源类 OOP 
class Ticket {
     //属性、方法
    private int number = 30;

    //卖票的方式
    public void sale() {
        if (number > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出了第" + (number--) + "张票剩余" + number + "张票");
        }
    }
}

代码开启了三个线程
运行结果出现了不符合实际情况，卖出的票跟剩余的票和总数不对应，原因是多个线程可能争夺同一个资源
改变上面的代码，在sale方法加上synchronized，可以解决上述问题。
synchronized 本质：队列，锁
这个锁的是对象或者class

3.2、Lock（重点）

Lock接口

在这里插入图片描述

公平锁： 十分公平，必须先来后到~；

非公平锁： 十分不公平，可以插队；(默认为非公平锁)

package com.marchsoft.juctest;

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

package demo02;


import jdk.nashorn.internal.ir.CallNode;

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

public class Test1 {
    public static void main(String[] args) {
        //并发：多线程操作同一个资源类
        Ticket2 ticket = new Ticket2();
       /*
        new Runnable()看源码可以发现他是一个@FunctionalInterface函数式接口，接口不能实例化，
        但是可以用匿名内部类实现他，但是这个比价繁琐，
        所以在jdk1.8,可以使用lambdas表达式(参数)->{代码}实现。
        */
       /*
       new Thread(new Runnable(){
              @Override
              public void run(){

              }
          }).start();
       */
        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
// 不再使用synchronized实现多线程，而是使用Lock锁。
/*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-catch-finally：Ctrl+Alt+T
                try {
//                   业务代码
                    if (number > 0) {
                        System.out.println(Thread.currentThread().getName() + "卖出了第" + (number--) + "张票剩余" + number + "张票");
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();//解锁
                }
            }
        }

3.3、 Synchronized 与Lock 的区别

Synchronized 内置的Java关键字，Lock是一个接口
Synchronized 无法判断获取锁的状态，Lock可以判断
Synchronized 会自动释放锁，lock必须要手动加锁和手动释放锁！如果不释放锁，可能会遇到死锁
Synchronized 线程1(获得锁->阻塞)、线程2(一直等待)；lock就不一定会一直等待下去，lock会有一个trylock去尝试获取锁，不会造成长久的等待。
Synchronized 是可重入锁，不可以中断的，非公平的；Lock是接口，可重入的，可以判断锁，可以自己设置公平锁和非公平锁；
Synchronized 适合锁少量的代码同步问题，Lock适合锁大量的同步代码；

锁是什么，如何判断锁的是谁？

4、生产者和消费者问题

面试的：单例模式、排序算法、生产者消费者问题，死锁问题。

4.1、Synchronzied 版本

package pc;
/**
 * 线程之间的通信问题：生产者和消费者问题
 * 线程交替执行 A B操作同一个变量 num=0
 * A num+1
 * B num-1
 */
public class ConsumeAndProduct {
    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=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
 */

4.2、存在问题（虚假唤醒）

问题，如果有四个线程，会出现虚假唤醒
两个生产者线程，两个消费者线程，会虚线虚假唤醒，

if判断流水线状态为空时，线程被阻塞，这时if判断就完成了，线程被唤醒后直接执行线程剩余操作。
while判断流水线状态为空时，线程被阻塞，这时的while循环没有完成，线程被唤醒后会先进行while判断，然后执行后面的操作。
if只判断了一次，等待队列的多生产者被消费者唤醒后重新进入同步队列，这时候抢到锁，会从if下面的语句开始执行，相当于没了判断。
为什么if改成while之后就不会出现虚假唤醒问题了，因为while会一直判断，线程没有唤醒就出不来，比消费者唤醒生产者，其它2两个线程都会争夺锁，如果其中一个生产者抢到锁了，那么他会从等待位置醒来，while的时候，就会先循环判断条件，如果不满足条件才会出来，否则还会继续等待，但是if就不一样了，if判断一次就结束了，所以从wait醒来的时候，早就过了if判断语句，因此他会执行wait方法下面的操作。

在这里插入图片描述

虚假唤醒：就是当一个条件满足时，很多线程都被唤醒了，但是只有其中部分是有用的唤醒，其它的唤醒都是无用功。

解决方式，if 改为while即可，防止虚假唤醒

package com.marchsoft.juctest;

package pc;
/**
 * 线程之间的通信问题：生产者和消费者问题
 * 线程交替执行 A B操作同一个变量 num=0
 * A num+1
 * B num-1
 */
public class ConsumeAndProduct {
    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 num = 0;
//只要是并发编程一定会有锁。
    // +1
    public synchronized void increment() throws InterruptedException {
        // 判断等待
        while (num != 0) {
            this.wait();
        }
        num++;
        System.out.println(Thread.currentThread().getName() + "=>" + num);
        // 通知其他线程 +1 执行完毕
        this.notifyAll();
    }

    // -1
    public synchronized void decrement() throws InterruptedException {
        // 判断等待
        while (num == 0) {
            this.wait();
        }
        num--;
        System.out.println(Thread.currentThread().getName() + "=>" + num);
        // 通知其他线程 -1 执行完毕
        this.notifyAll();
    }
}
/*
执行结果：
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
C=>1
D=>0
C=>1
D=>0
C=>1
D=>0
C=>1
D=>0
C=>1
D=>0
C=>1
D=>0
C=>1
D=>0
C=>1
D=>0
C=>1
D=>0
C=>1
D=>0
 */

4.3、Lock版

JUC版的消费者和生产者问题

在这里插入图片描述

官方文档通过Lock找到Condition

在这里插入图片描述

代码实现：

package jucPC;

import jdk.nashorn.internal.ir.CallNode;

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 ConsumeAndProduct {
    public static void main(String[] args) {
        Data2 data = new Data2();

        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 Data2 {//数字，资源类
    private int num = 0;
//只要是并发编程一定会有锁。

    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
//condition.await();//等待
//condition.signalAll();//唤醒全部

    // +1
    public  void increment() throws InterruptedException {
        lock.lock();
        try {

//            业务代码
            // 判断等待
            while (num != 0) {
                condition.await();
            }
            num++;
            System.out.println(Thread.currentThread().getName() + "=>" + num);
            // 通知其他线程 +1 执行完毕
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    // -1
    public  void decrement() throws InterruptedException {
        lock.lock();
        try {
//            业务代码
            // 判断等待
            while (num == 0) {
                condition.await();
            }
            num--;
            System.out.println(Thread.currentThread().getName() + "=>" + num);
            // 通知其他线程 -1 执行完毕
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }



    }
}
/*
执行结果：
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
C=>1
D=>0
C=>1
D=>0
C=>1
D=>0
C=>1
D=>0
C=>1
D=>0
C=>1
D=>0
C=>1
D=>0
C=>1
D=>0
C=>1
D=>0
C=>1
D=>0
 */

4.4、Condition的优势

精准的通知和唤醒的线程！A执行完就执行B，B执行完就执行C，按照顺序来。

num适用于判断等待的
condition适用于判断唤醒谁的
如果我们要指定通知的下一个进行顺序怎么办呢？我们可以使用Condition来指定通知进程~

package com.marchsoft.juctest;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Description：
 * A 执行完 调用B
 * B 执行完 调用C
 * C 执行完 调用A
 *
 * @author jiaoqianjin
 * Date: 2020/8/11 9:58
 **/

public class ConditionDemo {
    public static void main(String[] args) {
        Data3 data3 = new Data3();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                data3.printA();
            }
        },"A").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                data3.printB();
            }
        },"B").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                data3.printC();
            }
        },"C").start();
    }

}
class Data3 {
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
    private int num = 1; // 1A 2B 3C

    public void printA() {
        lock.lock();
        try {
            // 业务代码 判断 -> 执行 -> 通知
            while (num != 1) {
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName() + "==> AAAA" );
            num = 2;
            condition2.signal();
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void printB() {
        lock.lock();
        try {
            // 业务代码 判断 -> 执行 -> 通知
            while (num != 2) {
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName() + "==> BBBB" );
            num = 3;
            condition3.signal();
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void printC() {
        lock.lock();
        try {
            // 业务代码 判断 -> 执行 -> 通知
            while (num != 3) {
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName() + "==> CCCC" );
            num = 1;
            condition1.signal();
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}
/*
A==> AAAA
B==> BBBB
C==> CCCC
A==> AAAA
B==> BBBB
C==> CCCC
...
*/

5、8锁，就是关于锁的8个问题

如何判断锁的是谁！锁到底锁的是谁？

5.1、锁1现象一对象，两普通同步方法，线程加延迟

1、标准情况下，两个线程先发短信，还是打电话？1/发短信 2/打电话

package lock8;

import java.util.concurrent.TimeUnit;
/**
 * 8锁，就是关于锁的8个问题
 * 1、标准情况下，两个线程先发短信，还是打电话？1/发短信 2/打电话
 *    synchronized 是重度锁，谁拿到锁就会阻塞，必须执行完了才会释放。
 *    线程A中加sleep，锁的是主线程。
 *    sleep的时候B还没创建，必定A先
 * 2、在sendSms方法加上sleep延迟4秒之后，是发短信还是先打电话？1/发短信 2/打电话
 *    先执行短信，4秒，主线程1s后继续的时候，A线程还在sleep，sleep没有释放锁，所以应该先发短信，然后释放锁之后再执行线程B
 *    synchronized锁的对象是方法的调用者，例子中锁的都是phone对象，两个方法用的同一个锁，谁先拿到谁先执行。
 *  *    因此执行发短信的时候会阻塞，sleep没有释放锁，所以就必须执行完发短信后释放锁才可以执行线程B。
 *
 *
 */

public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        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 {
    public synchronized void sendSms()  {
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");

    }
}
/*
发短信
打电话
 */

解析：

synchronized 是重度锁，谁拿到锁就会阻塞，必须执行完了才会释放。
线程A中加sleep，锁的是主线程。sleep的时候B还没创建，必定A先

5.2、锁2现象一对象，两个普通同步方法，线程、方法加延迟

2、在sendSms方法加上sleep延迟4秒之后，是发短信还是先打电话？1/发短信 2/打电话

package lock8;

import java.util.concurrent.TimeUnit;
/**
 * 8锁，就是关于锁的8个问题
 * 1、标准情况下，两个线程先发短信，还是打电话？1/发短信 2/打电话
 *    synchronized 是重度锁，谁拿到锁就会阻塞，必须执行完了才会释放。
 *    线程A中加sleep，锁的是主线程。
 *    sleep的时候B还没创建，必定A先
 * 2、在sendSms方法加上sleep延迟4秒之后，是发短信还是先打电话？1/发短信 2/打电话
 *    先执行短信，4秒，主线程1s后继续的时候，A线程还在sleep，sleep没有释放锁，所以应该先发短信，然后释放锁之后再执行线程B
 *    synchronized锁的对象是方法的调用者，例子中锁的都是phone对象，两个方法用的同一个锁，谁先拿到谁先执行。
 *    因此执行发短信的时候会阻塞，sleep没有释放锁，所以就必须执行完发短信后释放锁才可以执行线程B。
 *
 *
 */

public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        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("打电话");

    }
}
/*
发短信
打电话
*/

解析：

先执行短信，4秒，主线程1s后继续的时候，A线程还在sleep，sleep没有释放锁，所以应该先发短信，然后释放锁之后再执行线程B
synchronized锁的对象是方法的调用者，例子中锁的都是phone对象，两个方法用的同一个锁，谁先拿到谁先执行。
因此执行发短信的时候会阻塞，sleep没有释放锁，所以就必须执行完发短信后释放锁才可以执行线程B。

并不是顺序执行，synchronized 锁住的对象是方法的调用！对于两个方法用的是同一个锁，谁先拿到谁先执行，另外一个等待

5.3、锁3现象一对象，一普通同步方法，一普通方法。

增加一个普通方法后，先执行发短信还是Hello？

package lock8;

import java.util.concurrent.TimeUnit;
/**
 * 8锁，就是关于锁的8个问题
 * 3、增加一个普通方法后，先执行发短信还是Hello？先Hello再发短信
 */

public class Test2 {
    public static void main(String[] args) {
        Phone2 phone = new Phone2();
//        锁的存在
        new Thread(()->{
            phone.sendSms();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone.hello();
        },"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");
    }

}

/*
Hello
发短信
 */

解析：

hello是一个普通方法，不受synchronized锁的影响，不用等待锁的释放

5.4、锁4现象两对象，两普通同步方法

4、两个对象，两个同步方法，先发短信还是先打电话？

package lock8;

import java.util.concurrent.TimeUnit;
/**
 * 8锁，就是关于锁的8个问题
 * 3、增加一个普通方法后，先执行发短信还是Hello？先Hello再发短信
 * 4、两个对象，两个同步方法，先发短信还是先打电话？  两个对象 两个调用者，两把锁；所以都可以拿到锁，但是短信延迟了4秒，所以先打电话再发短信
 */

public class Test2 {
    public static void main(String[] args) {
//        两个对象 两个调用者，两把锁
        Phone2 phone = new Phone2();
        Phone2 phone2 = new Phone2();

//        锁的存在
        new Thread(()->{
            phone.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");
    }

}

/*
打电话
发短信
 */

解析：

两个对象两个调用者，两把锁；所以都可以拿到锁，但是短信延迟了4秒，所以先打电话再发短信

5.5、锁5现象一对象，两个static同步方法

5、增加两个静态的同步方法，先发短信还是先打电话？

package lock8;

import java.util.concurrent.TimeUnit;
/**
 * 8锁，就是关于锁的8个问题
 * 3、增加一个普通方法后，先执行发短信还是Hello？先Hello再发短信
 * 4、两个对象，两个同步方法，先发短信还是先打电话？  两个对象 两个调用者，两把锁；所以都可以拿到锁，但是短信延迟了4秒，所以先打电话再发短信
 * 5、增加两个静态的同步方法，先发短信还是先打电话？静态方法，类一加载的就有了，锁的是Class，类只有一个模板，所以谁先拿到锁谁先执行，这里A创建B还没创建，A执行4秒，等1秒B可以创建，但是A拿着锁，所以B得等A释放锁之后才可以。因此先发短信再打电话。
 *
 */

public class Test3 {
    public static void main(String[] args) {
        Phone3 phone = new Phone3();

//        锁的存在
        new Thread(()->{
            phone.sendSms();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone.call();
        },"B").start();
    }
}
//Phone3唯一的一个class对象
class Phone3 {
//    静态方法，类一加载的就有了，锁的是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("打电话");

    }


}

/*
发短信
打电话
 */

解析：

静态方法，类一加载的就有了，锁的是Class，类只有一个模板，所以谁先拿到锁谁先执行。
这里A创建B还没创建，A执行4秒，等1秒B可以创建，但是A拿着锁，所以B得等A释放锁之后才可以。因此先发短信再打电话。

5.6、锁6对象两个对象，两个static同步方法

6、两个对象，增加两个静态同步方法，先发短信还是先打电话？

package lock8;

import java.util.concurrent.TimeUnit;
/**
 * 8锁，就是关于锁的8个问题
 * 3、增加一个普通方法后，先执行发短信还是Hello？先Hello再发短信
 * 4、两个对象，两个同步方法，先发短信还是先打电话？  两个对象 两个调用者，两把锁；所以都可以拿到锁，但是短信延迟了4秒，所以先打电话再发短信
 * 5、增加两个静态的同步方法，先发短信还是先打电话？静态方法，类一加载的就有了，锁的是Class，类只有一个模板，所以谁先拿到锁谁先执行
 * 6、两个对象，增加两个静态同步方法，先发短信还是先打电话？ 两个对象的class类模板只有一个，static，锁的是class。所以谁先拿到锁谁先执行，这里A创建B还没创建，A执行4秒，等1秒B可以创建，但是A拿着锁，所以B得等A释放锁之后才可以。因此先发短信再打电话。
 *
 */

public class Test3 {
    public static void main(String[] args) {
//        两个对象的class类模板只有一个，static，锁的是class。
        Phone3 phone = new Phone3();
        Phone3 phone2 = new Phone3();

//        锁的存在
        new Thread(()->{
            phone.sendSms();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}
//Phone3唯一的一个class对象
class Phone3 {
//    静态方法，类一加载的就有了，锁的是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("打电话");

    }


}

/*
发短信
打电话
 */

解析：

两个对象的class类模板只有一个，static，锁的是class。所以谁先拿到锁谁先执行
这里A创建B还没创建，A执行4秒，等1秒B可以创建，但是A拿着锁，所以B得等A释放锁之后才可以。因此先发短信再打电话。
虽然不同对象调用不同方法，但是是静态方法，锁着的是Class模板，所以锁的对象是一样的，只能等锁释放才可以继续执行下一个。

对于static静态方法来说，对于整个类Class来说只有一份，对于不同的对象使用的是同一份方法，相当于这个方法是属于这个类的，如果静态static方法使用synchronized锁定，那么这个synchronized锁会锁住整个对象！不管多少个对象，对于静态的锁都只有一把锁，谁先拿到这个锁就先执行，其他的进程都需要等待！

5.7、锁7现象一对象，static和普通同步方法

7、1个静态同步方法，1个普通的同步方法，一个对象，先发短信还是先打电话？

package lock8;

import java.util.concurrent.TimeUnit;
/**
 * 8锁，就是关于锁的8个问题
 * 3、增加一个普通方法后，先执行发短信还是Hello？先Hello再发短信
 * 4、两个对象，两个同步方法，先发短信还是先打电话？  两个对象 两个调用者，两把锁；所以都可以拿到锁，但是短信延迟了4秒，所以先打电话再发短信
 * 5、增加两个静态的同步方法，先发短信还是先打电话？静态方法，类一加载的就有了，锁的是Class，类只有一个模板，所以谁先拿到锁谁先执行
 * 6、两个对象，增加两个静态同步方法，先发短信还是先打电话？ 两个对象的class类模板只有一个，static，锁的是class。所以谁先拿到锁谁先执行
 * 7、1个静态同步方法，1个普通的同步方法，一个对象，先发短信还是先打电话？先打电话再发短信，因为static锁的是类模板，普通同步方法锁的是方法的调用者，所以两个锁的对象不一样，都可以拿到锁。A创建线程的时候过了1秒B再创建，但是A要延迟4秒才调用了短信，所以这里1秒之后创建了线程B调用打电话方法直接输出打电话，然后过了几秒后才发短信。
 */

public class Test4 {
    public static void main(String[] args) {
//        两个对象的class类模板只有一个，static，锁的是class。
        Phone4 phone = new Phone4();

//        锁的存在
        new Thread(()->{
            phone.sendSms();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone.call();
        },"B").start();
    }
}
//Phone3唯一的一个class对象
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("打电话");

    }


}

/*
打电话
发短信
 */

解析：

先打电话再发短信，因为static锁的是类模板，普通同步方法锁的是方法的调用者，所以两个锁的对象不一样，都可以拿到锁。A创建线程的时候过了1秒B再创建，但是A要延迟4秒才调用了短信，所以这里1秒之后创建了线程B调用打电话方法直接输出打电话，然后过了几秒后才发短信。

5.8、锁8现象两对象，static和普通同步方法

8、1个静态同步方法，1个普通的同步方法，两个对象，先发短信还是先打电话？先打电话再发短信，因为static锁的是类模板，普通同步方法锁的是方法的调用者，所以两个锁的对象不一样，都可以拿到锁。A创建线程的时候过了1秒B再创建，但是A要延迟4秒才调用了短信，所以这里1秒之后创建了线程B调用打电话方法直接输出打电话，然后过了几秒后才发短信。

代码跟锁7对象差不多，就是多了一个对象调用打电话
在这里插入图片描述

6.、集合不安全

6.1、List 不安全

ArrayList在并发情况下是不安全的

package unsafe;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArrayList;
//java.util.ConcurrentModificationException 并发修改异常！
public class ListTest {
    public static void main(String[] args) {
//      并发下ArrayList是不安全的
        /**
         * 解决方案
         * 1、使用List<String> arrayList = new Vector<>();看源码会发现，vector先出来的，既然vector先出来都知道用synchronized去解决安全问题，那么ArrayList就不会想到吗？肯定会，但是为什么不能使用synchronized来解决呢
         * 2、使用List<Object> objects = Collections.synchronizedList(new ArrayList<>());
         * 3、使用CopyOnWriteArrayList<Object> objects = new CopyOnWriteArrayList<>();
         */

        List<String> 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();
        }

    }
}

会导致 java.util.ConcurrentModificationException 并发修改异常！
在这里插入图片描述
解决方案

List arrayList = new Vector<>();
List objects = Collections.synchronizedList(new ArrayList<>());
CopyOnWriteArrayList objects = new CopyOnWriteArrayList<>();

CopyOnWriteArrayList：写入时复制！ COW 计算机程序设计领域的一种优化策；
问题：多个线程调用的时候，list，读取的时候，固定的，写入的时候可能存在覆盖操作，第一个人修改了数据另一个人也修改了，但是两个人都不知道，那么后面提交的修改就将前面的修改覆盖掉了。
解决思想：在写入的时候避免覆盖，造成数据问题，所以会先复制一份，其它线程读取的时候还是之前的数据，等修改完成之后才将其插入进去。
读写分离 myCat
volatile 只能保证线程可见性，不能保证原子性原子性还是用cas来保证的

CopyOnWriteArrayList比Vector厉害在哪里？

Vector底层是使用synchronized关键字来实现的：效率特别低下

CopyOnWriteArrayList使用的是Lock锁，效率会更加高效！

为什么lock锁比synchronized效率更高呢？
synchronized

6.2、set 不安全

Set和List同理可得: 多线程情况下，普通的Set集合是线程不安全的；

解决方案还是两种：

使用Collections工具类的synchronized包装的Set类
使用CopyOnWriteArraySet 写入复制的JUC解决方案



package unsafe;

import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArraySet;

public class SetTest {
    public static void main(String[] args) {
        /**
         * 解决方法：
         * 1. Set<String> set = Collections.synchronizedSet(new HashSet<>());
         * 2. Set<String> set = new CopyOnWriteArraySet<>();
         */
//        Set<String> set = new HashSet<>();
        Set<String> set = new CopyOnWriteArraySet<>();

        for (int i = 1; i <= 30; i++) {
            new Thread(() -> {
                set.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(set);
            },String.valueOf(i)).start();
        }
    }
}

HashSet底层是什么？

hashSet底层就是一个HashMap，知道HashMap原理也就知道了HashSet原理了；

6.3、Map不安全

/map 是这样用的吗？  不是，工作中不使用这个
//默认等价什么？ new HashMap<>(16,0.75);
Map<String, String> map = new HashMap<>();
//加载因子、初始化容量

默认加载因子是0.75,默认的初始容量是16

在这里插入图片描述

同样的HashMap基础类也存在并发修改异常！

public class MapTest {
    public static void main(String[] args) {
        //默认等价什么？ new HashMap<>(16,0.75);
        /**
         * 解决方案
         * 1、Map<String, String> map = Collections.synchronizedMap(new HashMap<>());
         * 2、Map<String, String> map = new ConcurrentHashMap<>();
         */
        Map<String, String> map = new ConcurrentHashMap<>();
        //加载因子、初始化容量
        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();
        }
    }
}

ConcurrentHashMap底层原理？

7. Callable

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

public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        for (int i = 1; i < 10; i++) {
            MyThread1 myThread1 = new MyThread1();

            FutureTask<Integer> futureTask = new FutureTask<>(myThread1);//适配类
            // 放入Thread中使用，结果会被缓存
            new Thread(futureTask,String.valueOf(i)).start();
            // 这个get方法可能会被阻塞，如果在call方法中是一个耗时的方法，所以一般情况我们会把这个放在最后，或者使用异步通信
            int a = futureTask.get();
            System.out.println("返回值:" + s);
        }

    }

}
class MyThread1 implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        System.out.println("call()");
        return 1024;
    }
}

futuretask实现了runnable接口的子接口runnablefuture，futuretask又有一个带有callable类型参数的构造器，所以futuretask可以作为runnable接口的实现类传到thread的构造器中

8、常用的辅助类（必会）

8.1、CountDownLatch

概念
在这里插入图片描述
代码

package unsafe;

import java.util.concurrent.CountDownLatch;
//计数器
public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        // 总数是6
        CountDownLatch countDownLatch = new CountDownLatch(6);

        for (int i = 1; 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.await(); // 等待计数器归零 然后向下执行
没有的时候计数器没有归零也可以往下走
执行结果：
close door
2==> Go Out
1==> Go Out
3==> Go Out
4==> Go Out
5==> Go Out
6==> Go Out
有了那句的时候执行结果:
1==> Go Out
2==> Go Out
3==> Go Out
4==> Go Out
5==> Go Out
6==> Go Out
close door
 */

在这里插入图片描述

8.2、CyclickBarrier

概念
在这里插入图片描述
代码

package unsafe;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        /**
         * 集齐7颗龙珠召唤神龙
         */
        // 主线程 召唤龙珠的线程
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,() -> {
            System.out.println("召唤神龙成功");
        });
        for (int i = 1; i <= 7; i++) {
            // 子线程
            int finalI = i;
//            这里JDK1.8之前如果finalIst不是final类型的，lambda能操作到finalI吗？不能，finalI是局部变量
//            现在JDK1.8之后默认是final类型的。jdk8检测你局部变量没有被修改，编译时会给你加上final。
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "收集了第" + finalI + "颗龙珠");
                try {
                    cyclicBarrier.await(); // 加法计数 等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}
/*
注意：如果 CyclicBarrier cyclicBarrier = new CyclicBarrier(7,() -> {
            System.out.println("召唤神龙成功");
        });不是用7而是用了8，那么不会输出召唤神龙成功输出，因为线程里就集齐了7个，由于计数器要加到8之后才可以继续往下执行
执行结果：
Thread-1收集了第2颗龙珠
Thread-2收集了第3颗龙珠
Thread-0收集了第1颗龙珠
Thread-3收集了第4颗龙珠
Thread-4收集了第5颗龙珠
Thread-5收集了第6颗龙珠
Thread-6收集了第7颗龙珠
召唤神龙成功
 */

8.3、Semaphore

概念
在这里插入图片描述
代码

package unsafe;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class SemaphoreDemo {
    public static void main(String[] args) {

        // 线程数量，停车位，限流
        Semaphore semaphore = new Semaphore(3);
        for (int i = 0; i <= 6; i++) {
            new Thread(() -> {
                // acquire() 得到
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + "抢到车位");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName() + "离开车位");
                }catch (Exception e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release(); // release() 释放
                }
            }).start();
        }
    }
}
/*
执行结果：
Thread-0抢到车位
Thread-1抢到车位
Thread-2抢到车位
Thread-2离开车位
Thread-0离开车位
Thread-3抢到车位
Thread-4抢到车位
Thread-1离开车位
Thread-5抢到车位
Thread-3离开车位
Thread-6抢到车位
Thread-4离开车位
Thread-5离开车位
Thread-6离开车位
 */

原理：
在这里插入图片描述

CountDownLatch：指定线程执行完毕，再执行操作
CyclicBarrier：指定的个数线程都执行完毕，再执行操作
Semaphore：同一时间只能有指定数量得到线程

9、读写锁

概念

不加锁的

package rw;

import jdk.nashorn.internal.ir.CallNode;

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

/**
 * ReadWriteLock
 * 独占锁（写锁） 一次只能被一个线程占有
 * 共享锁（读锁） 多个线程可以同时占有
 * 读-读  可以共存
 * 读-写  不可以共存
 * 写-写  不可以共存
 */
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();
//      写入
        for (int i = 1; i <= 5; i++) {
            int temp = i;
            new Thread(() -> {

                myCache.put(temp + "", temp + "");

            },String.valueOf(i)).start();
        }
//      读取
        for (int i = 1; i <= 5; i++) {
            int temp = i;
            new Thread(() -> {

                myCache.get(temp + "");

            },String.valueOf(i)).start();
        }
    }
}

/**
 * 自定义缓存
 * 方法未加锁，导致写的时候被插队
 */
class MyCache {
    private volatile Map<String, String> map = new HashMap<>();
//  存，写
    public void put(String key, String value) {
        System.out.println(Thread.currentThread().getName() + "写入");
        map.put(key, value);
        System.out.println(Thread.currentThread().getName() + "写入ok");
    }
//  取，读
    public void get(String key) {
        System.out.println(Thread.currentThread().getName() + "读取");
        map.get(key);
        System.out.println(Thread.currentThread().getName() + "读取ok");
    }
}

/*
执行结果：
1写入
2写入
2写入ok
1写入ok
4写入
4写入ok
3写入
3写入ok
5写入
5写入ok
1读取
2读取
2读取ok
1读取ok
3读取
3读取ok
4读取
4读取ok
5读取
5读取ok
 */

加锁的

package rw;

import jdk.nashorn.internal.ir.CallNode;

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

/**
 * ReadWriteLock
 * 独占锁（写锁） 一次只能被一个线程占有
 * 共享锁（读锁） 多个线程可以同时占有
 * 读-读  可以共存
 * 读-写  不可以共存
 * 写-写  不可以共存
 */
public class ReadWriteLockDemo {
    public static void main(String[] args) {
//        MyCache myCache = new MyCache();
        MyCacheLock myCacheLock = new MyCacheLock();
//      写入
        for (int i = 1; i <= 5; i++) {
            int temp = i;
            new Thread(() -> {

                myCacheLock.put(temp + "", temp + "");

            },String.valueOf(i)).start();
        }
//      读取
        for (int i = 1; i <= 5; i++) {
            int temp = i;
            new Thread(() -> {

                myCacheLock.get(temp + "");

            },String.valueOf(i)).start();
        }
    }
}

//加锁的
class MyCacheLock {
    private volatile Map<String, String> map = new HashMap<>();
    private ReadWriteLock lock = new ReentrantReadWriteLock();
    //  存，写入的时候，只希望同时只有一个线程写
    public void put(String key, String value) {
        lock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "写入");
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + "写入ok");
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.writeLock().unlock();
        }

    }
    //  取，读
    public void get(String key) {
        lock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "读取");
            map.get(key);
            System.out.println(Thread.currentThread().getName() + "读取ok");
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.readLock().unlock();
        }


    }
}

/*
执行结果：
1写入
1写入ok
2写入
2写入ok
3写入
3写入ok
4写入
4写入ok
5写入
5写入ok
3读取
3读取ok
2读取
2读取ok
1读取
1读取ok
4读取
4读取ok
5读取
5读取ok
 */

10、阻塞队列

先进先出FIFO

阻塞队列
在这里插入图片描述

10.1、BlockQueue

是Collection的一个子类
在这里插入图片描述

什么情况下我们会使用阻塞队列：多线程并发处理、线程池

学会使用队列

BlockingQueue 有四组API

抛出异常
不会抛出异常
阻塞等待
超时等待

方式	抛出异常	不会抛出异常，有返回值	阻塞，等待	超时等待
添加	add	offer	put	offer(timenum.timeUnit)
移出	remove	poll	take	poll(timenum,timeUnit)
判断队首元素	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(blockingQueue.element());//查看对首元素是谁
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"));
        //添加 一个不能添加的元素 使用offer只会返回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());
    }
=======================================================================================
/**
     * 等待 一直阻塞
     */
    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");
        System.out.println("开始等待");
        blockingQueue.offer("d",2, TimeUnit.SECONDS);  //超时时间2s 等待如果超过2s就结束等待
        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("结束等待");
    }

10.2、SynchronousQueue同步队列

同步队列没有容量，也可以视为容量为1的队列；
进去一个元素，必须等待取出来之后，才能再往里面放入一个元素；
put方法和 take方法；
同步队列和其他的BlockingQueue 不一样它不存储元素；
put了一个元素，就必须从里面先take出来，否则不能再put进去值！
并且SynchronousQueue 的take是使用了lock锁保证线程安全的。

package com.marchsoft.queue;

import java.util.concurrent.BlockingDeque;
import java.util.concurrent.BlockingQueue;

/**
 * Description：
 *
 * @author jiaoqianjin
 * Date: 2020/8/12 10:02
 **/

public class SynchronousQueue {
    public static void main(String[] args) {
        BlockingQueue<String> synchronousQueue = new java.util.concurrent.SynchronousQueue<>();
        // 网queue中添加元素
        new Thread(() -> {
            try {
                System.out.println(Thread.currentThread().getName() + "put 01");
                synchronousQueue.put("1");
                System.out.println(Thread.currentThread().getName() + "put 02");
                synchronousQueue.put("2");
                System.out.println(Thread.currentThread().getName() + "put 03");
                synchronousQueue.put("3");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        // 取出元素
        new Thread(()-> {
            try {
                System.out.println(Thread.currentThread().getName() + "take" + synchronousQueue.take());
                System.out.println(Thread.currentThread().getName() + "take" + synchronousQueue.take());
                System.out.println(Thread.currentThread().getName() + "take" + synchronousQueue.take());
            }catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}
/*
Thread-0put 01
Thread-1take1
Thread-0put 02
Thread-1take2
Thread-0put 03
Thread-1take3
*/

11、线程池（重点）

线程池：三大方式、七大参数、四种拒绝策略

池化技术

程序的运行，本质：占用系统的资源！我们需要去优化资源的使用 ===> 池化技术
线程池、JDBC的连接池、内存池、对象池。。。。资源的创建、销毁十分消耗资源
池化技术：事先准备好一些资源，如果有人要用，就来我这里拿，用完之后还给我，以此来提高效率。

11.1、线程池的好处：

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

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

11.2、线程池：三大方法

ExecutorService threadPool = Executors.newSingleThreadExecutor();//单个线程
ExecutorService threadPool2 = Executors.newFixedThreadPool(5); //创建一个固定的线程池的大小

ExecutorService threadPool3 = Executors.newCachedThreadPool(); //可伸缩的

//工具类 Executors 三大方法；
public class Demo01 {
    public static void main(String[] args) {

        ExecutorService threadPool = Executors.newSingleThreadExecutor();//单个线程
        ExecutorService threadPool2 = Executors.newFixedThreadPool(5); //创建一个固定的线程池的大小
        ExecutorService threadPool3 = Executors.newCachedThreadPool(); //可伸缩的

        //线程池用完必须要关闭线程池
        try {

            for (int i = 1; i <=100 ; i++) {
                //通过线程池创建线程
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+ " ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }
    }
}

11.3、七大参数

源码分析
在这里插入图片描述

本质：其实三个方法都是调用的ThreadPoolExecutor

public static ExecutorService newSingleThreadExecutor() {
      return new FinalizableDelegatedExecutorService
          (new ThreadPoolExecutor(1, 1,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>()));//这里1，1也说明了核心线程数为1，最大线程数为1.
  }
public static ExecutorService newFixedThreadPool(int nThreads) {
      return new ThreadPoolExecutor(nThreads, nThreads,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>());//这里nTreads可以自己选，说明了核心线程数为自己设置的大小，最大线程数为自己设置的大小.
  }
public static ExecutorService newCachedThreadPool() {
      return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                    60L, TimeUnit.SECONDS,
                                    new SynchronousQueue<Runnable>());//这里的0代表默认的核心线程数为0，最大核心线程数可达到Integer.MAX_VALUE
  }
  
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;
}

线程池：
在这里插入图片描述

手动创建线程池：

package pool;

import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Demo01 {
    public static void main(String[] args) {
//        自定义线程池
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                2,//核心线程池
                5,//最大线程池大小
                3,//超过多长时间就会关闭最大线程池，也是释放线程池
                TimeUnit.SECONDS,//超时时间
                new LinkedBlockingDeque<>(3),//阻塞队列大小也就是候客区大小
                new ThreadPoolExecutor.AbortPolicy()//拒绝策略，
        );
        try {
//            最大承载：Deque+Max
            for (int i = 1; i <= 9; i++) {
                threadPoolExecutor.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPoolExecutor.shutdown();
        }
    }
}
/*
解析：循环5的时候：核心线程是2，候客区是3，所以刚好用不到后面的，这里只有两个人处理，还没有触发到后面的3个
pool-1-thread-1ok
pool-1-thread-1ok
pool-1-thread-1ok
pool-1-thread-1ok
pool-1-thread-2ok
解析：循环是6的时候，候客区满了，就触发了第三号
pool-1-thread-1ok
pool-1-thread-1ok
pool-1-thread-1ok
pool-1-thread-2ok
pool-1-thread-1ok
pool-1-thread-3ok
解析：循环是9的时候，抛出ThreadPoolExecutor异常，因为人数9超过了候客区（阻塞队列）+最大核心线程数=8；
 */

11.4、拒绝策略

1. new ThreadPoolExecutor.AbortPolicy()： //该拒绝策略为：银行满了，还有人进来，不处理这个人的，并抛出异常

超出最大承载，就会抛出异常：队列容量大小+maxPoolSize

2. new ThreadPoolExecutor.CallerRunsPolicy()： //该拒绝策略为：哪来的去哪里 main线程进行处理

3. new ThreadPoolExecutor.DiscardPolicy(): //该拒绝策略为：队列满了,丢掉异常，不会抛出异常。

4. new ThreadPoolExecutor.DiscardOldestPolicy()： //该拒绝策略为：队列满了，尝试去和最早的进程竞争，不会抛出异常

11.5、如何设置线程池的最大线程的大小

了解：CPU密集型 IO密集型（调优）

package pool;

import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Demo01 {
    public static void main(String[] args) {
//        自定义线程池

//        最大线程到底该如何定义
//        1、CPU 密集型，几核，就是几，可以保持CPU的效率最高
//        2、IO 密集型 判断你程序中十分耗IO的线程有多少个
//        程序 15个大型任务，io十分占用资源
//        获取CPU的核数
        System.out.println(Runtime.getRuntime().availableProcessors());//获取电脑是几核的

        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                2,//核心线程池
                5,//最大线程池大小
                3,//超过多长时间就会关闭最大线程池，也是释放线程池
                TimeUnit.SECONDS,//超时时间
                new LinkedBlockingDeque<>(3),//阻塞队列大小也就是候客区大小
                new ThreadPoolExecutor.AbortPolicy()//拒绝策略，
        );
        try {
//            最大承载：Deque+Max
            for (int i = 1; i <= 9; i++) {
                threadPoolExecutor.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPoolExecutor.shutdown();
        }
    }
}
/*
解析：循环5的时候：核心线程是2，候客区是3，所以刚好用不到后面的，这里只有两个人处理，还没有触发到后面的3个
pool-1-thread-1ok
pool-1-thread-1ok
pool-1-thread-1ok
pool-1-thread-1ok
pool-1-thread-2ok
解析：循环是6的时候，候客区满了，就触发了第三号
pool-1-thread-1ok
pool-1-thread-1ok
pool-1-thread-1ok
pool-1-thread-2ok
pool-1-thread-1ok
pool-1-thread-3ok
解析：循环是9的时候，抛出ThreadPoolExecutor异常，因为人数9超过了候客区（阻塞队列）+最大核心线程数=8；
 */

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

新时代的程序员：lambda表达式、链式编程、函数式接口、Stream流式计算
之前掌握的：泛型、枚举、反射和注解

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

超级多FunctionalInterface
简化编程模型，在新版本的框架底层大量应用
foreach（消费者类的函数式接口）

在这里插入图片描述

12.1、Function 函数型接口

在这里插入图片描述

package function;

import java.util.function.Function;

/**
 * Function 函数型接口，有一个输入参数，有一个输出
 * 只要是函数型接口 可以 用lambda表达式简化
 */
public class Demo01 {
    public static void main(String[] args) {
//        工具类：输出输入的值
        Function stringStringFunction = new Function<String, String>() {
            @Override
            public String apply(String s) {
                return s;
            }
        };
        //可以使用这个代替上面的
//        Function function(str)->{
//            return str;}
        System.out.println(stringStringFunction.apply("asd"));

    }
}

12.2、Predicate 断定型接口

package function;

import com.sun.org.apache.xpath.internal.objects.XBoolean;

import java.util.function.Predicate;

/**
 * 断定型接口：有一个输入参数，返回值只能是 布尔值
 */
public class PredicateDemo {
    public static void main(String[] args) {
//        判断字符串是否为空
//        Predicate<String> stringPredicate = new Predicate<String>(){
//
//            @Override
//            public boolean test(String s) {
//                return s.isEmpty();
//            }
//        };
       


        Predicate<String> predicate = (str) -> {return str.isEmpty();};
        // false
        System.out.println(predicate.test("aaa"));
        // true
        System.out.println(predicate.test(""));
    }
}

12.3、Consummer 消费型接口

package function;

import java.util.function.Consumer;
import java.util.function.Supplier;

/**
 * Consumer 消费型接口：只有输入，没有返回值
 */
public class Demo3 {
    public static void main(String[] args) {
/*        Consumer<String> stringConsumer = new Consumer<String>(){

            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };*/
        Consumer<String> stringConsumer = (s)->{
            System.out.println(s);;};
        stringConsumer.accept("adadasd");
        
    }
}

12.4、Supplier 供给型接口

在这里插入图片描述

package function;

import java.util.function.Supplier;

/**
 * Supplier 供给型接口，没有参数，只有返回值
 */
public class Demo04 {
    public static void main(String[] args) {
//        Supplier<Integer> integerSupplier = new Supplier<>(){
//
//            @Override
//            public Object get() {
//                return 1016;
//            }
//        };
        Supplier<Integer> supplier=()->{
            return 1016;
        };
        System.out.println(supplier.get());

    }
}

13、Stream 流式计算

大数据：存储+计算
集合、MySQL本质就是存储数据的
计算都应该交给流来操作
在这里插入图片描述
代码

package stream;

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

/**
 * Description：
 * 题目要求： 用一行代码实现
 * 1. Id 必须是偶数
 * 2.年龄必须大于23
 * 3. 用户名转为大写
 * 4. 用户名倒序
 * 5. 只能输出一个用户
 **/

public class Test {
    public static void main(String[] args) {
        User u1 = new User(1, "a", 23);
        User u2 = new User(2, "b", 23);
        User u3 = new User(3, "c", 23);
        User u4 = new User(6, "d", 24);
        User u5 = new User(4, "e", 25);
//      集合就是用来存储数据的，计算交给流操作
        List<User> list = Arrays.asList(u1, u2, u3, u4, u5);
        // lambda、链式编程、函数式接口、流式计算
//        计算交给流操作
//        lambda表达式，链式编程，函数式接口，Stream流计算
        list.stream()
                .filter(user -> {return user.getId()%2 == 0;})
                .filter(user -> {return user.getAge() > 23;})
                .map(user -> {return user.getName().toUpperCase();})
                .sorted((user1, user2) -> {return user2.compareTo(user1);})
                .limit(1)
                .forEach(System.out::println);
    }
}

14、ForkJoin

ForkJoin 在JDK1.7，并行执行任务！提高效率~。在大数据量速率会更快！

大数据中：MapReduce 核心思想->把大任务拆分为小任务！

14.1、ForkJoin 特点：工作窃取！

这里维护的都是双端队列
实现原理是：双端队列！从上面和下面都可以去拿到任务进行执行！

14.2、如何使用ForkJoin?

在这里插入图片描述

1、通过ForkJoinPool来执行
2、计算任务 execute(ForkJoinTask task)
3、计算类要去继承ForkJoinTask；

ForkJoin 的计算类

package com.marchsoft.forkjoin;

import java.util.concurrent.RecursiveTask;

/**
 * Description：
 *
 * @author jiaoqianjin
 * Date: 2020/8/13 8:33
 **/

public class ForkJoinDemo extends RecursiveTask<Long> {
    private long star;
    private long end;
    /** 临界值 */
    private long temp = 1000000L;

    public ForkJoinDemo(long star, long end) {
        this.star = star;
        this.end = end;
    }

    /**
     * 计算方法
     * @return
     */
    @Override
    protected Long compute() {
        if ((end - star) < temp) {
            Long sum = 0L;
            for (Long i = star; i < end; i++) {
                sum += i;
            }
            return sum;
        }else {
            // 使用ForkJoin 分而治之 计算
            //1 . 计算平均值
            long middle = (star + end) / 2;
            ForkJoinDemo forkJoinDemo1 = new ForkJoinDemo(star, middle);
            // 拆分任务，把线程压入线程队列
            forkJoinDemo1.fork();
            ForkJoinDemo forkJoinDemo2 = new ForkJoinDemo(middle, end);
            // 拆分任务，把线程压入线程队列
            forkJoinDemo2.fork();

            long taskSum = forkJoinDemo1.join() + forkJoinDemo2.join();
            return taskSum;
        }
    }
}

测试类

package com.marchsoft.forkjoin;

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

/**
 * Description：
 *
 * @author jiaoqianjin
 * Date: 2020/8/13 8:43
 **/

public class ForkJoinTest {
    private static final long SUM = 20_0000_0000;

    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 < SUM ; i++) {
            sum += i;
        }
        long end = System.currentTimeMillis();
        System.out.println(sum);
        System.out.println("时间：" + (end - star));
        System.out.println("----------------------");
    }
    /**
     * 使用ForkJoin 方法
     */
    public static void test2() throws ExecutionException, InterruptedException {
        long star = System.currentTimeMillis();

        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Long> task = new ForkJoinDemo(0L, SUM);
        ForkJoinTask<Long> submit = forkJoinPool.submit(task);
        Long along = submit.get();

        System.out.println(along);
        long end = System.currentTimeMillis();
        System.out.println("时间：" + (end - star));
        System.out.println("-----------");
    }
    /**
     * 使用 Stream 流计算
     */
    public static void test3() {
        long star = System.currentTimeMillis();

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

.parallel().reduce(0, Long::sum)使用一个并行流去计算整个计算，提高效率。

15、异步回调

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

其实就是前端 --> 发送ajax异步请求给后端
在这里插入图片描述

但是我们平时都使用CompletableFuture

15.1、没有返回值的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());  //获取执行结果
 }

15.2、有返回值的异步回调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

16.1、谈谈对Volatile 的理解

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

1、保证可见性
2、不保证原子性
3、禁止指令重排
如何实现可见性

volatile变量修饰的共享变量在进行写操作的时候回多出一行汇编：

0x01a3de1d:movb $0×0，0×1104800（%esi）;0x01a3de24**:lock** addl $0×0,(%esp);

Lock前缀的指令在多核处理器下会引发两件事情。

1）将当前处理器缓存行的数据写回到系统内存。

2）这个写回内存的操作会使其他cpu里缓存了该内存地址的数据无效。

多处理器总线嗅探：

为了提高处理速度，处理器不直接和内存进行通信，而是先将系统内存的数据读到内部缓存后再进行操作，但操作不知道何时会写到内存。如果对声明了volatile的变量进行写操作，JVM就会向处理器发送一条lock前缀的指令，将这个变量所在缓存行的数据写回到系统内存。但是在多处理器下，为了保证各个处理器的缓存是一致的，就会实现缓存缓存一致性协议，每个处理器通过嗅探在总线上传播的数据来检查自己的缓存值是不是过期了，如果处理器发现自己缓存行对应的内存地址呗修改，就会将当前处理器的缓存行设置无效状态，当处理器对这个数据进行修改操作的时候，会重新从系统内存中把数据库读到处理器缓存中。

16.2、什么是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

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

17.2、不保证原子性

原子性：不可分割；

线程A在执行任务的时候，不能被打扰的，也不能被分割的，要么同时成功，要么同时失败。

/**
 * 不保证原子性
 * number <=2w
 * 
 */
public class VDemo02 {

    private static volatile int number = 0;

    public static void add(){
        number++; 
        //++ 不是一个原子性操作，是两个~3个操作
        //
    }

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

如果不加lock和synchronized ，怎么样保证原子性？

使用原子类

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类是一个很特殊的存在；

原子类为什么这么高级？

17.3、禁止指令重排

什么是指令重排？

我们写的程序，计算机并不是按照我们自己写的那样去执行的

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

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

int x=1; //1
int y=2; //2
x=x+5;   //3
y=x*x;   //4

//我们期望的执行顺序是 1_2_3_4  可能执行的顺序会变成2134 1324
//可不可能是 4123？ 不可能的
1234567

可能造成的影响结果：前提：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

可能在线程A中会出现，先执行b=1,然后再执行x=a；

在B线程中可能会出现，先执行a=2，然后执行y=b；

那么就有可能结果如下：x=2; y=1.

volatile可以避免指令重排：

volatile中会加一道内存的屏障，这个内存屏障可以保证在这个屏障中的指令顺序。

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

1、保证特定的操作的执行顺序；

2、可以保证某些变量的内存可见性（利用这些特性，就可以保证volatile实现的可见性)

17.4、总结

volatile可以保证可见性；
不能保证原子性
由于内存屏障，可以保证避免指令重排的现象产生

面试官：那么你知道在哪里用这个内存屏障用得最多呢？单例模式

18、玩转单例模式

饿汉式、DCL懒汉式

18.1、饿汉式

/**
 * 饿汉式单例
 */
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;
    }

}

18.2、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);
    }
}

18.3、静态内部类

//静态内部类
public class Holder {
    private Holder(){

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

单例不安全, 因为反射

18.4、枚举

//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.<init>()

        EnumSingle instance2 = declaredConstructor.newInstance();
        System.out.println(instance1);
        System.out.println(instance2);
    }
}

使用枚举，我们就可以防止反射破坏了。

枚举类型的最终反编译源码：

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

19.1、什么是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 类

19.2、总结

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;

/**
 * Description：
 *
 * @author jiaoqianjin
 * Date: 2020/8/12 22:07
 **/

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、各种锁的理解

21.1、公平锁，非公平锁

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

/**
 * Creates an instance of {@code ReentrantLock}.
 * This is equivalent to using {@code ReentrantLock(false)}.
 */
public ReentrantLock() {
    sync = new NonfairSync();
}

2.非公平锁：非常不公平，允许插队，可以改变顺序

/**
 * 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();
}

21.2、可重入锁

Synchonized 锁

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.out.println(Thread.currentThread().getName()+"=> sms");
        call();//这里也有一把锁
    }
    public synchronized void call(){
        System.out.println(Thread.currentThread().getName()+"=> call");
    }
}

2.Lock 锁

//lock
public class Demo02 {

    public static void main(String[] args) {
        Phone2 phone = new Phone2();
        new Thread(()->{
            phone.sms();
        },"A").start();
        new Thread(()->{
            phone.sms();
        },"B").start();
    }

}
class Phone2{

    Lock lock=new ReentrantLock();

    public void sms(){
        lock.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");
        }catch (Exception e){
            e.printStackTrace();
        }
        finally {
            lock.unlock();
        }
    }
}

lock锁必须配对，相当于lock和 unlock 必须数量相同；
在外面加的锁，也可以在里面解锁；在里面加的锁，在外面也可以解锁；

21.3、自旋锁

spinlock

public final int getAndAddInt(Object var1, long var2, int var4) {
    int var5;
    do {
        var5 = this.getIntVolatile(var1, var2);
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
    return var5;
}

2.自我设计自旋锁

public class SpinlockDemo {

    // 默认
    // int 0
    //thread null
    AtomicReference<Thread> atomicReference=new AtomicReference<>();

    //加锁
    public void myLock(){
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName()+"===> mylock");

        //自旋锁
        while (!atomicReference.compareAndSet(null,thread)){
            System.out.println(Thread.currentThread().getName()+" ==> 自旋中~");
        }
    }


    //解锁
    public void myUnlock(){
        Thread thread=Thread.currentThread();
        System.out.println(thread.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 spinlockDemo=new SpinlockDemo();
        new Thread(()->{
            spinlockDemo.myLock();
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                spinlockDemo.myUnlock();
            }
        },"t1").start();

        TimeUnit.SECONDS.sleep(1);


        new Thread(()->{
            spinlockDemo.myLock();
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                spinlockDemo.myUnlock();
            }
        },"t2").start();
    }
}

运行结果：

t2进程必须等待t1进程Unlock后，才能Unlock，在这之前进行自旋等待。。。。

21.4、死锁

package com.ogj.lock;

import java.util.concurrent.TimeUnit;

public class DeadLock {
    public static void main(String[] args) {
        String lockA= "lockA";
        String lockB= "lockB";

        new Thread(new MyThread(lockA,lockB),"t1").start();
        new Thread(new MyThread(lockB,lockA),"t2").start();
    }
}

class MyThread implements Runnable{

    private String lockA;
    private String lockB;

    public MyThread(String lockA, String lockB) {
        this.lockA = lockA;
        this.lockB = lockB;
    }

    @Override
    public void run() {
        synchronized (lockA){
            System.out.println(Thread.currentThread().getName()+" lock"+lockA+"===>get"+lockB);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lockB){
                System.out.println(Thread.currentThread().getName()+" lock"+lockB+"===>get"+lockA);
            }
        }
    }
}

如何解开死锁

1、使用jps定位进程号，jdk的bin目录下：有一个jps

命令：jps -l

2、使用jstack 进程进程号找到死锁信息

一般情况信息在最后：

ence atomicReference=new AtomicReference<>();

//加锁
public void myLock(){
    Thread thread = Thread.currentThread();
    System.out.println(thread.getName()+"===> mylock");

    //自旋锁
    while (!atomicReference.compareAndSet(null,thread)){
        System.out.println(Thread.currentThread().getName()+" ==> 自旋中~");
    }
}


//解锁
public void myUnlock(){
    Thread thread=Thread.currentThread();
    System.out.println(thread.getName()+"===> myUnlock");
    atomicReference.compareAndSet(thread,null);
}

}


```java
public class TestSpinLock {
    public static void main(String[] args) throws InterruptedException {
        ReentrantLock reentrantLock = new ReentrantLock();
        reentrantLock.lock();
        reentrantLock.unlock();


        //使用CAS实现自旋锁
        SpinlockDemo spinlockDemo=new SpinlockDemo();
        new Thread(()->{
            spinlockDemo.myLock();
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                spinlockDemo.myUnlock();
            }
        },"t1").start();

        TimeUnit.SECONDS.sleep(1);


        new Thread(()->{
            spinlockDemo.myLock();
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                spinlockDemo.myUnlock();
            }
        },"t2").start();
    }
}

运行结果：

t2进程必须等待t1进程Unlock后，才能Unlock，在这之前进行自旋等待。。。。

21.5、死锁

[外链图片转存中…(img-l4geca1Q-1618478652073)]

package com.ogj.lock;

import java.util.concurrent.TimeUnit;

public class DeadLock {
    public static void main(String[] args) {
        String lockA= "lockA";
        String lockB= "lockB";

        new Thread(new MyThread(lockA,lockB),"t1").start();
        new Thread(new MyThread(lockB,lockA),"t2").start();
    }
}

class MyThread implements Runnable{

    private String lockA;
    private String lockB;

    public MyThread(String lockA, String lockB) {
        this.lockA = lockA;
        this.lockB = lockB;
    }

    @Override
    public void run() {
        synchronized (lockA){
            System.out.println(Thread.currentThread().getName()+" lock"+lockA+"===>get"+lockB);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lockB){
                System.out.println(Thread.currentThread().getName()+" lock"+lockB+"===>get"+lockA);
            }
        }
    }
}

如何解开死锁

1、使用jps定位进程号，jdk的bin目录下：有一个jps

命令：jps -l

[外链图片转存中…(img-m0FTTsCe-1618478652082)]

2、使用jstack 进程进程号找到死锁信息

[外链图片转存中…(img-OJza968A-1618478652086)]

一般情况信息在最后：

dxj1016

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
多线程进阶=＞JUC并发编程

JUC并发编程1. 什么是JUCJUC就是java.util.concurrent下面的类包，专门用于多线程的开发。（源码+官方文档面试高频问）2. 线程和进程进程是操作系统中的应用程序、是资源分配的基本单位，线程是用来执行具体的任务和功能，是CPU调度和分派的最小单位一个进程往往可以包含多个线程，至少包含一个1）进程一个程序，QQ.EXE Music.EXE；数据+代码+pcb一个进程可以包含多个线程，至少包含一个线程！Java默认有几个线程？2个线程！ main线程、GC线程
复制链接

扫一扫