Java并发编程--基础进阶高级（完结）

 

Java并发编程--基础进阶高级完整笔记。

这都不知道是第几次刷狂神的JUC并发编程了，从第一次的迷茫到现在比较清晰，算是个大进步了，之前JUC笔记不见了，重新做一套笔记。

目录

• :fire:1.多线程--基础内容
• :fire:2.八锁现象(synchronized、static)
  • 2.static synchronized
• :fire:3.Java集合--安全性
• :fire:4.高并发--辅助类
• :fire:5.读写锁(ReadWriteLock)
• • 1.集合--队列（阻塞队列、同步队列）
  • 2.线程池基本概念(三大方法、七大参数、四种拒绝策略)
• :fire:7.Stream(4个函数式接口、Lambda、异步回调)
• • 1.饿汉模式(程序一启动就new，十分占内存)
  • 2.懒汉模式(DCL模式：双重检测，需要的时候才new)
• :fire:9.Volatile和Atomic
• • 1.公平锁（FIFO）：Lock锁可以自定义，synchronized
  • 2.非公平锁(允许插队):Lock锁可以自定义
  • 3.可重入锁（获取一个锁再获取其他锁不会造成死锁）:lock锁和synchronized
  • 4.自旋锁:得不到就一直等待(Atomic.getAndIncrement底层就是自旋锁)

:fire:1.多线程--基础内容

1.Thread状态

​ 6种：新建、运行、阻塞、等待、超时等待、结束（可点击Thread查看源代码）

public enum State {
        NEW,

        RUNNABLE,

        BLOCKED,

        WAITING,

        TIMED_WAITING,

        TERMINATED;
    }

2.Synchronized

• 非公平锁
• 可重入锁，

​ Synchronized：是非公平锁(不能保证线程获得锁的顺序，即线程不会依次排队去获取资源，而是争抢,但是结果一定是正确的)，是可重入锁(已获得一个锁，可以再获得锁且不会造成死锁，比如synchronized内部可以再写个synchronized函数)

/**
     * Author: HuYuQiao
     * Description: Synchronized实现方式(修饰函数即可)
     */
    class TicketSync{
        public int number = 50;
        //synchronized本质是队列，锁
        public synchronized void sale(){
            if(number > 0) {
                System.out.println(Thread.currentThread().getName() + "获得了第" + number-- +"票");
            }
        }
    }

3.Lock锁

• 可重入锁

• 公平还是不公平锁可以设置(默认不公平锁)

  /**
       * Creates an instance of {@code ReentrantLock} with the
       * given fairness policy.
       *
       * @param fair {@code true} if this lock should use a fair ordering policy
       */
      public ReentrantLock(boolean fair) {
          sync = fair ? new FairSync() : new NonfairSync();
      }

  Lock：加锁之后必须解锁，，否则其他线程就获取不到了，所以用 try-catch-finally 包起来。

/**
     * Author: HuYuQiao
     * Description: Lock实现方式(加锁、解锁)
     */
    class TicketLock{
        Lock lock = new ReentrantLock();
        public int number = 50;
        public void sale(){
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "获得了第" + number-- +"票");

            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }

4.总结

​ 在不加锁情况下，多线程会争抢，导致 输出顺序、计算结果 都会不一致（上面例子结果如果一样是因为只有3个线程，for循环即出错，因为number--这个函数本身不是线程安全的），所以就引入了锁的概念，synchronized，lock保证了输出顺序、计算结果的一致性。

​ 虚假唤醒 ：在synchronized.wait与lock.condition.await唤醒线程时，是从await代码之后开始运行，所以为了保证能唤醒线程，需要用while语句将代码包含起来。

​ 完整代码

package com.empirefree.springboot;

import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import sun.security.krb5.internal.Ticket;

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

/**
 * @program: springboot
 * @description: 多线程
 * @author: huyuqiao
 * @create: 2021/06/26 14:26
 */

@RunWith(SpringRunner.class)
@SpringBootTest
@Slf4j
public class ThreadTest {
    
    /**
     * Author: HuYuQiao
     * Description: Synchronized实现方式(修饰函数即可)
     */
    class TicketSync{
        public int number = 50;
        //synchronized本质是队列，锁
        public synchronized void sale(){
            System.out.println(Thread.currentThread().getName() + "获得了第" + number-- +"票");

        }
    }
    
    /**
     * Author: HuYuQiao
     * Description: Lock实现方式(加锁、解锁)
     */
    class TicketLock{
        Lock lock = new ReentrantLock();
        public int number = 50;
        public void sale(){
            lock.lock();
            try {
                System.out.prin