JUC基础笔记（尚硅谷周阳JUC的笔记）

概述

• juc就是 java.util.concurrent包的首字母
• 下面又分 并发包、 atomic 和 locks 包
• 也就是所谓的并发工具类
• 进程： 是程序的一次执行，拥有独立资源的单位
• 线程：轻量级进程，共享进程中的内存资源 ，程序调度和分配的基本单位， 更好的使程序并发的执行
• 并发： 是在程序在宏观上是并行， 实则是交替的执行
• 并行： 两个程序一起执行，同步执行。
• 在高内聚低耦合的前端下： 多线程编程的企业级套路 + 模板：
  * 线程 操作（对外暴露的调用方法） 资源类
  * 多线程操作共享资源
  * 先写共享资源类
  * 在写对共享资源的操作
  * 实现Runnable接口的匿名实现
  
  

卖票

//过去javase的写法
class Ticket{//资源类
    //票
    private int number = 30;

    public synchronized void saleTicket(){
        if (number > 0){
            System.out.println(Thread.currentThread().getName()+"\t卖出第："+(number--)+"\t还剩下："+number);
        }
    }
}
/**
 *题目：三个售票员   卖出   30张票
 * 多线程编程的企业级套路+模板
 * 1.在高内聚低耦合的前提下，线程    操作(对外暴露的调用方法)     资源类
 */
public class SaleTicket {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 40; i++) {
                    ticket.saleTicket();
                }
            }
        },"A").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 40; i++) {
                    ticket.saleTicket();
                }
            }
        },"B").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 40; i++) {
                    ticket.saleTicket();
                }
            }
        },"C").start();
    }
}

//利用lock写法 lock相较于synchronized较为灵活， 而且锁的范围更少， 有点类似于操作系统的信号量
public class CurrentTicket {
    public static void main(String[] args) {

        Ticket ticket = new Ticket();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <= 40; i ++)
                  ticket.saleTicket();
            }
        }, "a").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <= 40; i ++)
                  ticket.saleTicket();
            }
        }, "b").start();

        //写成lamb表达式
        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();
    }
}
class Ticket{
    private int count = 50;
    private Lock lock = new ReentrantLock();
    public void saleTicket(){
        lock.lock();

        try {
            if (count > 0){
                System.out.println(Thread.currentThread().getName() + count);
                count --;
            }
        } finally {
            lock.unlock();
        }

    }
}

Lambda表达式

• 对于一个接口来说如果只一个没有实现的方法可以直接用lambda表达式替换 （为什么说没有实现， 因为jdk8 接口中可以写默认实现， 以及静态方法）
• 对于声明式函数接口 的注解@FunctionalInterface
• 原则 拷贝中括号， 写死右箭头， 落地大括号

//什么意思呢
interface Foo{
      int div ();
}
//我们就可以这么做
Foo f = () -> {写实现;  return 值;};
f.div();即可
// 对于有返回值有参数的
 interface Foo{
      int div (int a, int b);
}
Foo f = (a, b) -> {写实现； return 值};
f.div(1, 2);就可以

线程间的通信

• 一个进程内， 线程间的协调和调度， 操作共享资源。
• 不同进程间的通信得利用操作系统中讲的进程通信。

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

/**
 * @author xiaofei
 * @create 2021-07-28 9:53
 */


/*
 * 题目： 现在两个线程， 可以操作初始值位零的一个变量，
 * 实现一个进程对变量加一， 一个线程对改变量减一
 * 实现交替， 来10轮， 变量初始值为零
 *
 *
 * 1、高内聚低耦合， 线程操作资源类
 * 2、判断/干活/通知
 * 3、多线程交互中， 必须要防止多线程的续集唤醒， 也即 （判断使用while不
 * 能用if）
 * 4、标志位
 * 唤醒的时候还必须在判断
 * */

class AirConditioner {
    private int num = 0;
    private Lock lock = new ReentrantLock();

    public synchronized void add() throws InterruptedException {
          //这种情况会出错的原因是线程被唤醒的时侯就不需要在拍段一次条件了故在面对超过两个线程的时候就出现错误
//        if (num != 0) this.wait();
//        num ++;
//        System.out.println(Thread.currentThread().getName() + " " + num);
//
//        this.notifyAll();
        //第一种解决办法
        while (num != 0) this.wait();
        num ++;
        System.out.println(Thread.currentThread().getName() + " " + num);

        this.notifyAll();

        //第二种解决办法 说到底都是 让其唤醒的时候在经历一次判断 另外这样写可能打出来的结果可能不是40行
        // 因为被唤醒之后就不是去去执行本次的操作而是直接本次操作结束 执行 i++ 了
//        if (num == 0) {
//            num ++;
//            System.out.println(Thread.currentThread().getName() + " " + num);
//            this.notifyAll();
//        }else
//            this.wait();


    }

