多线程并发

刺骨的言语ヽ痛彻心扉 2022-03-09 06:12 401阅读 0赞

# 线程 #

> 新建线程

> 线程状态

# 并发理论 #

## JMM内存模型 ##

## 重排序 ##

## happens-before规则 ##

# 并发关键字 #

## synchronized ##

## volatile ##

# Lock体系 #

> Lock与synchronized对比

1.  Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；
2.  synchronized`无法判断是否获取锁的状态`，Lock`可以判断是否获取到锁`；
3.  synchronized在发生异常时，会`自动释放`线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用`Lock时需要在finally块中释放锁`；
4.  Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；
5.  `synchronized的锁可重入、不可中断、非公平`，而`Lock锁可重入、可中断、可公平`（两者皆可）
6.  Lock可以提高多个线程进行读操作的效率。
7.  `Lock锁适合大量同步的代码的同步问题`，synchronized锁适合代码少量的同步问题。在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。

> Lock接口

public interface Lock {
        void lock();
        void lockInterruptibly() throws InterruptedException;
        boolean tryLock();
        boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
        void unlock();	//释放锁
        Condition newCondition();
    }

由于在前面讲到如果采用`Lock，必须主动去释放锁`，并且在`发生异常时，不会自动释放锁`。因此一般来说，使用Lock必须在try\{\}catch\{\}块中进行，并且将`释放锁的操作放在finally块中进行，以保证锁一定被被释放`，防止死锁的发生。通常使用Lock来进行同步的话，是以下面这种形式去使用的：

Lock lock = ...;
    lock.lock();
    try{
        //处理任务
    }catch(Exception ex){
         
    }finally{
        lock.unlock();   //释放锁
    }

1.  void lock();
2.  boolean tryLock();  
    tryLock()方法是有返回值的，它表示用来尝试获取锁，`如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false`，也就说这个方法无论如何都会立即返回。在拿`不到锁时不会一直在那等待`。
3.  boolean tryLock(long time, TimeUnit unit) throws InterruptedException;  
    tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的，只不过`区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false`。如果如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。  
    所以，一般情况下通过tryLock来获取锁时是这样使用的：

Lock lock = ...;
    if(lock.tryLock()) {
         try{
             //处理任务
         }catch(Exception ex){
             
         }finally{
             lock.unlock();   //释放锁
         } 
    }else {
        //如果不能获取锁，则直接做其他事情
    }

1.  void lockInterruptibly() throws InterruptedException;  
    因此当通过lockInterruptibly()方法获取某个锁时，如果不能获取到，只有进行等待的情况下，是可以响应中断的。  
    而用synchronized修饰的话，当一个线程处于等待某个锁的状态，是无法被中断的，只有一直等待下去。

## AQS ##

> 什么是AQS

AQS是AbustactQueuedSynchronizer的简称，它是一个Java提高的底层同步工具类,AQS提供了一种实现阻塞锁和一系列依赖FIFO等待队列的同步器的框架，用一个`int类型的变量表示同步状态`，并提供了`一系列的CAS操作来管理这个同步状态`。`AQS的主要作用是为Java中的并发同步组件提供统一的底层支持`，例如ReentrantLock，CountdowLatch就是基于AQS实现的，用法是通过继承AQS实现其模版方法，然后将子类作为同步组件的内部类。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NhbWp1c3RpbjE_size_16_color_FFFFFF_t_70]

> AQS原理

**state状态**  
  AbstractQueuedSynchronizer维护了一个`volatile int类型的变量`，用户表示当前同步状态。volatile虽然不能保证操作的原子性，但是保证了当前变量state的可见性。至于volatile的具体语义，可以参考相关文章。state的访问方式有三种:

*  getState()
 *  setState()
 *  compareAndSetState()

这三种操作`均是原子操作`，其中compareAndSetState的实现依赖于Unsafe的compareAndSwapInt()方法。

**自定义资源共享方式**  
  AQS定义两种资源共享方式：`Exclusive`（独占，只有一个线程能执行，如ReentrantLock）和`Share`（共享，多个线程可同时执行，如Semaphore/CountDownLatch）。  
  不同的自定义同步器争用共享资源的方式也不同。`自定义同步器在实现时只需要实现共享资源state的获取与释放方式即可，至于具体线程等待队列的维护`（如获取资源失败入队/唤醒出队等），AQS已经在顶层实现好了。自定义同步器实现时主要实现以下几种方法：

