JUC并发编程---学习笔记

最新推荐文章于 2023-06-14 16:55:02 发布
最新推荐文章于 2023-06-14 16:55:02 发布
阅读量214 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45304571/article/details/122382627
版权

什么是JUC

 

java.util工具包、包、分类

业务：普通的线程代码Thread

Runnable 没有返回值、效率相比入Callable相对较低！

2、线程和进程

进程：一个程序，QQ.exe 程序的集合

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

Java默认有几个线程？2个 main 、GC

线程：开了一个进程Typora，写字，自动保存（线程负责）

对于Java而言：Thread、Runnable、Callable

Java真的可以开启线程嘛？开不了

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

并发、并行

并发编程：并发、并行

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

  • CPU一核，模拟出来多条线程，快速交替

并行：多个人一起行走

  • CPU多核，多个线程可以同时执行
public class Test1 {
    public static void main(String[] args) {
        // 获取CPU核数
        // CPU密集型，IO密集型
        System.out.println(Runtime.getRuntime().availableProcessors());
    }
}

并发编程的本质：充分利用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:
         * <ul>
         *   <li>{@link Object#wait() Object.wait} with no timeout</li>
         *   <li>{@link #join() Thread.join} with no timeout</li>
         *   <li>{@link LockSupport#park() LockSupport.park}</li>
         * </ul>
         *
         * <p>A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called <tt>Object.wait()</tt>
         * on an object is waiting for another thread to call
         * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
         * that object. A thread that has called <tt>Thread.join()</tt>
         * 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:
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         */
        // 超时等待 (过时不候)
        TIMED_WAITING,

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         */
        // 终止
        TERMINATED;
    }

wait/sleep 区别

1、来自不同的类

wait => Object

sleep => Thread

2、关于锁的释放

wait会释放锁，sleep不会释放锁。

3、使用的范围是不同的

wait 必须再同步代码块

sleep可以再任何地方

4、是否需要捕获异常

wait需要捕获异常

sleep必须要捕获异常

3、Lock锁

传统的synchronized

package com.hzx.demo01;

// 卖票例子

/**
 * 真正的多线程开发 公司中的开发 降低耦合性
 * 线程就是一个单独的资源类 没有任何附属的操作
 * 1、属性、方法
 */
public class SaleTicketDemo01 {
    public static void main(String[] args) {
        // 并发:多个线程操作同一个资源类,把资源类丢入线程
        Ticket ticket = new Ticket();

        // @FunctionalInterface 函数式接口, lamda表达式 (参数)->{代码}
        new Thread(()->{
            for (int i = 1; i < 40; i++){
                ticket.sale();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 1; i < 40; i++){
                ticket.sale();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 1; i < 40; i++){
                ticket.sale();
            }
        },"C").start();
    }
}

//资源类 OOP
class Ticket{
    // 属性、方法
    private int number = 30;

    // 卖票的方式
    // synchronized 本质: 队列,锁
    public synchronized void sale(){
        if(number > 0){
            System.out.println(Thread.currentThread().getName()+"卖出了"+(number--)+"票,剩余:"+number);
        }
    }

    // 对象
    // class
}

Lock锁

公平锁: 十分公平 先来后到

非公平锁: 十分不公平 可以插队（默认）

package com.hzx.demo01;

// 卖票例子

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

/**
 * 真正的多线程开发 公司中的开发 降低耦合性
 * 线程就是一个单独的资源类 没有任何附属的操作
 * 1、属性、方法
 */
public class SaleTicketDemo02 {
    public static void main(String[] args) {
        // 并发:多个线程操作同一个资源类,把资源类丢入线程
        Ticket1 ticket = new Ticket1();

        // @FunctionalInterface 函数式接口, lamda表达式 (参数)->{代码}
        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();
    }
}

// Lock三部曲

/**
 * 1、 new ReentrantLock();
 * 2、 lock.lock(); // 加锁
 * 3、 lock.unlock(); // 解锁
 */
class Ticket1{
    // 属性、方法
    private int number = 30;

    Lock lock = new ReentrantLock();
    
    public void sale(){
        lock.lock(); // 加锁

        lock.tryLock(); // 尝试获取锁
        
        try{
            // 业务代码
            if(number > 0){
                System.out.println(Thread.currentThread().getName()+"卖出了"+(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锁就不会等待，tryLock（）；

5、Synchronized 可重入锁，不可中断，非公平；Lock,可重入锁，可以判断锁，非公平锁（可以设置）；

6、Synchronized 适合锁少量的代码同步问题，Lock适合锁大量的同步代码！！

锁是什么？如何判断锁？

生产者和消费者问题

生产者和消费者问题 Synchronized 版

package com.hzx.pc;

/**
 * 线程之间的通信问题: 生产者和消费者问题！ 等待唤醒,通知唤醒
 * 线程交替执行 A B 操作同一个变量 num = 0
 * A num +1
 * B num -1
 */
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();
    }
}

问题存在，A B C D4个线程还安全吗？虚假唤醒

 用循环防止虚假唤醒

if改为while判断

package com.hzx.pc;

/**
 * 线程之间的通信问题: 生产者和消费者问题！ 等待唤醒,通知唤醒
 * 线程交替执行 A B 操作同一个变量 num = 0
 * A num +1
 * B num -1
 */
public class A {
    public static void main(String[] args) {
        Data data = new Data();

        new Thread(()->{
            for (int i = 0; i < 10; i++){
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++){
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++){
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++){
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}

// 等待 业务 通知
class Data{ // 资源类
    private int number = 0;

    // +1
    public synchronized void increment() throws InterruptedException {
        while(number != 0){
            // 等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        // 通知其他线程 +1完毕
        this.notifyAll();
    }
    // -1
    public synchronized void decrement() throws InterruptedException {
        while(number == 0){
            // 等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        // 通知其他线程 -1完毕
        this.notifyAll();
    }
}

生产者和消费者问题 JUC版

 通过Lock找到Condition

代码实现

package com.hzx.pc;

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 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 = new ReentrantLock();
    Condition condition = lock.newCondition();

    /**
     * condition.await(); // 等待
     * condition.signalAll(); // 唤醒全部
     */

    // +1
    public void increment(){
        lock.lock();
        try{
            while(number != 0){
                // 等待
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            // 通知其他线程 +1完毕
            condition.signalAll();
        }catch (InterruptedException 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 (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

Condition 精准的通知和唤醒线程

代码 有序

package com.hzx.pc;

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

/**
 * A执行完 调用B  B执行完 调用C  C执行完 调用A
 */
public class 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 conditionA = lock.newCondition();
    private Condition conditionB = lock.newCondition();
    private Condition conditionC = lock.newCondition();
    private int number = 1; // A:1 B:2 C:3
    public void printA(){
        lock.lock();
        try {
            // 业务 判断 执行 通知
            while(number != 1){
                // 等待
                conditionA.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>AAA");
            //唤醒 指定的人
            number = 2;
            conditionB.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void printB(){
        lock.lock();
        try{
            while(number != 2){
                conditionB.await();
            }
            System.out.println(Thread.currentThread().getName() + "=>BBB");
            number = 3;
            conditionC.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void printC(){
        lock.lock();
        try{
            while(number != 3){
                conditionC.await();
            }
            System.out.println(Thread.currentThread().getName() + "=>CCC");
            number = 1;
            conditionA.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    // 生产线: 下单->支付->交易->物流
}

8锁现象

如何判断锁的是谁！永远知道什么锁，锁到底锁的是谁！

对象（多个）、Class（唯一）

package com.hzx.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁 就是关于锁的8个问题
 * 1、 标准情况下 两个线程先打印发短信还是打电话？
 * 2、 sendSms延迟4秒 两个线程先打印发短信还是打电话？
 */
public class Test1 {
    public static void main(String[] args) {
        Phone phone = new Phone();

        // 锁的存在
        new Thread(()->{phone.sendSms();},"A").start();

        // 捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{phone.call();},"B").start();
    }


}

class Phone{

    // synchronized 锁的对象是方法的调用者!
    // 两个方法用的同一个锁 谁先拿到 谁执行

    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}
package com.hzx.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁 就是关于锁的8个问题
 * 3、 增加一个普通方法 两个线程先打印发短信还是hello？  普通方法
 * 4、 两个对象 两个同步方法打印发短信还是先打电话
 */
public class Test2 {
    public static void main(String[] args) {
        // 两个对象 两个调用者 两把锁
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();

        // 锁的存在
        new Thread(()->{phone1.sendSms();},"A").start();

        // 捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{phone2.call();},"B").start();
    }


}

class Phone2{

    // synchronized 锁的对象是方法的调用者!
    // 两个方法用的同一个锁 谁先拿到 谁执行

    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }

    // 这里没有锁 不是同步方法 不受锁的影响
    public void hello(){
        System.out.println("hello");
    }
}
package com.hzx.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁 就是关于锁的8个问题
 * 5、 增加两个静态的同步方法 只有一个对象 是先打印发短信 还是 打电话？
 * 6、 两个对象 两个静态同步方法 先打印发短信 还是 打电话
 */
public class Test3 {
    public static void main(String[] args) {
        // 两个对象 两个调用者 两把锁 两个对象的Class类模板只有一个, static锁的是Class
        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();


        // 锁的存在
        new Thread(()->{phone1.sendSms();},"A").start();

        // 捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{phone2.call();},"B").start();
    }


}

// Phone3只有唯一一个class对象
class Phone3{

    // synchronized 锁的对象是方法的调用者!
    // 两个方法用的同一个锁 谁先拿到 谁执行
    // static 静态方法 类一加载就有了 Class模板 锁的是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("打电话");
    }


}
package com.hzx.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁 就是关于锁的8个问题
 * 7、 一个静态同步方法 一个普通的同步方法 一个对象 先打印发短信还是打电话？
 * 8、一个静态同步方法 一个普通的同步方法 两个对象 先打印发短信还是打电话？
 */
public class Test4 {
    public static void main(String[] args) {
        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();

        // 锁的存在
        new Thread(()->{phone1.sendSms();},"A").start();

        // 捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{phone2.call();},"B").start();
    }


}

class Phone4{

    // synchronized 锁的对象是方法的调用者!
    // 两个方法用的同一个锁 谁先拿到 谁执行

    // 静态同步方法
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    // 普通同步方法
    public synchronized void call(){
        System.out.println("打电话");
    }
}

小结

new this 具体的一个对象

static Class 唯一的一个模板

集合类不安全

List不安全

package com.hzx.unsafe;

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

// java.util.ConcurrentModificationException 并发修改异常
public class ListTest {
    public static void main(String[] args) {
        // 并发下 ArrayList 不安全的
        /**
         * 解决方案:
         * 1、 Vector（默认安全） 解决
         * 2、 Collections.synchronizedList(new ArrayList<>());
         * 3、 new CopyOnWriteArrayList<>();
         */
        // CopyOnWrite 写入时复制 COW思想 计算机程序设计领域的一种优化策略;
        // 多个线程调用的时候,list,读取的时候,固定的,写入(覆盖)
        // 在写入的时候避免覆盖,造成数据问题

        // 读写分离 MyCat
        // CopyOnWriteArrayList 比 Vector 好在哪里？ Vector用的是Synchronized 效率低 CopyOnWriteArrayList 用的lock

        List<String> list = new CopyOnWriteArrayList<>();
//        List<String> list = new Vector<>();

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

Set不安全

package com.hzx.unsafe;

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

/**
 * 同理可证 java.util.ConcurrentModificationException 并发修改异常
 */
public class SetTest {
    public static void main(String[] args) {
        /**
         * 解决方案:
         * 1、 Collections.synchronizedSet(new HashSet<>());
         * 3、 new CopyOnWriteArraySet<>();
         */
        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);
            },""+i).start();
        }
    }
}

hashSet底层是什么？

    public HashSet() {
        map = new HashMap<>();
    }

// Set  add方法本质就是 map key是无法重复的
public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }


private static final Object PRESENT = new Object(); // PRESENT不变的值

HashMap不安全

package com.hzx.unsafe;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

// java.util.ConcurrentModificationException
public class MapTest {
    public static void main(String[] args) {
        // map是这样用的嘛？ 默认等价于什么？
        // 工作中不用HashMap
        // 默认等价 new HashMap<>(16,0.75);
//        Map<String, String> map = new HashMap<>();
//        Map<String, String> map = new ConcurrentHashMap<>();
        Map<String, String> map = Collections.synchronizedMap(new HashMap<>());
        /**
         * 解决方案:
         * 1、 new ConcurrentHashMap<>();
         * 2、 Collections.synchronizedMap(new HashMap<>());
         */
        for(int i = 1;i <= 30;i++){
            new Thread(()->{
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
                System.out.println(map);
            },""+i).start();
        }

    }
}

Callable

1、可以有返回值

2、可以抛出异常

3、方法不同，call()

代码测试

Thread不能直接执行Callable 需要通过别的方式

package com.hzx.callable;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // new Thread(new MyThread()).start(); 传统方式 没有返回值
        // new Thread(new Runnable()).start();
        // new Thread(new FutureTask<V>()).start();
        // new Thread(new FutureTask<V>(Callable)).start();
        // new Thread().start(); 怎么启动Callable

        MyThread myThread = new MyThread();
        // 适配类
        FutureTask futureTask = new FutureTask(myThread);

        new Thread(futureTask,"A").start();
        new Thread(futureTask,"B").start();// 结果会被缓存 效率高 


        Object o = futureTask.get(); // 获取 Callable的返回结果  这个get方法可能会产生阻塞
        // 把它放在最后或者使用异步通信
        System.out.println(o);
    }
}

class MyThread implements Callable<String> {

    @Override
    public String call() throws Exception {
        System.out.println("call()"); // 多个线程 会打印几次
        // 耗时操作
        return null;
    }
}
//class MyThread implements Runnable{
//
//    @Override
//    public void run() {
//
//    }
//}

注意点：

  1. 有缓存
  2. 结果可能需要等待，会阻塞

常用的辅助类

CountDownLatch

package com.hzx.add;

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(()->{
                countDownLatch.countDown(); // 数量-1
                System.out.println(Thread.currentThread().getName()+"Go Out");
            },""+i).start();
        }

        countDownLatch.await(); // 等待计数器归零 然后再向下执行

        System.out.println("Close Door");
    }
}

减法计数器

原理：

countDownLatch.countDown(); // 数量-1
countDownLatch.await(); // 等待计数器归零

每次有线程调用countDown()数量-1，假设计数器变为0，await()就会被唤醒继续执行。

CyclicBarrier

加法计数器

package com.hzx.add;

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

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        /**
         * 集齐七颗龙珠 召唤神龙
         */
        // 召唤龙珠的线程
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
            System.out.println("召唤神龙成功");
        });

        for (int i = 1;i <= 7;i++){
            final int temp = i;
            // lamda能操作到i嘛
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"收集"+temp+"个龙珠");
                try {
                    cyclicBarrier.await(); // 等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

Semaphore

Semaphore：信号量

例子：抢车位  6个车 3个停车位 轮流等待车位

package com.hzx.add;

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

public class SemaphoreDemo {
    public static void main(String[] args) {
        // 线程数量3 =》 停车位 3个
        Semaphore semaphore = new Semaphore(3);

        for (int i = 1;i <= 6;i++){
            new Thread(()->{
                // acquire() 得到
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"抢到车位");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName()+"离开车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release(); // release() 释放
                }
            },""+i).start();
        }
    }
}

原理：

semaphore.acquire(); 获得，假设已经满了 等待 等待被是释放为止
semaphore.release(); 释放 会将当前的信号量释放+1 然后唤醒等待的线程

作用：多个共享资源互斥的使用！并发限流，控制最大的线程数！

读写锁

ReadWriteLock

package com.hzx.rw;

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

/**
 * 独占锁(写锁) 一次只能被一个线程占有
 * 共享锁(读锁) 多个线程可以同时占有
 * ReadWriteLock
 * 读-读 可以共存
 * 读-写 不能共存
 * 写-写 不能共存
 */
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCacheLock myCache = new MyCacheLock();

        for(int i = 1; i <= 5;i++){
            final int temp = i;
            new Thread(()->{
                myCache.put(temp+"",""+temp);
            },i+"").start();
        }
        for(int i = 1; i <= 5;i++){
            final int temp = i;
            new Thread(()->{
                myCache.get(temp+"");
            },i+"").start();
        }
    }
}


/**
 * 自定义缓存  加锁的
 */
class MyCacheLock{
    private volatile Map<String,Object> map = new HashMap<>();
    // 读写锁: 更加细粒度的控制
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    // 存 写 入的时候 只希望同时只有一个线程写
    public void put(String key,Object value){
        readWriteLock.writeLock().lock();
        try{
            System.out.println(Thread.currentThread().getName()+"写入"+key);
            map.put(key,value);
            System.out.println(Thread.currentThread().getName()+"写入OK");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            readWriteLock.writeLock().unlock();
        }

    }

    // 取 读 所有人都可以读
    public void get(String key){
        readWriteLock.readLock().lock();
        try{
            System.out.println(Thread.currentThread().getName()+"读取"+key);
            Object o = map.get(key);
            System.out.println(Thread.currentThread().getName()+"读取OK");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            readWriteLock.readLock().unlock();
        }
    }
}

/**
 * 自定义缓存
 */
class MyCache{
    private volatile Map<String,Object> map = new HashMap<>();

    // 存 写
    public void put(String key,Object value){
        System.out.println(Thread.currentThread().getName()+"写入"+key);
        map.put(key,value);
        System.out.println(Thread.currentThread().getName()+"写入OK");
    }

    // 取 读
    public void get(String key){
        System.out.println(Thread.currentThread().getName()+"读取"+key);
        Object o = map.get(key);
        System.out.println(Thread.currentThread().getName()+"读取OK");
    }
}

阻塞队列

阻塞队列：

BlockingQueue 不是新的东西

  

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

学会使用队列

四组API

方式抛出异常有返回值，不会抛出异常阻塞等待超时等待
添加addofferputoffer(E e ,long time,TimeUint uint)
移除removepolltakepoll(long time,TimeUint uint)
检测队首元素elementpeek--
   /**
     * 抛出异常
     */
    public static void test1(){
        // 队列大小为3
        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(3);
        System.out.println(arrayBlockingQueue.add("a"));
        System.out.println(arrayBlockingQueue.add("b"));
        System.out.println(arrayBlockingQueue.add("c"));

        // IllegalStateException: Queue full 抛出异常 队列已满
//        System.out.println(arrayBlockingQueue.add("d"));
        System.out.println(arrayBlockingQueue.remove());
        System.out.println(arrayBlockingQueue.remove());
        System.out.println(arrayBlockingQueue.remove());

        // java.util.NoSuchElementException 抛出异常 没有元素
        System.out.println(arrayBlockingQueue.remove());
    }
    /**
     * 有返回值，不跑出异常
     */
    public static void test2(){
        // 队列大小为3
        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(3);
        System.out.println(arrayBlockingQueue.offer("a"));
        System.out.println(arrayBlockingQueue.offer("b"));
        System.out.println(arrayBlockingQueue.offer("c"));
        //System.out.println(arrayBlockingQueue.offer("d")); // 返回false 不抛出异常
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());
        //System.out.println(arrayBlockingQueue.poll()); // 返回null 不抛出异常
    }
    /**
     * 等待 阻塞（一直阻塞）
     */
    public static void test3() throws InterruptedException {
        // 队列大小为3
        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(3);
        arrayBlockingQueue.put("a");
        arrayBlockingQueue.put("b");
        arrayBlockingQueue.put("c");
        //arrayBlockingQueue.put("d"); // 一直等待

        System.out.println(arrayBlockingQueue.take());
        System.out.println(arrayBlockingQueue.take());
        System.out.println(arrayBlockingQueue.take());
        //System.out.println(arrayBlockingQueue.take()); // 一直等待
    }
    /**
     * 等待 阻塞（等待超时）
     */
    public static void test4() throws InterruptedException {
        // 队列大小为3
        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(3);

        arrayBlockingQueue.offer("a");
        arrayBlockingQueue.offer("b");
        arrayBlockingQueue.offer("c");
        //arrayBlockingQueue.offer("d",2, TimeUnit.SECONDS); // 等待超过两秒 退出

        arrayBlockingQueue.poll();
        arrayBlockingQueue.poll();
        arrayBlockingQueue.poll();
        arrayBlockingQueue.poll(2,TimeUnit.SECONDS);// 等待超过两秒 退出
    }

SynchronousQueue 同步队列

没有容量，进去一个元素，必须等待取出来之后，才能再往里面放一个元素。

package com.hzx.bq;

import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;

/**
 * 同步队列
 * 和其他的BlockingQueue 不一样 SynchronousQueue 不存储元素
 * put了一个元素 必须从里面先take取出来 否则不能再put进去值
 */
public class SynchronousQueueDemo {
    public static void main(String[] args) {
        SynchronousQueue<Object> synchronousQueue = new SynchronousQueue<>();// 同步队列

        new Thread(()->{
            try {
                System.out.println(Thread.currentThread().getName()+"put 1");
                synchronousQueue.put(1);
                System.out.println(Thread.currentThread().getName()+"put 2");
                synchronousQueue.put(2);
                System.out.println(Thread.currentThread().getName()+"put 2");
                synchronousQueue.put(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"T1").start();
        new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+synchronousQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+synchronousQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+synchronousQueue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"T2").start();
    }
}

线程池

线程池：三大方法、7大参数、4种拒绝策略

池化技术

程序的运行，本质：占用系统的资源！优化资源的使用！=》池化技术

线程池、连接池、内存池、对象池......

池化技术：事先准备好一些资源，有人要用，就来我这拿，用完之后还给我。

线程池的好处：

  1. 降低资源的消耗
  2. 提高响应的速度
  3. 方便管理

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

线程池：三大方法

package com.hzx.pool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

// Executors 工具类 3大方法
// 使用了线程池之后 用线程池创建线程
public class Demo01 {
    public static void main(String[] args) {
//        ExecutorService executorService = Executors.newSingleThreadExecutor();// 单个线程
//        ExecutorService executorService = Executors.newFixedThreadPool(5);// 创建一个固定的线程池的大小 5
//        ExecutorService executorService = Executors.newCachedThreadPool();// 可伸缩的 遇强则强 遇弱则弱

        try {
            for(int i = 0; i < 10; i++){
                executorService .execute(()->{
                    // 使用线程池创建线程
                    System.out.println(Thread.currentThread().getName());
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 线程池用完 程序结束 关闭线程池
            executorService.shutdown();
        }
    }
}

7大参数

源码分析

    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE, // 约等于21亿
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

本质：开启线程就是调用 ThreadPoolExecutor

    public ThreadPoolExecutor(int corePoolSize, // 核心线程池大小
                              int maximumPoolSize, // 最大的线程池大小
                              long keepAliveTime, // 超时了 没人调用就会释放
                              TimeUnit unit, // 超时单位
                              BlockingQueue<Runnable> workQueue, // 阻塞队列
                              ThreadFactory threadFactory, // 线程工厂 创建线程 一般不用动
                              RejectedExecutionHandler handler // 拒绝策略) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

 

手动创建一个线程池

package com.hzx.pool;

import java.util.concurrent.*;

// Executors 工具类 3大方法
// 使用了线程池之后 用线程池创建线程

/**
 * 拒绝策略
 * new ThreadPoolExecutor.AbortPolicy() // 银行满了 还有人进来 如果队列满了 还有人进来不处理这个人 抛出异常
 * new ThreadPoolExecutor.CallerRunsPolicy() // 哪来的去哪里 这里是main线程去执行
 * new ThreadPoolExecutor.DiscardPolicy() // 队列满了 丢掉任务 不会抛出异常
 * new ThreadPoolExecutor.DiscardOldestPolicy() // 队列满了 尝试去和最早的竞争 竞争失败就不执行 也不会抛出异常
 */
public class Demo01 {
    public static void main(String[] args) {
//        ExecutorService executorService = Executors.newSingleThreadExecutor();// 单个线程
//        ExecutorService executorService = Executors.newFixedThreadPool(5);// 创建一个固定的线程池的大小 5
//        ExecutorService executorService = Executors.newCachedThreadPool();// 可伸缩的 遇强则强 遇弱则弱
        ExecutorService threadPoolExecutor = new ThreadPoolExecutor(
                2,
                5,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardOldestPolicy() // 队列满了 尝试去和最早的竞争 竞争失败就不执行 也不会抛出异常
                );

        try {
            // 最大承载：Deque + max 5 + 3 = 8
            // 超过 抛出异常RejectedExecutionException
            for(int i = 0; i < 10; i++){
                threadPoolExecutor .execute(()->{
                    // 使用线程池创建线程
                    System.out.println(Thread.currentThread().getName()+"ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 线程池用完 程序结束 关闭线程池
            threadPoolExecutor.shutdown();
        }
    }
}

4种拒绝策略

/**
 * 拒绝策略
 * new ThreadPoolExecutor.AbortPolicy() // 银行满了 还有人进来 如果队列满了 还有人进来不处理这个人 抛出异常
 * new ThreadPoolExecutor.CallerRunsPolicy() // 哪来的去哪里 这里是main线程去执行
 * new ThreadPoolExecutor.DiscardPolicy() // 队列满了 丢掉任务 不会抛出异常
 * new ThreadPoolExecutor.DiscardOldestPolicy() // 队列满了 尝试去和最早的竞争 竞争失败就不执行 也不会抛出异常
 */

小结和拓展

池的最大的大小如何去设置

CPU的密集型，IO的密集型

// 最大线程到底该如何定义
// 1.CPU密集型 几核的 就定义为几 可以保证CPU的效率最高
// 2.IO密集型 判断程序中十分耗IO的线程数 大于这个数就行 最好两倍
System.out.println(Runtime.getRuntime().availableProcessors()); // 获取CPU的核数

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

新时代的程序员：lamda表达式、链式编程、函数式接口、Stream流式计算

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

@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

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

代码测试：

Funcation 函数式接口

/**
 * Function 函数型接口 有一个输入参数 有一个输出
 * 只要是 函数型接口 可以 用 lamda表达式简化
 */
public class Demo01 {
    public static void main(String[] args) {
//        Function function = new Function<String,String>() {
//            @Override
//            public String apply(String o) {
//                return o;
//            }
//        };
        Function<String,String> function = (str) -> {return  str;};
        System.out.println(function.apply("123"));
    }
}

断定型接口：有一个输入参数 返回值只能是 布尔值

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

Consumer消费型接口

/**
 * Consumer 消费型接口：只有输入 没有返回值
 */
public class Demo03 {
    public static void main(String[] args) {
//        Consumer consumer = new Consumer<String>() {
//            @Override
//            public void accept(String o) {
//                System.out.println(o);
//            }
//        };
        Consumer<String> consumer = (o) -> {System.out.println(o);};
        consumer.accept("amd");
    }
}

Supplier供给型接口

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

Stream流式计算

什么是Stream流式计算

大数据：存储 + 计算

存储：集合、MySQL本质是存储东西；

计算都应该交给流来操作

/**
 * 题目要求：一分钟内完成此题 只能用一行代码实现
 * 现在有5个用户 筛选：
 * 1. ID必须是偶数
 * 2. 年龄必须大于23岁
 * 3. 用户名转为大写字母
 * 4. 用户名字母倒着排序
 * 5. 只输出一个用户
 */
public class Test {
    public static void main(String[] args) {
        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(6, "e", 25);
        // 集合就是存储
        List<User> list = Arrays.asList(user1, user2, user3, user4, user5);

        // 计算交给Stream流
        // 链式编程 Stream流 函数式接口
        list.stream()
                .filter(u -> {return u.getId() % 2 == 0;})
                .filter(u -> {return u.getAge() > 23;})
                .map(u -> {return u.getName().toUpperCase();})
                .sorted((uu1,uu2) -> {return uu2.compareTo(uu1);})
                .limit(1)
                .forEach(System.out::println);
    }
}

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {

    private int id;
    private String name;
    private int age;
}

ForkJoin

什么是ForkJoin(分支合并)

ForkJoin在JDK1.7出现，并行执行任务！提高效率，大数据量！

大数据：Map Reduce 大任务拆分成小任务

ForkJoin特点：工作窃取

这里面维护的都是双端队列（两边都可以操作）

ForkJoin操作

package com.hzx.forkjoin;

import java.util.concurrent.RecursiveTask;

/**
 * 求和计算任务
 *
 * // 如何使用 forkjoin
 *    1. forkjoinpool 通过它来执行
 *    2. 新建计算任务 forkjoinpool.execute(ForkJoinTask<?> task)
 *    3. 计算类要继承ForkJoinTask
 *
 */
public class ForkJoinDemo extends RecursiveTask<Long> {

    private Long start;
    private Long end;
    // 临界值
    private Long temp = 10000L;

    public ForkJoinDemo(Long start, Long end) {
        this.start = start;
        this.end = end;
    }

    // 计算方法
    @Override
    protected Long compute() {
        if(end - start < temp){
            Long sum = 0L;
            for (Long i = start; i <= end; i++) {
                sum += i;
            }
            return sum;
        }else{
            // 分支合并计算forkjoin
            long middle = (start + end) / 2; // 中间值
            ForkJoinDemo task1 = new ForkJoinDemo(start, middle);
            task1.fork(); // 拆分任务 把任务压入线程队列
            ForkJoinDemo task2 = new ForkJoinDemo(middle + 1, end);
            task2.fork(); // 拆分任务 把任务压入线程队列
            return task1.join() + task2.join();
        }
    }
}


package com.hzx.forkjoin;

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

/**
 * 同一个任务 别人效率高你十几倍
 */
public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // test1(); // sum=500000000500000000时间6556
        // test2(); // sum=500000000500000000时间4414
        // test3(); // sum=500000000500000000时间152
    }

    public static void test1(){
        long start = System.currentTimeMillis();
        Long sum = 0L;
        for (Long i = 1L; i <= 10_0000_0000; i++) {
            sum += i;
        }
        long end = System.currentTimeMillis();
        System.out.println("sum=" + sum + "时间" + (end - start));
    }

    // 会使用ForkJoin
    public static void test2() throws ExecutionException, InterruptedException {
        long start = System.currentTimeMillis();
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Long> task = new ForkJoinDemo(0L, 10_0000_0000L);
        //forkJoinPool.execute(task); // 执行任务 没有返回结果
        ForkJoinTask<Long> submit = forkJoinPool.submit(task);// 提交任务 有返回结果
        Long sum = submit.get();
        long end = System.currentTimeMillis();
        System.out.println("sum=" + sum + "时间" + (end - start));
    }

    public static void test3(){
        long start = System.currentTimeMillis();
        // Stream并行流 rangeClosed():(}
        long sum = LongStream.rangeClosed(0L, 10_0000_0000L).parallel().reduce(0, Long::sum);
        long end = System.currentTimeMillis();
        System.out.println("sum=" + sum + "时间" + (end - start));
    }
}

异步回调

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

package com.hzx.future;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

/**
 * 异步调用： CompletableFuture
 * // 异步执行
 * // 成功回调 
 * // 失败回调
 */
public class Demo01 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 没有返回值的 runAsync 的异步回调
//        CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(
//                ()->{
//                    try {
//                        TimeUnit.SECONDS.sleep(2);
//                    } catch (InterruptedException e) {
//                        e.printStackTrace();
//                    }
//                    System.out.println(Thread.currentThread().getName() + "runAsync=>Void");
//                }
//        );
//        System.out.println("1111");
//
//        completableFuture.get(); // 获取阻塞执行结果

        // 有返回值的 supplyAsync 异步回调
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(
                () -> {
                    System.out.println(Thread.currentThread().getName() + "supplyAsync=>Integer");
                    int i = 10/0;
                    return 1024;
                }
        );

        System.out.println(completableFuture.whenComplete(
                (t, u) -> {
                    System.out.println("t=>" + t); // 正常的返回结果
                    System.out.println("u=>" + u); // 错误信息
                }
        ).exceptionally(
                (e) -> {
                    System.out.println(e.getMessage()); // 可以获取到错误的返回结果
                    return 233;
                }
        ).get());

    }
}

JMM

请你谈谈你对Volatile的理解

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

1、保证可见性

2、不保证原子性

3、禁止指令重排

什么是JMM

JMM：Java内存模型，不存在的东西，概念！约定！

关于JMM的一些同步的约定：

1、线程解锁前，必须把共享变量立刻刷回主存。

2、线程加锁前，必须读取主存中的最新值到工作内存中！

3、加锁和解锁是同一把锁

线程 工作内存、主内存

内存交互操作有8种，虚拟机实现必须保证每一个操作都是原子的，不可在分的（对于double和long类型的变量来说，load、store、read和write操作在某些平台上允许例外）

    • lock     （锁定）：作用于主内存的变量，把一个变量标识为线程独占状态
    • unlock （解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定
    • read    （读取）：作用于主内存变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用
    • load     （载入）：作用于工作内存的变量，它把read操作从主存中变量放入工作内存中
    • use      （使用）：作用于工作内存中的变量，它把工作内存中的变量传输给执行引擎，每当虚拟机遇到一个需要使用到变量的值，就会使用到这个指令
    • assign  （赋值）：作用于工作内存中的变量，它把一个从执行引擎中接受到的值放入工作内存的变量副本中
    • store    （存储）：作用于主内存中的变量，它把一个从工作内存中一个变量的值传送到主内存中，以便后续的write使用
    • write 　（写入）：作用于主内存中的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中

　　JMM对这八种指令的使用，制定了如下规则：

    • 不允许read和load、store和write操作之一单独出现。即使用了read必须load，使用了store必须write
    • 不允许线程丢弃他最近的assign操作，即工作变量的数据改变了之后，必须告知主存
    • 不允许一个线程将没有assign的数据从工作内存同步回主内存
    • 一个新的变量必须在主内存中诞生，不允许工作内存直接使用一个未被初始化的变量。就是怼变量实施use、store操作之前，必须经过assign和load操作
    • 一个变量同一时间只有一个线程能对其进行lock。多次lock后，必须执行相同次数的unlock才能解锁
    • 如果对一个变量进行lock操作，会清空所有工作内存中此变量的值，在执行引擎使用这个变量前，必须重新load或assign操作初始化变量的值
    • 如果一个变量没有被lock，就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量
    • 对一个变量进行unlock操作之前，必须把此变量同步回主内存

public class JMMDemo {
    private static int num = 0;
    public static void main(String[] args) { // mian线程
        new Thread(
                ()->{ // 线程1
                    while(num == 0){

                    }
                }
        ).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        num = 1;
        System.out.println(num);
    }
}

问题：程序不知道值已经被修改过了

Volatile

保证可见性

    // 不加volatile 程序就会死循环
    // 加 volatile 可保证可见性
    private volatile static int num = 0;
    public static void main(String[] args) { // mian线程
        new Thread(
                ()->{ // 线程1 对主内存的变化不知道
                    while(num == 0){

                    }
                }
        ).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        num = 1;
        System.out.println(num);
    }

不保证原子性

原子性：不可分割

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

// volatile不保证原子性
public class VDemo02 {
    // volatile不保证原子性
    private volatile static int num = 0;

    public static void add(){
        num++;
    }

    public static void main(String[] args) {
        // 理论num为2W
        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.out.println(Thread.currentThread().getName() + " " + num);
    }
}

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

使用原子类，解决原子性问题。

原子类为什么这么高级？ 底层CAS

// volatile不保证原子性
public class VDemo02 {
    // volatile不保证原子性
    private volatile static AtomicInteger num = new AtomicInteger();

    public static void add(){
        // num++; // 不是一个原子性操作
        num.getAndIncrement(); // AtomicInteger +1方法 CAS
    }

    public static void main(String[] args) {
        // 理论num为2W
        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.out.println(Thread.currentThread().getName() + " " + num);
    }
}

这些类的底层都直接和操作系统挂钩！在内存中修改值！Unsafe类是一个很特殊的存在。

指令重排

什么是指令重排：你写的程序，计算机并不是按照你写的那样去执行的。

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

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

int x = 1; // 1
int y = 2; // 2
x = x + 5; // 3
y = x * x; // 4
我们所期望的1234顺序执行
程序可能是 2134 1324 
不可能是 4123

可能造成影响的结果：a b x y这四个默认都是0；

线程A线程B

x = a

y = b
b = 1a = 2

正常的结果：x = 0;y = 0;但是可能由于指令重排

线程A线程B
b = 1a = 2
x = ay = b

指令重排导致的异常结果：x = 2; y = 1;

volatile关键词可以避免指令重排！

volatile实现避免指令重排：内存屏障（CPU指令 ）；

作用：

  1. 保证特定的操作的执行顺序
  2. 可以保证某些变量的内存可见性（利用这些特性volatile实现了可见性）

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

单例模式

饿汉式 DCL懒汉式

单例模式_开膛手joker的博客-CSDN博客

深入理解CAS

什么是CAS

// CAS
public class CASDemo {
    // CAS compareAndSet 比较并交换
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2020);
        // expect期望 update更新
        // public final boolean compareAndSet(int expect, int update)
        // 如果期望的值达到了 那么就更新 否则不更新 CAS是CPU的并发原语
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());

        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());
        atomicInteger.incrementAndGet()
    }
}

 Unsafe类

CAS：比较当前工作内存中的值和主内存中的值，如果这个值是期望的，那么则执行操作，如果不是就一直循环！

缺点：

  1. 循环会耗时
  2. 一次性只能保证一个共享变量的原子性
  3. 存在ABA问题

CAS：ABA问题（狸猫换太子）

// CAS
public class CASDemo {
    // CAS compareAndSet 比较并交换
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2020);
        // expect期望 update更新
        // public final boolean compareAndSet(int expect, int update)
        // 如果期望的值达到了 那么就更新 否则不更新 CAS是CPU的并发原语

        // ===捣乱的线程===
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());
        System.out.println(atomicInteger.compareAndSet(2021, 2020));
        System.out.println(atomicInteger.get());

        // ===期望的线程===
        System.out.println(atomicInteger.compareAndSet(2020, 666));
        System.out.println(atomicInteger.get());

        // 对于我们平时写的sql; 乐观锁
    }
}

原子引用

解决ABA问题，引入原子引用！对应的思想：乐观锁

带版本号的原子操作

public class CASDemo {
    // CAS compareAndSet 比较并交换
    public static void main(String[] args) {
//        AtomicInteger atomicInteger = new AtomicInteger(2020);

        // AtomicStampedReference 注意 如果泛型是一个包装类,注意对象的引用问题
        AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(1, 1);

        new Thread(
                ()-> {
                    int stamp = atomicStampedReference.getStamp(); // 获取版本号
                    System.out.println("a1=>"+atomicStampedReference.getStamp());

                    try {
                        TimeUnit.SECONDS.sleep(2);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(atomicStampedReference.compareAndSet(1, 2,
                            atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
                    System.out.println("a2=>"+atomicStampedReference.getStamp());

                    System.out.println(atomicStampedReference.compareAndSet(2, 1,
                            atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
                    System.out.println("a3=>"+atomicStampedReference.getStamp());
                },"a").start();
        // 乐观锁的原理相同
        new Thread(
                ()-> {
                    int stamp = atomicStampedReference.getStamp(); // 获取版本号
                    System.out.println("b1=>"+atomicStampedReference.getStamp());

                    try {
                        TimeUnit.SECONDS.sleep(2);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(atomicStampedReference.compareAndSet(1, 6,
                            atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
                    System.out.println("b2=>"+atomicStampedReference.getStamp());

                },"b").start();
    }
}

注意：

Integer使用了对象缓存机制，默认范围是-128~127，推荐使用静态工厂方法valueOf获取对象实例，而不是new，因为valueOf使用缓存，而new一定会创建新的对象分配新的内存空间。

各种锁的理解

公平锁、非公平锁

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

非公平锁：非常不公平，可以插队（默认非公平锁）

public ReentrantLock() {
     sync = new NonfairSync();
}

public ReentrantLock(boolean fair) {
     sync = fair ? new FairSync() : new NonfairSync();
}

可重入锁

可重入锁（递归锁）

 Synchronized版

package com.hzx.lock;

// 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.out.println(Thread.currentThread().getName() + "sms");
        call(); // 这里也有锁
    }

    public synchronized void call(){
        System.out.println(Thread.currentThread().getName() + "call");
    }
}

Lock版

package com.hzx.lock;

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

// lock 可重复锁
public class Demo02 {
    public static void main(String[] args) {
        phone phone = new phone();
        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();
        }
    }
}

自旋锁

自定义锁

package com.hzx.lock;

import java.util.concurrent.atomic.AtomicReference;

/**
 * 自旋锁
 */
public class SpinLockDemo {

    AtomicReference<Thread> atomicReference = new AtomicReference<>();
    // 加锁
    public void myLock(){
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName() + "==> mylock");
        // 自旋锁
        while (!atomicReference.compareAndSet(null, thread)) {

        }

    }

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

自定义锁的测试

package com.hzx.lock;

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

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(1);
                    }catch (Exception e){
                        e.printStackTrace();
                    }finally {
                        spinLockDemo.myUnLock();
                    }
                },"T2"
        ).start();


    }
}

死锁

死锁是什么

死锁测试，怎么排除死锁：

package com.hzx.lock;

import java.util.concurrent.TimeUnit;

public class DeadLockDemo {
    public static void main(String[] args) {
        String lockA = "lockA";
        String lockB = "lockB";
        new Thread(
                new MyThreed(lockA,lockB),"T1"
        ).start();
        new Thread(
                new MyThreed(lockB,lockA),"T2"
        ).start();
    }
}

class MyThreed implements Runnable{
    
    private String lockA;
    private String lockB;

    public MyThreed(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定位进程号  jps-l 命令

2、使用jstack查看进程信息  jstack 进程号 命令

排查问题：

1、日志

2、堆栈信息

小结

关注狂神说Java

开膛手joker
关注
基于《狂神说Java》JUC并发编程--学习笔记
wudidahuanggua的博客
06-15 866
本笔记仅做学习与复习使用，不存在刻意抄袭。给各位学友强烈推荐《遇见狂神说》他的整套Java学习路线使我获益匪浅！！!点击跳转至遇见狂神说哔哩哔哩首页如果你也是狂神的小迷弟，可以加我好友一起探讨学习。 ...
JUC并发编程学习笔记(硅谷)
07-23
"JUC并发编程学习笔记(硅谷)"很可能包含了关于Java并发工具集（Java Util Concurrency, JUC）的深入理解和实战经验。JUC是Java标准库提供的一套强大的并发处理工具，它极大地简化了多线程编程，提高了程序的可读性...
JUC底层的详细学习+狂神JUC笔记+全网最全
热门推荐
qq_41617848的博客
07-27 2万+
1、什么是JUC 源码+官方文档 JUC是 java util concurrent 面试高频问JUC~！ java.util 是Java的一个工具包~ 业务：普通的线程代码 Thread Runnable： 没有返回值、效率相比于Callable 相对较低！ 2、线程和进程 进程：一个程序，QQ.EXE Music.EXE；数据+代码+pcb 一个进程可以包含多个线程，至少包含一个线程！ Java默认有几个线程？2个线程！ main线程、GC线程 线程：开了一个进程Typora，写字，等待几分钟会进行
第46天学习打卡（四大函数式接口 Stream流式计算 ForkJoin 异步回调 JMM Volatile）
doudoutj的博客
02-23 177
小结与扩展 池的最大的大小如何去设置！ 了解:IO密集型，CPU密集型：（调优） //1.CPU密集型 几核就是几个线程 可以保持效率最高 //2.IO密集型判断你的程序中十分耗IO的线程，只要大于这个线程数就行 一般设置为这个耗IO线程数的两倍 package com.kuang.pool; import java.util.concurrent.*; // Executors工具类 三大方法 //使用了线程池之后，使用线程池来创建线程 public class Demo01 { .
面试官：如何终止线程？有几种方式？
Mr_wxc的博客
04-23 8428
在 Java 中有以下 3 种方法可以终止正在运行的线程： 使用退出标志，使线程正常退出，也就是当 run() 方法完成后线程终止； 使用 stop() 方法强行终止线程，但是不推荐使用这个方法，因为使用此方法不安全，目前该方法已被弃用； 使用 interrupt()方法中断线程。 第一种：使用标志位终止线程 使用标志位终止线程就是定义一个boolean型的标志位 ，在线程的run方法中根据这...
JUC并发编程——学习笔记
TGA麻辣香锅的博客
01-07 245
juc并发编程——狂神笔记 已完结
JUC并发编程笔记
weixin_43758633的博客
02-03 589
视频地址：【狂神说Java】JUC并发编程最新版通俗易懂 多线程进阶=>JUC并发编程 1、什么是JUC 源码 + 官方文档 面试高频问！ java.util 工具包 业务：无法通过普通的线程代码 Thread实现。 Runnable 没有返回值、效率相比于Callable相对较低！ 企业开发中Callable 使用较多 Callable ： 锁： 2、线程和进程 进程：是一个程序，QQ.exe Music.exe 程序的集合； 一个进程往往可以包含多个线程，至少包含一个。 Java默认有几
juc-study编程笔记.md
07-06
学习狂神说的juc编程的笔记
个人学习-JUC-笔记
02-25
本笔记主要围绕尚硅谷周阳老师的JUC课程展开，旨在帮助个人学习者深入理解和掌握Java并发编程的核心知识。 1. **并发基础** - **线程与进程**：线程是程序执行的最小单位，进程则是资源分配的基本单位。了解它们的...
JUC并发编程.md
01-28
### JUC并发编程知识点 #### 一、JUC并发编程简介 ...通过以上介绍，我们了解到JUC并发编程的核心概念和技术细节，这为后续深入学习并发控制、原子操作、线程安全容器等高级主题奠定了坚实的基础。
JUC并发编程（狂神说笔记）
qq_39831512的博客
06-02 314
JUC并发编程 什么是JUC java.util.concurrent、java.util.concurrent.atomic、java.util.concurrent.locks这三个包 前期回顾 什么是线程和进程？ 进程：运行中的程序 线程：一个进程包含多个线程，至少包含一个。java默认有两个线程（main线程、GC线程） JAVA并不能真的开启线程（JAVA无法直接操作硬件，是底层C++去做的） public synchronized void start() { /
并发编程juc笔记
学过的东西，讲不出来等于没学。
10-07 1006
方法二，使用 Runnable 配合 Thread 把【线程】和【任务】（要执行的代码）分开 方法三，FutureTask 配合 Thread FutureTask 能够接收 Callable 类型的参数，用来处理有返回结果的情况 3.3 查看进程线程的方法 windows 任务管理器可以查看进程和线程数，也可以用来杀死进程 tasklist 查看进程 taskkill 杀死进程 linux ps -fe 查看所有进程 ps -fT -p 查看某个进程（PID）的所有线程 kill 杀死进程 top
JAVA笔记 | JUC并发编程
qq_37630282的博客
02-09 527
JUC学习笔记
JUC并发编程学习笔记
qq_44781255的博客
05-07 145
开启的三种方式： Thread,Runnable,Callable java底层调用的本地方法（开启多线程） 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 add
【JUC】并发编程学习笔记（一）
lushixuan12345的博客
12-01 527
基础知识、Lock锁、线程间的通信、集合的线程安全
JUC并发编程学习笔记(一)
Huathy的博客
01-18 198
什么是JUC java.util.concurrent java.util.concurrent.locks 业务：普通的线程代码Thread Runnable：没有返回值，效率相较于Callable较低．
JUC并发编程学习笔记（简单易懂）
林夕
06-14 890
非公平锁:可以插队(无参构造方法默认为非公平锁)公平锁:先来后到(有参构造方法传值true时为公平锁)/** 真正的多线程开发,公司中的开发,降低耦合型* 线程就是一个单独的资源类,没有任何附属的操作!* 1. 属性 方法* *///并发:多线程操作同一个资源类,把资源丢入线程//@FunctionalInterface 函数式接口,jkd1.8 lambda 表达式(参数)->{代码}i < 30;i++) {
JUC并发编程学习笔记（狂神）
qq_40826814的博客
04-19 141
感谢原作者和狂神https://blog.csdn.net/weixin_44491927/article/details/108560692 JUC并发编程 1. 什么是JUC 2. 线程和进程 1）进程 2）线程 3）并发 4）并行 5）线程的状态 6）wait/sleep 3.Lock 1）传统的 synchronized 2）Lock 3. Synchronized 与Lock 的区别 4. 生..
狂神说java-juc并发编程
最新发布
09-23
狂神说java-juc并发编程是指狂神在讲解Java并发编程时提到了Java Util Concurrent（简称JUC）这个包。JUC是Java中用于处理并发编程的三个包之一，它包含了一系列的并发工具类和线程安全的集合类。其中，java.util....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值