    public synchronized void sub() throws InterruptedException {

        while (num == 0) this.wait();
        num --;
        System.out.println(Thread.currentThread().getName() + " " + num);
        this.notifyAll();

//        if (num == 1) {
//            num --;
//            System.out.println(Thread.currentThread().getName() + " " + num);
//            this.notifyAll();
//        }else
//            this.wait();
    }
}

public class ThreadWaitNotifyDemo {

    public static void main(String[] args) throws Exception{


        AirConditioner airConditioner = new AirConditioner();
        new Thread(() -> {
            try {
//                for (int i = 0; i < 10; i ++) airConditioner.sub();
                while (true) airConditioner.sub();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "B").start();
        new Thread(() -> {
            try {
//                for (int i = 0; i < 10; i ++) airConditioner.add();
                while (true) airConditioner.sub();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "A").start();

        new Thread(() -> {
            try {
//                for (int i = 0; i < 10; i ++) airConditioner.add();
                while (true) airConditioner.add();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "c").start();



        new Thread(() -> {
            try {
//                for (int i = 0; i < 10; i ++) airConditioner.sub();
                while (true) airConditioner.add();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "d").start();

    }
}

• 新版的生产者消费者

class AirConditioner {
    private int num = 0;
    private Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    public  void add() throws InterruptedException {
        lock.lock();
        try {
            while (num != 0) condition.await();
            num ++;
            System.out.println(Thread.currentThread().getName() + " " + num);
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

    public void sub() throws InterruptedException {

        lock.lock();
        try {
            while (num == 0) condition.await();
            num --;
            System.out.println(Thread.currentThread().getName() + " " + num);
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

一道经典的线程按顺序打印

/*
* 多线程之间按顺序调用， 实现A -> B -> C
* 三个线程启动， 要求如下：
* A 打印5次 B 打印10次， CC打印15次
* 接着
* AA打印5次， BB打印10次， CC打印15次
* 来10轮
*  下订单 -> 减库存 -> 调支付
*
* synchronized 它最大的缺点就是不能精确唤醒某个线程
* lock  它灵活可以多个锁精确唤醒
* 可以让某个锁放开当前线程
* 非常像操作系统的信号量的传参， 当前参数被那个锁给await了那么就只能用这把锁把他唤醒，
* 跟线程同步有关操作系统
* */

class Print{

    private int num = 1;  // 1：A 2：B 3 C
    private Lock lock = new ReentrantLock();
    Condition A = lock.newCondition();    //用来锁A的
    Condition B = lock.newCondition();    // 用来锁B的
    Condition C = lock.newCondition();    //用来锁C的

    public void print(int sign){
        if (sign == 1){
            lock.lock();
            try {
                while (num != 1){
                    A.await();
                }
                for (int i = 0; i < 5; i ++){
                    System.out.println(Thread.currentThread().getName() + " " + i);
                }
                num ++;
                B.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }else if (sign == 2){
            lock.lock();
            try {
                while (num != 2){
                    B.await();
                }
                for (int i = 0; i < 10; i ++){
                    System.out.println(Thread.currentThread().getName() + " " + i);
                }
                num ++;
                C.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }else {
            lock.lock();
            try {
                while (num != 3){
                    C.await();
                }
                for (int i = 0; i < 15; i ++){
                    System.out.println(Thread.currentThread().getName() + " " + i);
                }
                num = (num + 1) % 3;
                A.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
}
public class ThreadOrderAccess {

    public static void main(String[] args) {
        Print print = new Print();
        new Thread(
                () -> {
                    for (int i = 0; i < 10; i ++) print.print(1);
                }, "A"
        ).start();
        new Thread(
                () -> {
                    for (int i = 0; i < 10; i ++) print.print(2);
                }, "B"
        ).start();new Thread(
                () -> {
                    for (int i = 0; i < 10; i ++) print.print(3);
                }, "C"
        ).start();

    }
}

多线程8锁

  /*
*
* 题目：多线程8锁
* 1、两个普通的同步方法 先打印邮件还是sms ：邮件
* 2、邮件方法暂停3秒钟， 请问先打印那个： 邮件
* 3、邮件方法暂停3秒钟 新增一个普通方法hello()和发邮件, 先打印邮件还是hello : hello
* 4、两部手机一个发邮件一个发短信   发短信
* 5、两个静态同步方法、同一部手机先打印那个 邮件
* 6、两个静态同步方法  两部手机 ： 邮件
* 7、一个静态同步方法， 一个普通同步方法  同一部手机 ： SMS
* 8、一个静态同步方法， 一个普通同步方法  2部手机 ： SMS
*
* 想两个拿同一个手机 一个想打电话一个想发消息， 同一时间是不是只能有一个人拿到这部手机
* 笔记：
*   一个对象里面如果有多个synchronized. 某个时刻内， 只要有一个线程去调用其中的一个synchronized方法
*   其他线程都只能等待， 换句话说， 某个时刻内， 只能有一个对象去访问同一个资源类中的synchronized方法
*   锁的是当前对象this, 被锁定后， 其他线程都不能进入到当前对象的其他的synchronized方法
*   加个普通方法后和同步锁无关
*   换成两个对象之后， 不是同一把锁了， 故无关
*   都换成静态同步方法的时候 对于静态方法的锁是 本类.class
*
*   静态同步方法于非静态同步方法之间是不会有竞态条件的
*   但是一旦一个静态同步方法获取锁后， 其他的静态方法都必须等待该方法释放锁后才能获取锁
*   总之 对于锁相同的时候同时只能有一个线程访问
*
* */

class Phone{
    public static synchronized void sendEmail() throws InterruptedException {
        Thread.sleep(3000);
        System.out.println("sendEmail");
    }
    public  synchronized void sendSmS(){
        System.out.println("sendSMS");
    }

    public void hello(){
        System.out.println("hello");
    }

}
public class Lock8 {

    public static void main(String[] args) {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();
        new Thread(() -> {
            try {
                phone1.sendEmail();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "A").start();

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

        new Thread(() -> {
            phone1.hello();
        }, "C").start();
    }
}

集合线程不安全

/*
* 笔记：
*   写时复制
*   CopyOnWrite 容器即写时复制的容器， 往一个容器添加元素的时候， 不直接往当前容器的object[]添加元素， 而是先将当前容器Object[]
*   进行复制出一个新的容器object[] newElements， 让后新的容器object[] newElements里添加元素， 添加元素之后，
*   在将原容器的引用指向心的容器 setArray(newElements) 这样做的好处时可以对CopyOnWrite容器进行并发的读，
*   而不需要加锁， 因为当前容器不会添加任何元素， 所以CopyOnWrite容器也是一种读写分离的思想， 读和写不同的容器
*    public boolean add(E e) {
*        final ReentrantLock lock = this.lock;
*       lock.lock();
*        try {
*            Object[] elements = getArray();
*            int len = elements.length;
*            Object[] newElements = Arrays.copyOf(elements, len + 1);
*            newElements[len] = e;
*            setArray(newElements);
*            return true;
*        } finally {
*            lock.unlock();
*        }
*    }
*    HashSet底层就是hashmap add方法add一个值就是hashmap的key, value是写死的Object
*    hashMap 底层是一个Node类型的数组加链表+红黑树， 他是使用的拉链发实现的hash表， 数组长度起始为16 负载因子0.75
*    链表超过8就是变成红黑树。
*
* 题目： 请举例说明集合类是不安全的
* ArrayList hashSet hashmap 是线程不安全的
* vector 是线程安全的  only-one 不在乎性能只在乎 线程安全不安全
* 1、故障现象
* 会出现java.utils.concurrentModificationException
*
* 2、导致原因
*    并发修改异常
* 3、解决方案
*   1、 vector
*   2、 Collections.synchronizedList
*   3、 CopyOnWriteArrayList  多线程用这个
*       写的时候复制一份， 让读跟写分离
*     Object[] newElements = Arrays.copyOf(elements, len + 1);
*     newElements[len] = e;
*     setArray(newElements);
*   4、CurrentHashMap -> hashMap
*   5、LinkedList -> ConcurrentLinkedQueue
*   6、hashSet 他的底层就是HashMap所以
*
* 4、优化建议 （同样的错误， 不出现第二次）
*
* */
public class NotSafeDemo {

    public static void main(String[] args) {

        setNoteSafe();

    }

    public static void MapNotSafe(){
//        Map map = new HashMap<>();
        Map<String, String> map = new ConcurrentHashMap<>();

    }

    public static void setNoteSafe (){
//        Set set = new HashSet<>();
        Set<String> set = new CopyOnWriteArraySet<>();
        for (int i = 1; i <= 30; i++) {
            new Thread(() ->
            {
                set.add(UUID.randomUUID().toString().substring(0, 8));
                System.out.println(set);
            }, String.valueOf(i)).start();
        }

    }

    public static void listNotSafe (){
//          List list = new ArrayList();
//        List