JUC并发编程进阶

置顶

情、狠现实

已于 2022-03-06 14:33:28 修改

阅读量883

点赞数 2

分类专栏： Java学习文章标签： b树数据库数据结构

于 2022-03-06 11:45:54 首次发布

本文链接：https://blog.csdn.net/ctrl_kun/article/details/123307582

版权

本文深入探讨JUC并发编程，涵盖线程、进程、Lock、并发控制、线程池、函数式接口、流式计算等关键概念。讲解了Lock与synchronized的区别，强调了并发编程中锁的状态判断和精准通知。还介绍了线程池的原理和使用，以及四大函数式接口的应用。最后讨论了JMM、Volatile特性以及并发编程中的常见问题，如ABA问题和死锁。

摘要由CSDN通过智能技术生成

JUC并发编程进阶

jdk环境

保证项目JDK至少有1.8 Project和Moudle都要设置好

在这里插入图片描述

什么是JUC？

源码+官方文档 面试高频

在这里插入图片描述

java.util工具包

业务：普通的线程代码 Thread

Runnable 没有返回值，效率相比Callable低！

线程和进程

线程，进程，如果不能用一句话说出来的技术说明不扎实！

进程：一个进程，QQ.exe Music.exe 程序的集合，运行中的程序

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

java默认有几个线程呢？2个 main+GC

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

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 static void main(String[] args) {
   
    // 获取CPU的核数
    // CPU密集型，IO密集型
    System.out.println(Runtime.getRuntime().availableProcessors());
}

并发编程的本质：充分利用CPU资源

线程有几个状态？

public enum State {
   
        // 新生
        NEW,

        // 运行
        RUNNABLE,

        // 阻塞
        BLOCKED,

        //等待（一直等）
        WAITING,

        // 超时等待（等待一定时间，没有等到直接结束）
        TIMED_WAITING,

        //终止
        TERMINATED;
    }

wait/sleep 区别

来自不同的类
wait => Object
sleep => Thread
关于锁的释放
wait 会释放锁，sleep不会释放锁
使用的范围不同
wait 必须在同步代码块中
sleep 可以在任何地方执行
sleep不需要被唤醒（休眠之后推出阻塞），但是wait需要（不指定时间需要被别人中断）。

Lock锁（重点）

传统的synchronized


/**
 * 真正的多线程开发（降低耦合性）
 * 线程就是一个单独的资源类 没有任何附属的操作
 * 1. 属性 方法
 */
public class SaleTicketDemo01 {
   
    public static void main(String[] args) {
   

        // 并发：多线程操作同一个资源类，把资源丢进线程
        Ticket ticket = new Ticket();

        // @FunctionalInterface 函数式接口 jdk1.8 兰八大表达式 ( 参数 )->{ 代码 }
        for (String s : Arrays.asList("A", "B", "C")) {
   
            new Thread(()->{
   
                for (int i = 0; i < 60; i++) {
   
                    ticket.sale();
                }
            }, s).start();
        }
    }
}

/**
 * 资源类
 */
class Ticket{
   
    // 属性 方法
    private int number = 50;

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

}

Lock 接口

Lock lock = …;

lock.lock();//加锁

lock.unlock();//解锁

可重入锁(常用)

实现类：ReentrantLock,ReentrantReadWriteLock.ReadLock(读锁),ReentrantReadWriteLock.WriteLock(写锁)


/**
 * 真正的多线程开发（降低耦合性）
 * 线程就是一个单独的资源类 没有任何附属的操作
 * 1. 属性 方法
 */
public class SaleTicketDemo02 {
   
    public static void main(String[] args) {
   

        // 并发：多线程操作同一个资源类，把资源丢进线程
        Ticket2 ticket = new Ticket2();

        // @FunctionalInterface 函数式接口 jdk1.8 兰八大表达式 ( 参数 )->{ 代码 }
        for (String s : Arrays.asList("A", "B", "C")) {
   
            new Thread(()->{
   
                for (int i = 0; i < 60; i++) {
   
                    ticket.sale();
                }
            }, s).start();
        }
    }
}

