JUC并发编程学习笔记

前言

看狂神JUC并发编程的学习笔记

一、简介

1、什么是JUC

Java 5.0 提供了java.util.concurrent（简称JUC）包，在此包中增加了在并发编程中很常用的使用工具类，用于定义类似于线程的自定义子系统，包括线程池、异步IO和轻量级任务框架。提供可调的、灵活的线程池。还提供了设计用于多线程上下文中的Collection实现等。

以下为JUC的三个包

二、线程和进程

线程和进程

进程：例如：一个程序，QQ.exe，Music.exe 程序的集合；
线程：例如：开了一个Typora进程，里面有写字、自动保存等线程
一个进程往往可以包含多个线程，至少包含一个！

Java默认有几个线程？ 2 个 mian、GC
开启线程的方式：Thread、Runnable、Callable

Java真的可以开启线程吗 不可以！只能通过本地方法调用底层的c++，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多核，多个线程可以同时执行；线程池

获取CPU的核数:

package com.radish.demo01;

/**
 * @author: Radish
 * @date: 2020-10-28 11:18
 */
public class Test1 {
    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 区别

1、来自不同的类

wait=>Object
sleep=>Thread

2、关于锁的释放

wait会释放锁，sleep睡觉了，抱着锁睡觉，不会释放

3、使用范围不同

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

X 4、是否需要捕获异常

wait 不需要捕获异常

sleep 必须要捕获异常

三、Lock锁（重点）

传统 Synchronized

package com.radish.demo01;

/**
 * @author: Radish
 * @date: 2020-10-28 11:41
 */
//基本的卖票例子

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

        //@FunctionalInterface 函数式接口，jdk1.8 lambda表达式（参数）->{代码}
        new Thread(() -> {
            for (int i = 0; i < 60; i++) {
                ticket.sale();
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 0; i < 60; i++) {
                ticket.sale();
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 0; i < 60; i++) {
                ticket.sale();
            }
        }, "C").start();

    }
}

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

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

Lock接口

公平锁：十分公平，先来后到

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

package com.radish.demo01;

/**
 * @author: Radish
 * @date: 2020-10-28 11:41
 */
//基本的卖票例子

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

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

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

    }
}

// Lock三部曲：
// 1、new ReentrantLock();
// 2、lock.lock();   //加锁
// 3、finally=> lock.unlock(); //解锁
class Ticket2{
    // 属性、方法
    private int number = 50;

    Lock lock = new ReentrantLock();

    //卖票的方式
    //synchronized 本质：队列，锁
    public void sale(){

        lock.lock();    // 加锁

        try {
            //业务代码

            if(number > 0){
                System.out.println(Thread.currentThread().getName()+"卖出了"+(number--)+"票，剩余"+number);
            }
        }catch (Exception e){

        }finally {
            lock.unlock();  // 解锁
        }

    }

    //对象
    //class
}

Synchronized和Lock区别

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

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

四、生产者和消费者问题

生产者和消费者问题 Synchronized版

package com.radish.pc;

/**
 * @author: Radish
 * @date: 2020-10-28 13:09
 * 线程之间的通信问题：生产者和消费者问题  等待唤醒，通知唤醒
 * 线程交替执行   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 = 5;

    //+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,D 4个线程！虚假唤醒

if 改为 while

生产者和消费者问题 JUC版

通过Lock 找到 Condition

代码实现

package com.radish.pc;

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

/**
 * @author: Radish
 * @date: 2020-10-28 13:42
 */
public class B {
    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 number = 0;

    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

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

    //+1
    public void increment() throws InterruptedException {

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

    }

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

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

Condition 精准通知和唤醒线程

代码测试：

package com.radish.pc;

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

/**
 * @author: Radish
 * @date: 2020-10-28 14:00
 * 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{    //资源类 lock

    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
    private int number = 1;

    public void printA(){
        lock.lock();
        try {
            //业务代码 判断-> 执行-> 通知
            while (number != 1){
                //等待
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>AAAAA");
            // 唤醒指定的人：B
            number = 2;
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    };
    public void printB(){
        lock.lock();
        try {
            //业务代码 判断-> 执行-> 通知
            while (number != 2){
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>BBBBB");
            number = 3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    };
    public void printC(){lock.lock();
        try {
            //业务代码 判断-> 执行-> 通知
            while (number != 3){
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>CCCCC");
            number = 1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    };
}

五、8锁现象

如何判断锁的是谁！永远的知道什么锁，锁到底锁的是谁！
深刻理解我们的锁

package com.radish.lock8;

import java.util.concurrent.TimeUnit;

/**
 * @author: Radish
 * @date: 2020-10-30 9:08
 * 8锁，就是关于锁的8个问题
 * 1、标准情况下，两个线程先打印  发短信还是打电话？ 1/发短信 2/打电话
 * 2、sendSms延迟4秒，两个线程先打印  发短信还是打电话？ 1/发短信 2/打电话
 */
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.radish.lock8;

import java.util.concurrent.TimeUnit;

/**
 * @author: Radish
 * @date: 2020-10-30 9:08
 * 3、增加了一个hello普通方法，先执行发短信还是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.radish.lock8;

import java.util.concurrent.TimeUnit;

/**
 * @author: Radish
 * @date: 2020-10-30 9:08
 * 5、增加两个静态的同步方法,只有一个对象  发短信还是打电话先？ 发短信
 * 6、两个对象！ 增加两个静态的同步方法,只有一个对象  发短信还是打电话先？ 发短信
 */
public class Test3 {
    public static void main(String[] args) {

        //两个对象
        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
    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.radish.lock8;

import java.util.concurrent.TimeUnit;

/**
 * @author: Radish
 * @date: 2020-10-30 9:08
 * 7、1个静态同步方法，1个普通同步方法，一个对象。 先打印发短信还是打电话  打电话！
 * 8、1个静态同步方法，1个普通同步方法，两个对象。 先打印发短信还是打电话  打电话！
 */
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();
    }
}

//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("打电话");
    }
}

小结

new this 具体的一个手机
static Class 唯一的一个模板

六、集合类不安全

List不安全

package com.radish.unsafe;

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

/**
 * @author: Radish
 * @date: 2020-10-30 9:43
 */
//java.util.ConcurrentModificationException 并发修改异常！
public class ListTest {
    public static void main(String[] args) {
        // 并发下ArrayList不安全
        /**
         * 解决方案：
         * 1、List