isHeldExclusively()：该线程是否正在独占资源。只有用到condition才需要去实现它。
    tryAcquire(int)：独占方式。尝试获取资源，成功则返回true，失败则返回false。
    tryRelease(int)：独占方式。尝试释放资源，成功则返回true，失败则返回false。
    tryAcquireShared(int)：共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
    tryReleaseShared(int)：共享方式。尝试释放资源，如果释放后允许唤醒后续等待结点返回true，否则返回false。

> AQS源码解析

## **1. acquire(int)** ##

acquire是一种以独占方式获取资源，如果获取到资源，线程直接返回，否则进入等待队列，直到获取到资源为止，且整个过程忽略中断的影响。该方法是独占模式下线程获取共享资源的顶层入口。获取到资源后，线程就可以去执行其临界区代码了。下面是acquire()的源码：

public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

通过注释我们知道，acquire方法是一种互斥模式，且忽略中断。该方法至少执行一次tryAcquire(int)方法，如果tryAcquire(int)方法返回true，则acquire直接返回，否则当前线程需要进入队列进行排队。函数流程如下：

1.  tryAcquire()尝试直接去获取资源，如果成功则直接返回；
2.  addWaiter()将该线程加入等待队列的尾部，并标记为独占模式；
3.  acquireQueued()使线程在等待队列中获取资源，一直获取到资源后才返回。如果在整个等待过程中被中断过，则返回true，否则返回false。
4.  如果线程在等待过程中被中断过，它是不响应的。只是获取资源后才再进行自我中断selfInterrupt()，将中断补上。

**1.1 tryAcquire(int)**  
   tryAcquire尝试以独占的方式获取资源，如果获取成功，则直接返回true，否则直接返回false。该方法可以用于实现Lock中的tryLock()方法。该方法的默认实现是抛出UnsupportedOperationException，具体实现由自定义的扩展了AQS的同步类来实现。AQS在这里只负责定义了一个公共的方法框架。这里之所以没有定义成abstract，是因为独占模式下只用实现tryAcquire-tryRelease，而共享模式下只用实现tryAcquireShared-tryReleaseShared。如果都定义成abstract，那么每个模式也要去实现另一模式下的接口。

protected boolean tryAcquire(int arg) {
            throw new UnsupportedOperationException();
        }

**1.2 addWaiter(Node)**  
  该方法用于将当前线程根据不同的模式（Node.EXCLUSIVE互斥模式、Node.SHARED共享模式）加入到等待队列的队尾，并返回当前线程所在的结点。如果队列不为空，则以通过compareAndSetTail方法以CAS的方式将当前线程节点加入到等待队列的末尾。否则，通过enq(node)方法初始化一个等待队列，并返回当前节点。源码如下：

private Node addWaiter(Node mode) {
            Node node = new Node(Thread.currentThread(), mode);
            // Try the fast path of enq; backup to full enq on failure
            Node pred = tail;
            if (pred != null) {
                node.prev = pred;
                if (compareAndSetTail(pred, node)) {
                    pred.next = node;
                    return node;
                }
            }
            enq(node);
            return node;
        }

**1.3 acquireQueued(Node, int)**  
  acquireQueued()用于队列中的线程自旋地以独占且不可中断的方式获取同步状态（acquire），直到拿到锁之后再返回。该方法的实现分成两部分：如果当前节点已经成为头结点，尝试获取锁（tryAcquire）成功，然后返回；否则检查当前节点是否应该被park，然后将该线程park并且检查当前线程是否被可以被中断。

final boolean acquireQueued(final Node node, int arg) {
            //标记是否成功拿到资源，默认false
            boolean failed = true;
            try {
                boolean interrupted = false;//标记等待过程中是否被中断过
                for (;;) {
                    final Node p = node.predecessor();
                    if (p == head && tryAcquire(arg)) {
                        setHead(node);
                        p.next = null; // help GC
                        failed = false;
                        return interrupted;
                    }
                    if (shouldParkAfterFailedAcquire(p, node) &&
                        parkAndCheckInterrupt())
                        interrupted = true;
                }
            } finally {
                if (failed)
                    cancelAcquire(node);
            }
        }

## **2. release(int)** ##

release(int)方法是独占模式下线程释放共享资源的顶层入口。它会释放指定量的资源，如果彻底释放了（即state=0）,它会唤醒等待队列里的其他线程来获取资源。这也正是unlock()的语义，当然不仅仅只限于unlock()。下面是release()的源码：