/**
 * 资源类
 *
 * Lock 三部曲
 * 1. new ReentrantLock();
 * 2. lock.lock(); // 加锁
 * 3. lock.unlock(); // 解锁
 */
class Ticket2{
   
    // 属性 方法
    private int number = 30;

    Lock lock = new ReentrantLock();

    // 买票的方式
    public void sale(){
   
        lock.lock(); // 加锁

        try {
   
            // 业务代码
            if (number > 0) {
   
                System.out.println(Thread.currentThread().getName() + "卖出了" + (number--) + "票，剩余：" + number);
            }
        } catch (Exception e) {
   
            e.printStackTrace();
        } finally {
   
            lock.unlock(); // 解锁
        }


    }

}

Synchronized 和 Lock 区别

Sycnchronized 内置的java关键字，Lock 是一个java类
Synchronized 无法判断取锁的状态，而 Lock 可以判断是否获取到了锁
Synchronized 会自动释放锁， Lock 锁必须要手动释放锁！如果不释放锁，死锁！
Synchronized 线程1 （获得锁，阻塞）、线程2（一直等）；Lock 不会一直等待，会尝试获取锁
Synchronized 可重入锁，不可以中断的，非公平；Lock ，可重入锁，可以判断锁，非公平（可以自己设置）
Synchronized 适合锁少量的代码同步问题，Lock 适合锁大量的同步代码！

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

生产者和消费者问题

面试：单例模式、排序算法、生产者消费者、死锁

生产者和消费者问题 Synchronized 版


/**
 * 线程之间的通信问题 ： 生产者和消费者问题
 * 线程交替执行 A B 操作同一个遍历 num = 0
 * A num + 1
 * B num - 1
 */
public class A {
   
    public static void main(String[] args) {
   
        final 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);
        //通知其他线程 我加一完毕了;
        this.notifyAll();
    }

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

}

问题如果同时存在多个线程虚假唤醒

在这里插入图片描述

JUC 版，生产者与消费者问题

在这里插入图片描述

必须把if改成while！！！

在这里插入图片描述

代码实现：


/**
 * 线程之间的通信问题 ： 生产者和消费者问题
 * 线程交替执行 A B 操作同一个遍历 num = 0
 * A num + 1
 * B num - 1
 */
public class B {
   
    public static void main(String[] args) {
   
        final 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);
            //通知其他线程 我加一完毕了;
            condition.signalAll();
        } catch (Exception e) {
   
            e.printStackTrace();
        } finally {
   
            lock.unlock();
        }
    }

    //-1
    public void decrement() {
   
        lock.lock();

        try {
   
            while (number==0){
   
                //等待
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            //通知其他线程，我减一完毕了
            condition.signalAll();
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        } finally {
   
            lock.unlock();
        }
    }


}

任何一个新的技术，绝对不是仅仅只是覆盖了原来的技术，优势和补充！

Condition 精准通知和唤醒线程

代码测试：

package kuang.juc.pc;

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

/**
* Condition 精准通知和唤醒线程
 */
public class C {
   
    public static void main(String[] args) {
   
        final Data3 data = new Data3();

        new Thread(()->{
   
            for (int i = 0; i < 10; i++) {
   
                data.printA();
            }
        }, "A").start();

        new Thread(()-> {
   
            for (int i = 0; i < 10; i++) {
   
                data.printB();
            }
        }, "B").start();

        new Thread(()->{
   
            for (int i = 0; i < 10; i++) {
   
                data.printC();
            }
        }, "C").start();

    }
}

/**
 * 资源类
 */
class Data3{
   

    Lock lock = new ReentrantLock();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();

    private int number = 1;//A 1 B 2 C 3

    public void printA(){
   
        lock.lock();
        try {
   
            // 业务 判断->执行->通知
            while (number != 1) {
   
                //等待
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName() + "=> A");
            // 唤醒 B
            number = 2;
            condition2.signal();
        } catch (Exception e) {
   
            e.printStackTrace();
        } finally {