## ReentrantLock ##

ReentrantLock，意思是“可重入锁”。ReentrantLock是唯一实现了Lock接口的类，并且ReentrantLock提供了更多的方法。

> 重入锁实现原理

> 公平锁实现原理

> 非公平锁实现原理

## ReadWriteLock ##

ReadWriteLock也是一个接口，在它里面只定义了两个方法：

public interface ReadWriteLock {
        Lock readLock();
        Lock writeLock();
    }

一个用来获取读锁，一个用来获取写锁。也就是说将文件的读写操作分开，分成2个锁来分配给线程，从而使得多个线程可以同时进行读操作。

> LockSupport

在Java多线程中，当需要阻塞或者唤醒一个线程时，都会使用LockSupport工具类来完成相应的工作。LockSupport定义了一组公共静态方法，这些方法提供了最基本的线程阻塞和唤醒功能，而LockSupport也因此成为了构建同步组件的基础工具。

LockSupport定义了一组以park开头的方法用来阻塞当前线程，以及unpark(Thread)方法来唤醒一个被阻塞的线程，这些方法描述如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NhbWp1c3RpbjE_size_16_color_FFFFFF_t_70 1]

> Condition

在java中，对于任意一个java对象，它都拥有一组定义在java.lang.Object上监视器方法，包括wait()，wait(long timeout)，notify()，notifyAll()，这些方法配合synchronized关键字一起使用可以实现等待/通知模式。  
同样，Condition接口也提供了类似Object监视器的方法，通过与Lock配合来实现等待/通知模式。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NhbWp1c3RpbjE_size_16_color_FFFFFF_t_70 2]

## ReentrantReadWriteLock ##

todo

# 并发容器 #

## ConcurrentHashMap ##

## CopyOnWriteArrayList ##

## ThreadLocal ##

## BlockingQueue ##

同步队列，又称阻塞队列。`同步队列是AQS很重要的组成部分`，它是一个`双端队列`，遵循FIFO原则，`主要作用是用来存放在锁上阻塞的线程`，当一个线程尝试获取锁时，如果已经被占用，那么当前线程就会被构造成一个Node节点假如到同步队列的尾部，`队列的头节点是成功获取锁的节点`，当头节点线程是否锁时，会唤醒后面的节点并释放当前头节点的引用。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NhbWp1c3RpbjE_size_16_color_FFFFFF_t_70 3]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NhbWp1c3RpbjE_size_16_color_FFFFFF_t_70 4]

## ConcurrentLinkedQueue ##

# 线程池 #

# 原子操作类 #

# 并发工具 #

## CountDownLatch倒计时器 ##

## CyclicBarrier循环栅栏 ##

## CountDownLatch与CyclicBarrier比较 ##

## Semaphore资源访问控制 ##

# 并发实践 #

> 生产者消费者问题

*  Object的wait/notifyAll方式
 *  lock的condition的await/signalAll方式
 *  blockingQueue方式

# 参考文献 #

[多线程并发知识合集][Link 1]  
[40个Java多线程问题总结][40_Java]  
[Java并发-AQS及各种Lock锁的原理][Java_-AQS_Lock]  
[Java技术之AQS详解][Java_AQS]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NhbWp1c3RpbjE_size_16_color_FFFFFF_t_70]: /images/20220309/cfd867ca0ec74ec9b15e3b03ba78b0d0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NhbWp1c3RpbjE_size_16_color_FFFFFF_t_70 1]: /images/20220309/43e20001658c454d915956230977a505.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NhbWp1c3RpbjE_size_16_color_FFFFFF_t_70 2]: /images/20220309/59d4a65dc01041189b626b475261679d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NhbWp1c3RpbjE_size_16_color_FFFFFF_t_70 3]: /images/20220309/54686674879a4552a9691b3ad0039159.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NhbWp1c3RpbjE_size_16_color_FFFFFF_t_70 4]: /images/20220309/dc5a2e6b2da04c14bc10ac79324d681e.png
[Link 1]: https://github.com/CL0610/Java-concurrency
[40_Java]: http://www.importnew.com/18459.html
[Java_-AQS_Lock]: https://blog.csdn.net/zhangdong2012/article/details/79983404
[Java_AQS]: https://www.jianshu.com/p/da9d051dcc3d