多线程高并发详情总结

最新推荐文章于 2024-04-28 09:44:26 发布
置顶 最新推荐文章于 2024-04-28 09:44:26 发布
阅读量741 收藏 2
点赞数 3
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32012375/article/details/108376816
版权

多线程高并发JUC同步锁：

ReentrantLock ：读写锁，共享锁

​ readLock 读锁 writeLock写锁

SemaPhore：一个计数信号量

常用于限制可以访问某些资源的线程数量，例如通过 Semaphore 限流。三种操作：

​ 1初始化 2增加 3减少

``

//信号量，只允许 3个线程同时访问
        Semaphore semaphore = new Semaphore(3);
//获取许可信息
	semaphore.acquire();
//释放许可信息
//当获取许可信息的时候 线程数量3减少1 ，当释放的许可信息的时候数量还原，这样保证了线程的有序性，当前允许的线程数量为1的时候，所有线程将有序执行，从第一个获取许可开始 从上往下执行

Exchanger：线程信息交换

​ Exchanger类可用于（两个线程）之间交换信息。可简单地将Exchanger对象理解为一个包含两个格子的容器，通过exchanger方法可以向两个格子中填充信息。当两个格子中的均被填充时，该对象会自动将两个格子的信息交换，然后返回给线程，从而实现两个线程的信息交换

LockSupport：线程控制（阻塞和唤醒）

​ park 阻塞

​ unpark 唤醒

​ 我们换一种角度来理解一下park和unpark，可以想一下，unpark其实就相当于一个许可，告诉特定线程你可以停车，特定线程想要park停车的时候一看到有许可，就可以立马停车继续运行了。因此其执行顺序可以颠倒。

现在有了这个概念，我们体会一下上面JVM层面park的方法，这里面counter字段，就是用来记录所谓的“许可”的。

CountDownLatch：

ountDownLatch这个类使一个线程等待其他线程各自执行完毕后再执行。

​ 是通过一个计数器来实现的，计数器的初始值是线程的数量。每当一个线程执行完毕后，计数器的值就-1，当计数器的值为0时，表示所有线程都执行完毕，然后在闭锁上等待的线程就可以恢复工作了！

构造函数：

//参数count为计数值
public CountDownLatch(int count) {  };

/===比较重要的方法
//调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行
public void await() throws InterruptedException { };   
//和await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行
public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };  
//将count值减1
public void countDown() { };  


*CountDownLatch和CyclicBarrier区别：
1.countDownLatch是一个计数器，线程完成一个记录一个，计数器递减，只能只用一次
2.CyclicBarrier的计数器更像一个阀门，需要所有线程都到达，然后继续执行，计数器递增，提供reset功能，可以多次使用

CycliBarrier：（单词：循环栅栏）

它的作用就是会让所有线程都等待完成后才会继续下一步行动。

举个例子，就像生活中我们会约朋友们到某个餐厅一起吃饭，有些朋友可能会早到，有些朋友可能会晚到，但是这个餐厅规定必须等到所有人到齐之后才会让我们进去。这里的朋友们就是各个线程，餐厅就是 CyclicBarrier

​ 应用场景：一个线程组的线程需要等待所有线程完成任务后再继续执行下一次任务

​ 构造方法：

public CyclicBarrier(int parties)
public CyclicBarrier(int parties, Runnable barrierAction)
    //参数解释
	parties 是参与线程的个数
	第二个构造方法有一个 Runnable 参数，这个参数的意思是最	后一个到达线程要做的任务
 
    //重要方法：
    public int await() throws InterruptedException, BrokenBarrierException
    
	public int await(long timeout, TimeUnit unit) throws InterruptedException, BrokenBarrierException, TimeoutException	
    //参数解析：
    线程调用 await() 表示自己已经到达栅栏
    
	BrokenBarrierException 表示栅栏已经被破坏，破坏的原因可能是其中一个线程 await() 时被中断或者超时

Phaser：（阶段器）

场景：从字面意思能理解为，用来解决控制多个线程分阶段共同完成任务的情景问题。

例子：学生考试，首先必须所有学生到场才能开始，学生考完才能收卷，收完卷才能评卷

​ 在CyclicBarrier、CountDownLatch中，我们使用计数器来控制程序的顺序执行，同样的在Phaser中也是通过计数器来控制。在Phaser中计数器叫做parties， 我们可以通过Phaser的构造函数或者register()方法来注册。

​ 通过调用register()方法，我们可以动态的控制phaser的个数。如果我们需要取消注册，则可以调用arriveAndDeregister()方法。

Phaser的值是从0到Integer.MAX_VALUE，每个周期过后该值就会加一，如果到达Integer.MAX_VALUE则会继续从0开始。

如果我们执行多个Phaser周期，则可以重写onAdvance方法：

protected boolean onAdvance(int phase, int registeredParties) {
        return registeredParties == 0;
    }

onAdvance将会在最后一个arrive（）调用的时候被调用，如果这个时候registeredParties为0的话，该Phaser将会调用isTerminated方法结束该Phaser。

如果要实现多周期的情况，我们可以重写这个方法：

protected boolean onAdvance(int phase, int registeredParties) {
                return phase >= iterations || registeredParties == 0;
            }

所谓AQS，指的是AbstractQueuedSynchronizer，它提供了一种实现阻塞锁和一系列依赖FIFO等待队列的同步器的框架，ReentrantLock、Semaphore、CountDownLatch、CyclicBarrier等并发类均是基于AQS来实现的，具体用法是通过继承AQS实现其模板方法，然后将子类作为同步组件的内部类。

了解一个框架最好的方式是读源码，说干就干。

AQS是JDK1.5之后才出现的，由大名鼎鼎的Doug Lea李大爷来操刀设计并开发实现，全部源代码(加注释)2315行，整体难度中等。

* @since 1.5
* @author Doug Lea

基本框架AQS

在阅读源码前，首先阐述AQS的基本思想及其相关概念。

AQS基本框架如下图所示：

img

AQS维护了一个volatile语义(支持多线程下的可见性)的共享资源变量state和一个FIFO线程等待队列(多线程竞争state被阻塞时会进入此队列)。

State

首先说一下共享资源变量state，它是int数据类型的，其访问方式有3种：

  • getState()
  • setState(int newState)
  • compareAndSetState(int expect, int update)

上述3种方式均是原子操作，其中compareAndSetState()的实现依赖于Unsafe的compareAndSwapInt()方法。

private volatile int state;

// 具有内存读可见性语义
protected final int getState() {
    return state;
}

// 具有内存写可见性语义
protected final void setState(int newState) {
    state = newState;
}

// 具有内存读/写可见性语义
protected final boolean compareAndSetState(int expect, int update) {
    // See below for intrinsics setup to support this
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

资源的共享方式分为2种：

  • 独占式(Exclusive)

只有单个线程能够成功获取资源并执行，如ReentrantLock。

  • 共享式(Shared)

多个线程可成功获取资源并执行，如Semaphore/CountDownLatch等。

AQS将大部分的同步逻辑均已经实现好，继承的自定义同步器只需要实现state的获取(acquire)和释放(release)的逻辑代码就可以，主要包括下面方法：

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

AQS需要子类复写的方法均没有声明为abstract，目的是避免子类需要强制性覆写多个方法，因为一般自定义同步器要么是独占方法，要么是共享方法，只需实现tryAcquire-tryRelease、tryAcquireShared-tryReleaseShared中的一种即可。

当然，AQS也支持子类同时实现独占和共享两种模式，如ReentrantReadWriteLock。

CLH队列(FIFO)

AQS是通过内部类Node来实现FIFO队列的，源代码解析如下：

static final class Node {
    
    // 表明节点在共享模式下等待的标记
    static final Node SHARED = new Node();
    // 表明节点在独占模式下等待的标记
    static final Node EXCLUSIVE = null;

    // 表征等待线程已取消的
    static final int CANCELLED =  1;
    // 表征需要唤醒后续线程
    static final int SIGNAL    = -1;
    // 表征线程正在等待触发条件(condition)
    static final int CONDITION = -2;
    // 表征下一个acquireShared应无条件传播
    static final int PROPAGATE = -3;

    /**
     *   SIGNAL: 当前节点释放state或者取消后，将通知后续节点竞争state。
     *   CANCELLED: 线程因timeout和interrupt而放弃竞争state，当前节点将与state彻底拜拜
     *   CONDITION: 表征当前节点处于条件队列中，它将不能用作同步队列节点，直到其waitStatus被重置为0
     *   PROPAGATE: 表征下一个acquireShared应无条件传播
     *   0: None of the above
     */
    volatile int waitStatus;
    
    // 前继节点
    volatile Node prev;
    // 后继节点
    volatile Node next;
    // 持有的线程
    volatile Thread thread;
    // 链接下一个等待条件触发的节点
    Node nextWaiter;

    // 返回节点是否处于Shared状态下
    final boolean isShared() {
        return nextWaiter == SHARED;
    }

    // 返回前继节点
    final Node predecessor() throws NullPointerException {
        Node p = prev;
        if (p == null)
            throw new NullPointerException();
        else
            return p;
    }
    
    // Shared模式下的Node构造函数
    Node() {  
    }

    // 用于addWaiter
    Node(Thread thread, Node mode) {  
        this.nextWaiter = mode;
        this.thread = thread;
    }
    
    // 用于Condition
    Node(Thread thread, int waitStatus) {
        this.waitStatus = waitStatus;
        this.thread = thread;
    }
}

可以看到，waitStatus非负的时候，表征不可用，正数代表处于等待状态，所以waitStatus只需要检查其正负符号即可，不用太多关注特定值。

获取资源(独占模式)

acquire(int)

首先讲解独占模式(Exclusive)下的获取/释放资源过程，其入口方法为:

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

tryAcquire(arg)为线程获取资源的方法函数，在AQS中定义如下：

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

很明显，该方法是空方法，且由protected修饰，说明该方法需要由子类即自定义同步器来实现。

acquire()方法至少执行一次tryAcquire(arg)，若返回true，则acquire直接返回，否则进入acquireQueued(addWaiter(Node.EXCLUSIVE), arg)方法。

acquireQueued方法分为3个步骤：

  1. addWriter()将当前线程加入到等待队列的尾部，并标记为独占模式；
  2. acquireQueued()使线程在等待队列中获取资源，直到获取到资源返回，若整个等待过程被中断过，则返回True，否则返回False。
  3. 如果线程在等待过程中被中断过，则先标记上，待获取到资源后再进行自我中断selfInterrupt()，将中断响应掉。

下面具体看看过程中涉及到的各函数：

tryAcquire(int)

tryAcquire尝试以独占的模式获取资源，如果获取成功则返回True，否则直接返回False，默认实现是抛出UnsupportedOperationException，具体实现由自定义扩展了AQS的同步器来完成。

addWaiter(Node)

addWaiter为当前线程以指定模式创建节点，并将其添加到等待队列的尾部，其源码为：

private Node addWaiter(Node mode) {
    Node node = new Node(Thread.currentThread(), mode);
    // 尝试将节点快速插入等待队列，若失败则执行常规插入(enq方法)
    Node pred = tail;
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    // 常规插入
    enq(node);
    return node;
}

再看enq(node)方法：

private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
        if (t == null) { // Must initialize
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

可以看到，常规插入与快速插入相比，有2点不同：

  1. 常规插入是自旋过程(for(;😉)，能够保证节点插入成功；
  2. 比快速插入多包含了1种情况，即当前等待队列为空时，需要初始化队列，即将待插入节点设置为头结点，同时为尾节点(因为只有一个嘛)。

常规插入与快速插入均依赖于CAS，其实现依赖于unsafe类，具体代码如下：

private final boolean compareAndSetHead(Node update) {
    return unsafe.compareAndSwapObject(this, headOffset, null, update);
}

private final boolean compareAndSetTail(Node expect, Node update) {
    return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
}

unsafe中的cas操作均是native方法，由计算机CPU的cmpxchg指令来保证其原子性。

接着看acquireQueued()方法：

acquireQueued(Node, int)

相关说明已在代码中注释：

final boolean acquireQueued(final Node node, int arg) {
    // 标识是否获取资源失败
    boolean failed = true;
    try {
        // 标识当前线程是否被中断过
        boolean interrupted = false;
        // 自旋操作
        for (;;) {
            // 获取当前节点的前继节点
            final Node p = node.predecessor();
            // 如果前继节点为头结点，说明排队马上排到自己了，可以尝试获取资源，若获取资源成功，则执行下述操作
            if (p == head && tryAcquire(arg)) {
                // 将当前节点设置为头结点
                setHead(node);
                // 说明前继节点已经释放掉资源了，将其next置空，以方便虚拟机回收掉该前继节点
                p.next = null; // help GC
                // 标识获取资源成功
                failed = false;
                // 返回中断标记
                return interrupted;
            }
            // 若前继节点不是头结点，或者获取资源失败，
            // 则需要通过shouldParkAfterFailedAcquire函数
            // 判断是否需要阻塞该节点持有的线程
            // 若shouldParkAfterFailedAcquire函数返回true，
            // 则继续执行parkAndCheckInterrupt()函数，
            // 将该线程阻塞并检查是否可以被中断，若返回true，则将interrupted标志置于true
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        // 最终获取资源失败，则当前节点放弃获取资源
        if (failed)
            cancelAcquire(node);
    }
}

具体看一下shouldParkAfterFailedAcquire函数：

// shouldParkAfterFailedAcquire是通过前继节点的waitStatus值来判断是否阻塞当前节点的线程的
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    // 获取前继节点的waitStatus值ws
    int ws = pred.waitStatus;
    // 如果ws的值为Node.SIGNAL(-1)，则直接返回true
    // 说明前继节点完成资源的释放或者中断后，会通知当前节点的，回家等通知就好了，不用自旋频繁地来打听消息
    if (ws == Node.SIGNAL)
        return true;
    // 如果前继节点的ws值大于0,即为1,说明前继节点处于放弃状态(Cancelled)
    // 那就继续往前遍历，直到当前节点的前继节点的ws值为0或负数
    // 此处代码很关键，节点往前移动就是通过这里来实现的，直到节点的前继节点满足
    // if (p == head && tryAcquire(arg))条件，acquireQueued方法才能够跳出自旋过程
    if (ws > 0) {
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        // 将前继节点的ws值设置为Node.SIGNAL，以保证下次自旋时，shouldParkAfterFailedAcquire直接返回true
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

parkAndCheckInterrupt()函数则简单很多，主要调用LockSupport类的park()方法阻塞当前线程，并返回线程是否被中断过。

private final boolean parkAndCheckInterrupt() {
    LockSupport.park(this);
    return Thread.interrupted();
}

至此，独占模式下，线程获取资源acquire的代码就跟完了，总结一下过程：

  1. 首先线程通过tryAcquire(arg)尝试获取共享资源，若获取成功则直接返回，若不成功，则将该线程以独占模式添加到等待队列尾部，tryAcquire(arg)由继承AQS的自定义同步器来具体实现；
  2. 当前线程加入等待队列后，会通过acquireQueued方法基于CAS自旋不断尝试获取资源，直至获取到资源；
  3. 若在自旋过程中，线程被中断过，acquireQueued方法会标记此次中断，并返回true。
  4. 若acquireQueued方法获取到资源后，返回true，则执行线程自我中断操作selfInterrupt()。
static void selfInterrupt() {
    Thread.currentThread().interrupt();
}

释放资源(独占模式)

讲完获取资源，对应的讲一下AQS的释放资源过程，其入口函数为：

public final boolean release(int arg) {
    if (tryRelease(arg)) {
        // 获取到等待队列的头结点h
        Node h = head;
        // 若头结点不为空且其ws值非0，则唤醒h的后继节点
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

逻辑并不复杂，通过tryRelease(arg)来释放资源，和tryAcquire类似，tryRelease也是有继承AQS的自定义同步器来具体实现。

tryRelease(int)

该方法尝试释放指定量的资源。

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

unparkSuccessor(Node)

该方法主要用于唤醒等待队列中的下一个阻塞线程。

private void unparkSuccessor(Node node) {
    // 获取当前节点的ws值
    int ws = node.waitStatus;
    // 将当前节点的ws值置0
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);

    Node s = node.next;
    // 若后继节点为null或者其ws值大于0(放弃状态)，则从等待队列的尾节点从后往前搜索，
    // 搜索到等待队列中最靠前的ws值非正且非null的节点
    if (s == null || s.waitStatus > 0) {
        s = null;
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    // 如果后继节点非null，则唤醒该后继节点持有的线程
    if (s != null)
        LockSupport.unpark(s.thread);
}

后继节点的阻塞线程被唤醒后，就进入到acquireQueued()的if (p == head && tryAcquire(arg))的判断中，此时被唤醒的线程将尝试获取资源。

当然，如果被唤醒的线程所在节点的前继节点不是头结点，经过shouldParkAfterFailedAcquire的调整，也会移动到等待队列的前面，直到其前继节点为头结点。

讲解完独占模式下资源的acquire/release过程，下面开始讲解共享模式下，线程如何完成资源的获取和共享。

获取资源(共享模式)

理解了独占模式下，资源的获取和释放过程，则共享模式下也就so easy了，首先看一下方法入口：

public final void acquireShared(int arg) {
    if (tryAcquireShared(arg) < 0)
        doAcquireShared(arg);
}

执行tryAcquireShared方法获取资源，若获取成功则直接返回，若失败，则进入等待队列，执行自旋获取资源，具体由doAcquireShared方法来实现。

tryAcquireShared(int)

同样的，tryAcquireShared(int)由继承AQS的自定义同步器来具体实现。

protected int tryAcquireShared(int arg) {
    throw new UnsupportedOperationException();
}

其返回值为负值代表失败；0代表获取成功，但无剩余资源；正值代表获取成功且有剩余资源，其他线程可去获取。

doAcquireShared(int)

private void doAcquireShared(int arg) {
    // 将线程以共享模式添加到等待队列的尾部
    final Node node = addWaiter(Node.SHARED);
    // 初始化失败标志
    boolean failed = true;
    try {
        // 初始化线程中断标志
        boolean interrupted = false;
        for (;;) {
            // 获取当前节点的前继节点
            final Node p = node.predecessor();
            // 若前继节点为头结点，则执行tryAcquireShared获取资源
            if (p == head) {
                int r = tryAcquireShared(arg);
                // 若获取资源成功，且有剩余资源，将自己设为头结点并唤醒后续的阻塞线程
                if (r >= 0) {
                    setHeadAndPropagate(node, r);
                    p.next = null; // help GC
                    // 如果中断标志位为真，则线程执行自我了断
                    if (interrupted)
                        selfInterrupt();
                    // 表征获取资源成功
                    failed = false;
                    return;
                }
            }
            // houldParkAfterFailedAcquire(p, node)根据前继节点判断是否阻塞当前节点的线程
            // parkAndCheckInterrupt()阻塞当前线程并检查线程是否被中断过，若被中断过，将interrupted置为true
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            // 放弃获取资源
            cancelAcquire(node);
    }
}

可以发现，doAcquireShared与独占模式下的acquireQueued大同小异，主要有2点不同：

  1. doAcquireShared将线程的自我中断操作放在了方法体内部；
  2. 当线程获取到资源后，doAcquireShared会将当前线程所在的节点设为头结点，若资源有剩余则唤醒后续节点，比acquireQueued多了个唤醒后续节点的操作。

上述方法体现了共享的本质，即当前线程吃饱了后，若资源有剩余，会招呼后面排队的来一起吃，好东西要大家一起分享嘛，哈哈。

下面具体看一下setHeadAndPropagate(Node, int)函数：

private void setHeadAndPropagate(Node node, int propagate) {
    // 记录原来的头结点，下面过程会用到
    Node h = head; 
    // 设置新的头结点
    setHead(node);
    
    // 如果资源还有剩余，则唤醒后继节点
    if (propagate > 0 || h == null || h.waitStatus < 0 ||
        (h = head) == null || h.waitStatus < 0) {
        Node s = node.next;
        if (s == null || s.isShared())
            doReleaseShared();
    }
}

可以看到，实际执行唤醒后继节点的方法是doReleaseShared()，继续追踪：

private void doReleaseShared() {
    // 自旋操作
    for (;;) {
        // 获取等待队列的头结点
        Node h = head;
        if (h != null && h != tail) {
            int ws = h.waitStatus;
            if (ws == Node.SIGNAL) {
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                    continue; 
                // 唤醒后继节点的线程
                unparkSuccessor(h);
            }
            else if (ws == 0 &&
                     !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                continue;                // loop on failed CAS
        }
        if (h == head)                   // loop if head changed
            break;
    }
}

释放资源(共享模式)

首先进入到方法入口：

public final boolean releaseShared(int arg) {
    // 尝试释放资源
    if (tryReleaseShared(arg)) {
        // 唤醒后继节点的线程
        doReleaseShared();
        return true;
    }
    return false;
}

同样的，tryReleaseShared(int)由继承AQS的自定义同步器来具体实现。

doReleaseShared()上节讲解setHeadAndPropagate已说明过，不再赘述。

至此，共享模式下的资源获取/释放就讲解完了，下面以一个具体场景来概括一下：

整个获取/释放资源的过程是通过传播完成的，如最开始有10个资源，线程A、B、C分别需要5、4、3个资源。

  • A线程获取到5个资源，其发现资源还剩余5个，则唤醒B线程；

  • B线程获取到4个资源，其发现资源还剩余1个，唤醒C线程；

  • C线程尝试取3个资源，但发现只有1个资源，继续阻塞；

  • A线程释放1个资源，其发现资源还剩余2个，故唤醒C线程；

  • C线程尝试取3个资源，但发现只有2个资源，继续阻塞；

  • B线程释放2个资源，其发现资源还剩余4个，唤醒C线程；

  • C线程获取3个资源，其发现资源还剩1个，继续唤醒后续等待的D线程；

常见的21种锁：

img

帮你总结好的锁：

序号锁名称应用
1乐观锁CAS
2悲观锁synchronized、vector、hashtable
3自旋锁CAS
4可重入锁synchronized、Reentrantlock、Lock
5读写锁ReentrantReadWriteLock，CopyOnWriteArrayList、CopyOnWriteArraySet
6公平锁Reentrantlock(true)
7非公平锁synchronized、reentrantlock(false)
8共享锁ReentrantReadWriteLock中读锁
9独占锁synchronized、vector、hashtable、ReentrantReadWriteLock中写锁
10重量级锁synchronized
11轻量级锁锁优化技术
12偏向锁锁优化技术
13分段锁concurrentHashMap
14互斥锁synchronized
15同步锁synchronized
16死锁相互请求对方的资源
17锁粗化锁优化技术
18锁消除锁优化技术

1、乐观锁

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VJMF4Agf-1599098962763)(data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQImWNgYGBgAAAABQABh6FO1AAAAABJRU5ErkJggg==)]乐观锁

乐观锁是一种乐观思想，假定当前环境是读多写少，遇到并发写的概率比较低，读数据时认为别的线程不会正在进行修改（所以没有上锁）。写数据时，判断当前 与期望值是否相同，如果相同则进行更新（更新期间加锁，保证是原子性的）。

Java中的乐观锁： CAS，比较并替换，比较当前值（主内存中的值），与预期值（当前线程中的值，主内存中值的一份拷贝）是否一样，一样则更新，否则继续进行CAS操作。

如上图所示，可以同时进行读操作，读的时候其他线程不能进行写操作。

2、悲观锁

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7F1eK859-1599098962765)(data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQImWNgYGBgAAAABQABh6FO1AAAAABJRU5ErkJggg==)]悲观锁

悲观锁是一种悲观思想，即认为写多读少，遇到并发写的可能性高，每次去拿数据的时候都认为其他线程会修改，所以每次读写数据都会认为其他线程会修改，所以每次读写数据时都会上锁。其他线程想要读写这个数据时，会被这个线程block，直到这个线程释放锁然后其他线程获取到锁。

Java中的悲观锁： synchronized修饰的方法和方法块、ReentrantLock。

如上图所示，只能有一个线程进行读操作或者写操作，其他线程的读写操作均不能进行。

3、自旋锁

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RC2wBFZr-1599098962766)(data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQImWNgYGBgAAAABQABh6FO1AAAAABJRU5ErkJggg==)]mark

自旋锁是一种技术： 为了让线程等待，我们只须让线程执行一个忙循环（自旋）。

现在绝大多数的个人电脑和服务器都是多路（核）处理器系统，如果物理机器有一个以上的处理器或者处理器核心，能让两个或以上的线程同时并行执行，就可以让后面请求锁的那个线程“稍等一会”，但不放弃处理器的执行时间，看看持有锁的线程是否很快就会释放锁。

自旋锁的优点： 避免了线程切换的开销。挂起线程和恢复线程的操作都需要转入内核态中完成，这些操作给Java虚拟机的并发性能带来了很大的压力。

自旋锁的缺点： 占用处理器的时间，如果占用的时间很长，会白白消耗处理器资源，而不会做任何有价值的工作，带来性能的浪费。因此自旋等待的时间必须有一定的限度，如果自旋超过了限定的次数仍然没有成功获得锁，就应当使用传统的方式去挂起线程。

自旋次数默认值：10次，可以使用参数-XX:PreBlockSpin来自行更改。

自适应自旋： 自适应意味着自旋的时间不再是固定的，而是由前一次在同一个锁上的自旋时间及锁的拥有者的状态来决定的。有了自适应自旋，随着程序运行时间的增长及性能监控信息的不断完善，虚拟机对程序锁的状态预测就会越来越精准。

Java中的自旋锁： CAS操作中的比较操作失败后的自旋等待。

4、可重入锁（递归锁）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YtPsLAPj-1599098962768)(data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQImWNgYGBgAAAABQABh6FO1AAAAABJRU5ErkJggg==)]可重入锁

可重入锁是一种技术： 任意线程在获取到锁之后能够再次获取该锁而不会被锁所阻塞。

可重入锁的原理： 通过组合自定义同步器来实现锁的获取与释放。

  • 再次获取锁：识别获取锁的线程是否为当前占据锁的线程，如果是，则再次成功获取。获取锁后，进行计数自增，
  • 释放锁：释放锁时，进行计数自减。

Java中的可重入锁： ReentrantLock、synchronized修饰的方法或代码段。

可重入锁的作用： 避免死锁。

面试题1： 可重入锁如果加了两把，但是只释放了一把会出现什么问题？

答：程序卡死，线程不能出来，也就是说我们申请了几把锁，就需要释放几把锁。

面试题2： 如果只加了一把锁，释放两次会出现什么问题？

答：会报错，java.lang.IllegalMonitorStateException。

5、读写锁

读写锁是一种技术： 通过ReentrantReadWriteLock类来实现。为了提高性能， Java 提供了读写锁，在读的地方使用读锁，在写的地方使用写锁，灵活控制，如果没有写锁的情况下，读是无阻塞的，在一定程度上提高了程序的执行效率。读写锁分为读锁和写锁，多个读锁不互斥，读锁与写锁互斥，这是由 jvm 自己控制的。

读锁： 允许多个线程获取读锁，同时访问同一个资源。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AvNuPSXH-1599098962768)(data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQImWNgYGBgAAAABQABh6FO1AAAAABJRU5ErkJggg==)]读锁

写锁： 只允许一个线程获取写锁，不允许同时访问同一个资源。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CvAEQIFW-1599098962769)(data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQImWNgYGBgAAAABQABh6FO1AAAAABJRU5ErkJggg==)]写锁

如何使用：

/**
* 创建一个读写锁
* 它是一个读写融为一体的锁，在使用的时候，需要转换
*/
private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();

获取读锁和释放读锁

// 获取读锁
rwLock.readLock().lock();

// 释放读锁
rwLock.readLock().unlock();

获取写锁和释放写锁

// 创建一个写锁
rwLock.writeLock().lock();

// 写锁 释放
rwLock.writeLock().unlock();

Java中的读写锁：ReentrantReadWriteLock

6、公平锁

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-t4YIQu17-1599098962770)(data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQImWNgYGBgAAAABQABh6FO1AAAAABJRU5ErkJggg==)]公平锁

公平锁是一种思想： 多个线程按照申请锁的顺序来获取锁。在并发环境中，每个线程会先查看此锁维护的等待队列，如果当前等待队列为空，则占有锁，如果等待队列不为空，则加入到等待队列的末尾，按照FIFO的原则从队列中拿到线程，然后占有锁。

7、非公平锁

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VaeH0pE8-1599098962771)(data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQImWNgYGBgAAAABQABh6FO1AAAAABJRU5ErkJggg==)]非公平锁

非公平锁是一种思想： 线程尝试获取锁，如果获取不到，则再采用公平锁的方式。多个线程获取锁的顺序，不是按照先到先得的顺序，有可能后申请锁的线程比先申请的线程优先获取锁。

优点： 非公平锁的性能高于公平锁。

缺点： 有可能造成线程饥饿（某个线程很长一段时间获取不到锁）

**Java中的非公平锁：**synchronized是非公平锁，ReentrantLock通过构造函数指定该锁是公平的还是非公平的，默认是非公平的。

8、共享锁

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OlviaZLw-1599098962772)(data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQImWNgYGBgAAAABQABh6FO1AAAAABJRU5ErkJggg==)]共享锁

共享锁是一种思想： 可以有多个线程获取读锁，以共享的方式持有锁。和乐观锁、读写锁同义。

Java中用到的共享锁： ReentrantReadWriteLock。

9、独占锁

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6lWdBcVg-1599098962773)(data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQImWNgYGBgAAAABQABh6FO1AAAAABJRU5ErkJggg==)]独占锁

独占锁是一种思想： 只能有一个线程获取锁，以独占的方式持有锁。和悲观锁、互斥锁同义。

Java中用到的独占锁： synchronized，ReentrantLock

10、重量级锁

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-17Z9rdzx-1599098962774)(data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQImWNgYGBgAAAABQABh6FO1AAAAABJRU5ErkJggg==)]重量级锁

重量级锁是一种称谓： synchronized是通过对象内部的一个叫做监视器锁（monitor）来实现的，监视器锁本身依赖底层的操作系统的 Mutex Lock来实现。操作系统实现线程的切换需要从用户态切换到核心态，成本非常高。这种依赖于操作系统 Mutex Lock来实现的锁称为重量级锁。为了优化synchonized，引入了轻量级锁，偏向锁。

Java中的重量级锁： synchronized

11、轻量级锁

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OxV2PQiY-1599098962775)(data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQImWNgYGBgAAAABQABh6FO1AAAAABJRU5ErkJggg==)]轻量级锁

轻量级锁是JDK6时加入的一种锁优化机制： 轻量级锁是在无竞争的情况下使用CAS操作去消除同步使用的互斥量。轻量级是相对于使用操作系统互斥量来实现的重量级锁而言的。轻量级锁在没有多线程竞争的前提下，减少传统的重量级锁使用操作系统互斥量产生的性能消耗。如果出现两条以上的线程争用同一个锁的情况，那轻量级锁将不会有效，必须膨胀为重量级锁。

优点： 如果没有竞争，通过CAS操作成功避免了使用互斥量的开销。

缺点： 如果存在竞争，除了互斥量本身的开销外，还额外产生了CAS操作的开销，因此在有竞争的情况下，轻量级锁比传统的重量级锁更慢。

12、偏向锁

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9M5UbInd-1599098962776)(data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQImWNgYGBgAAAABQABh6FO1AAAAABJRU5ErkJggg==)]偏向锁

偏向锁是JDK6时加入的一种锁优化机制： 在无竞争的情况下把整个同步都消除掉，连CAS操作都不去做了。偏是指偏心，它的意思是这个锁会偏向于第一个获得它的线程，如果在接下来的执行过程中，该锁一直没有被其他的线程获取，则持有偏向锁的线程将永远不需要再进行同步。持有偏向锁的线程以后每次进入这个锁相关的同步块时，虚拟机都可以不再进行任何同步操作（例如加锁、解锁及对Mark Word的更新操作等）。

优点： 把整个同步都消除掉，连CAS操作都不去做了，优于轻量级锁。

缺点： 如果程序中大多数的锁都总是被多个不同的线程访问，那偏向锁就是多余的。

13、分段锁

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-D4jy6FXq-1599098962778)(data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQImWNgYGBgAAAABQABh6FO1AAAAABJRU5ErkJggg==)]分段锁

分段锁是一种机制： 最好的例子来说明分段锁是ConcurrentHashMap。**ConcurrentHashMap原理：**它内部细分了若干个小的 HashMap，称之为段(Segment)。默认情况下一个 ConcurrentHashMap 被进一步细分为 16 个段，既就是锁的并发度。如果需要在 ConcurrentHashMap 添加一项key-value，并不是将整个 HashMap 加锁，而是首先根据 hashcode 得到该key-value应该存放在哪个段中，然后对该段加锁，并完成 put 操作。在多线程环境中，如果多个线程同时进行put操作，只要被加入的key-value不存放在同一个段中，则线程间可以做到真正的并行。

**线程安全：**ConcurrentHashMap 是一个 Segment 数组， Segment 通过继承ReentrantLock 来进行加锁，所以每次需要加锁的操作锁住的是一个 segment，这样只要保证每个 Segment 是线程安全的，也就实现了全局的线程安全

14、互斥锁

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bVy5Hhbx-1599098962779)(data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQImWNgYGBgAAAABQABh6FO1AAAAABJRU5ErkJggg==)]互斥锁

互斥锁与悲观锁、独占锁同义，表示某个资源只能被一个线程访问，其他线程不能访问。

  • 读-读互斥
  • 读-写互斥
  • 写-读互斥
  • 写-写互斥

Java中的同步锁： synchronized

15、同步锁

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ukMKloYH-1599098962780)(data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQImWNgYGBgAAAABQABh6FO1AAAAABJRU5ErkJggg==)]同步锁

同步锁与互斥锁同义，表示并发执行的多个线程，在同一时间内只允许一个线程访问共享数据。

Java中的同步锁： synchronized

16、死锁

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bKICP8Si-1599098962780)(data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQImWNgYGBgAAAABQABh6FO1AAAAABJRU5ErkJggg==)]死锁

**死锁是一种现象：**如线程A持有资源x，线程B持有资源y，线程A等待线程B释放资源y，线程B等待线程A释放资源x，两个线程都不释放自己持有的资源，则两个线程都获取不到对方的资源，就会造成死锁。

Java中的死锁不能自行打破，所以线程死锁后，线程不能进行响应。所以一定要注意程序的并发场景，避免造成死锁。

17、锁粗化

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kJad3vou-1599098962781)(data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQImWNgYGBgAAAABQABh6FO1AAAAABJRU5ErkJggg==)]锁粗化

锁粗化是一种优化技术： 如果一系列的连续操作都对同一个对象反复加锁和解锁，甚至加锁操作都是出现在循环体体之中，就算真的没有线程竞争，频繁地进行互斥同步操作将会导致不必要的性能损耗，所以就采取了一种方案：把加锁的范围扩展（粗化）到整个操作序列的外部，这样加锁解锁的频率就会大大降低，从而减少了性能损耗。

18、锁消除

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2ZwOBjAX-1599098962781)(data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQImWNgYGBgAAAABQABh6FO1AAAAABJRU5ErkJggg==)]锁消除

锁消除是一种优化技术： 就是把锁干掉。当Java虚拟机运行时发现有些共享数据不会被线程竞争时就可以进行锁消除。

那如何判断共享数据不会被线程竞争？

利用逃逸分析技术：分析对象的作用域，如果对象在A方法中定义后，被作为参数传递到B方法中，则称为方法逃逸；如果被其他线程访问，则称为线程逃逸。

在堆上的某个数据不会逃逸出去被其他线程访问到，就可以把它当作栈上数据对待，认为它是线程私有的，同步加锁就不需要了。

19、synchronized

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gxAvnh1P-1599098962782)(data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQImWNgYGBgAAAABQABh6FO1AAAAABJRU5ErkJggg==)]synchronized

synchronized是Java中的关键字：用来修饰方法、对象实例。属于独占锁、悲观锁、可重入锁、非公平锁。

  • 1.作用于实例方法时，锁住的是对象的实例(this)；
  • 2.当作用于静态方法时，锁住的是 Class类，相当于类的一个全局锁， 会锁所有调用该方法的线程；
  • 3.synchronized 作用于一个非 NULL的对象实例时，锁住的是所有以该对象为锁的代码块。它有多个队列，当多个线程一起访问某个对象监视器的时候，对象监视器会将这些线程存储在不同的容器中。

每个对象都有个 monitor 对象， 加锁就是在竞争 monitor 对象，代码块加锁是在代码块前后分别加上 monitorenter 和 monitorexit 指令来实现的，方法加锁是通过一个标记位来判断的。

20、Lock和synchronized的区别

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ryRn9OyO-1599098962784)(data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQImWNgYGBgAAAABQABh6FO1AAAAABJRU5ErkJggg==)]自动挡和手动挡的区别

Lock： 是Java中的接口，可重入锁、悲观锁、独占锁、互斥锁、同步锁。

  • 1.Lock需要手动获取锁和释放锁。就好比自动挡和手动挡的区别
  • 2.Lock 是一个接口，而 synchronized 是 Java 中的关键字， synchronized 是内置的语言实现。
  • 3.synchronized 在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而 Lock 在发生异常时，如果没有主动通过 unLock()去释放锁，则很可能造成死锁现象，因此使用 Lock 时需要在 finally 块中释放锁。
  • 4.Lock 可以让等待锁的线程响应中断，而 synchronized 却不行，使用 synchronized 时，等待的线程会一直等待下去，不能够响应中断。
  • 5.通过 Lock 可以知道有没有成功获取锁，而 synchronized 却无法办到。
  • 6.Lock 可以通过实现读写锁提高多个线程进行读操作的效率。

synchronized的优势：

  • 足够清晰简单，只需要基础的同步功能时，用synchronized。
  • Lock应该确保在finally块中释放锁。如果使用synchronized，JVM确保即使出现异常，锁也能被自动释放。
  • 使用Lock时，Java虚拟机很难得知哪些锁对象是由特定线程锁持有的。

21、ReentrantLock 和synchronized的区别

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZnirOps5-1599098962785)(data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQImWNgYGBgAAAABQABh6FO1AAAAABJRU5ErkJggg==)]Lock、ReentrantLock、shnchronzied

ReentrantLock是Java中的类 ： 继承了Lock类，可重入锁、悲观锁、独占锁、互斥锁、同步锁。

划重点

相同点：

  • 1.主要解决共享变量如何安全访问的问题
  • 2.都是可重入锁，也叫做递归锁，同一线程可以多次获得同一个锁，
  • 3.保证了线程安全的两大特性：可见性、原子性。

不同点：

  • 1.ReentrantLock 就像手动汽车，需要显示的调用lock和unlock方法， synchronized 隐式获得释放锁。

  • 2.ReentrantLock 可响应中断， synchronized 是不可以响应中断的，ReentrantLock 为处理锁的不可用性提供了更高的灵活性

  • 3.ReentrantLock 是 API 级别的， synchronized 是 JVM 级别的

  • 4.ReentrantLock 可以实现公平锁、非公平锁，默认非公平锁，synchronized 是非公平锁，且不可更改。

  • 5.ReentrantLock 通过 Condition 可以绑定多个条件

  • …

纯个人理解，和资料汇集，如有不对请及时指出

Outstanding_IT
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
详细介绍：多线程高并发
weixin_47043353的博客
11-25 3428
高并发与多线程的关系与区别 liuhuiteng 2019-03-09 21:30:41 13357 收藏 80 分类专栏： Java进阶 文章标签： 高并发 多线程 高并发指标 高并发解决方案 一、什么是高并发 高并发（High Concurrency）是一种系统运行过程中遇到的一种“短时间内遇到大量操作请求”的情况，主要发生在web系统集中大量访问收到大量请求（例如：12306的抢票情况；天猫双十一活动）。该情况的发生会导致系统在这段时间内执行大量操作，例如对资源的请求、数据库的操作等。 二、高并发
TensorFlow-FIFOQueue（使用多线程实现并行输入）
menghaocheng的专栏
03-20 2628
本文涉及TensorFlow的三个组件： FIFOQueue：先入先出队列； QueueRunner：队列管理器； Coordinator：协调器。 它们协同完成了TensorFlow的多线程数据输入。 -------------------------------------------------------------------------------------------- ...
Java高并发8种解决方案，真的很全，亲测有效，嘿嘿嘿
最新发布
PythonAigc的博客
04-28 5721
Java高并发解决方案涉及多个层面，包括设计模式、并发工具类、框架、缓存、数据库优化等。以下是一些常见的Java高并发解决方案及其解决思路、方法和代码示例： 1. 使用线程池 解决思路： 通过线程池来管理线程，避免频繁创建和销毁线程，从而提高系统性能。 解决方法： 使用java.util.concurrent.ExecutorService和java.util.concurrent.Executors来创建线程池。
多线程/多进程写FIFO为原子操作(一次写小于PIPE_BUF内容)
lotus302的专栏
08-17 2354
#include #include #include #include #include #include #include #include #define WRITENUM 4 typedef struct writeattr writeattr; struct writeattr{ int id; int
FIFO和线程的使用
weixin_39162701的博客
06-21 903
做一个类似聊天的工具 第一个程序的代码 #include #include #include #include #include #include #include #include int res, r_fd, s_fd; pthread_t th_r, th_w; int kflag = 0; void *thread_w() { int tmp; char p[1000]; while
Queue - 一种线程安全的FIFO实现
江州司马
06-01 505
<p>Queue - 一种线程安全的FIFO实现</p> Python的Queue模块提供一种适用于多线程编程的FIFO实现。它可用于在生产者(producer)和消费者(consumer)之间线程安全(thread-safe)地传递消息或其它数据，因此多个线程可以共用同一个Queue实例。Queue的大小（元素的个数）可用来限制内存的使用。 Basic FIFO Queue Queue类实现了一个基本的先进先出(FIFO)容器，使用put...
Java_多线程与并发编程总结.doc
04-14
Java多线程与并发编程是Java开发中至关重要的一部分，它涉及到如何高效地利用CPU资源，以实现程序的并行执行。在操作系统层面，多任务和多进程是通过分配不同的内存空间来实现的，而线程则共享同一进程的内存，这...
Netty多线程并发编程
09-14
Netty多线程并发编程是指在Netty框架中使用多线程技术来实现高性能、高并发的网络编程。下面是关于Netty多线程并发编程的知识点总结： 一、 JAVA 内存模型与多线程编程 在Java中，内存模型是指Java虚拟机（JVM）中...
利用curl 多线程 模拟 并发的详解
12-19
总结起来，使用`curl`的多线程功能可以有效地并发处理多个网络请求，通过`curl_multi_init`、`curl_multi_add_handle`、`curl_multi_exec`等函数组合，可以构建出高效的数据抓取或请求系统。同时，通过合理地使用`...
Python多进程并发与多线程并发编程实例总结
12-25
本文实例总结了Python多进程并发与多线程并发。分享给大家供大家参考，具体如下： 这里对python支持的几种并发方式进行简单的总结。 Python支持的并发分为多线程并发与多进程并发（异步IO本文不涉及）。概念上来说，...
【多线程高并发编程】五 线程的生命周期
01-20
听过前面几篇文章的阅读，我们对多线程已经有了大致的了解。世界上的万物都是有规律的，人有生命周期，幼儿期->少年->青年，当然线程也不例外。跟着社长一起来看看线程的生老病死是怎么一回事。 1.
Java高并发解决方案
Javajishumi的博客
02-16 6784
Akka则是一种基于Actor模型的并发框架，可以将程序中的不同部分划分为不同的Actor，并采用消息传递的方式进行通信，以实现并发编程。在实际的应用中，数据库的并发控制也是一种重要的高并发解决方案。（5）缓存技术的应用：缓存技术是一种常见的性能优化手段，可以将热点数据放入缓存中，减少数据库的访问次数，提高系统的响应速度。在高并发环境下，缓存技术的应用可以有效地减少数据库的压力，提高系统的并发性能。（3）MVCC的实现：MVCC是一种比较先进的并发控制技术，可以在不加锁的情况下实现对数据的并发访问。
多线程高并发-线程的五种实现方式
weixin_42145464的博客
02-05 800
以下是从不同方式实现验证线程实现的五种方式。 package com.company; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class ThreadTest01 { public static void main(String[]args) throws Exception{ //第一种：1.编写一个类，继承Thread类，重写run.
【AXI4 verilog】手把手带你撸AXI代码（三、同步fifo设计）
helloworld573的博客
08-30 1906
为了支持AXI的outstanding特性，在设计从机时，需要使用fifo来缓存各通道的指令和数据。次FIFO特性如下：同步fifo，宽度32，深度31，带有空满指示信号，空时禁止读取。满时禁止写入。否则会造成内部指针错误。预读取：读数据时钟裸漏，当读使能有效时。当前数据消失，下一笔数据裸露，如此直到数据取走为止。...............
多线程与高并发（三）
༄༊星河༣
04-27 158
多线程与高并发（三）ReentrantLockReentrantLock vs synchronizedCountDownLatchCyclicBarrierPhaserReadWriteLockSemaphoreExchangerLockSupport ReentrantLock synchronized是可重入锁，ReentrantLock也是可重入锁，reentrantlock用于替代synchronized 由于m1锁定this,只有m1执行完毕的时候,m2才能执行，这里是复习synchronize
支持多线程的FIFO实现
mcupro的专栏
03-23 373
支持多线程的FIFO实现 #include <stdio.h> #include <stdlib.h> #include <errno.h> #include <unistd.h> #include <pthread.h> #include "thread_safe_fifo.h" #define MAX_BIT 8 #define MAX_SIZE (1<<MAX_BIT) #define CH_SIZE 4..
记录第一次参与高并发场景业务
我爱吃土豆
09-02 1185
目录业务场景项目难点1.发券并发问题2.支付宝技术对接3.服务器升级繁琐4.线上并发问题解决方案1.发券并发问题2.redis队列3.线程池异步4.多实例负载均衡项目收获 业务场景 上上周新启动了一个项目，是和支付宝合作的，活动流程大概是这样：支付宝侧会开发一个H5活动——品牌密室，用户可以在支付宝中搜到该活动，然后进行游戏互动，游戏后就可以领取券码，关注并进入生活号中进行券码的查看以及门店核销。 我负责的部分主要是在用户领券并进入生活号的时候，我会收到支付宝的订阅消息请求，其中有支付宝用户id及其他信息，
多线程并发执行及解决方法
little_spice的博客
02-02 4170
用一个案例来说明：假如我们要实现一个售票的小功能，用3个线程售出共2000张票。 初始模型为： package com.test7; public class synchronizedTest { public static void main(String [] args){ TicketWindow tw = new TicketWindow(); ...
第二章：数据结构-queue线程安全的FIFO实现-基本FIFO队列
编程菜鸟iglesias的博客
02-11 795
2.6 queue:线程安全的FIFO实现 queue模块提供了一个适用于多线程编程的先进先出(FIFO,first-in,first-0ut)数据结构，可以用来在生产者和消费者线程之间安全地传递消息或其他数据。它会为调用者处理锁定，使多个线程可以安全而容易地处理同一个Queue实例。Queue的大小（其中包含的元素个数）可能受限，以限制内存使用或处理。 说明：这里的讨论假设你已经了解队列的一般性...
"Java多线程高并发PDF资源与基础概念整理与借鉴
本资源是关于多线程高并发pdf资源的总结。本资源借鉴了进程与线程的基本概念，包括Java多线程入门类和接口、线程组和线程优先级、Java线程的状态及主要转化方法、以及Java线程间的通信。其次，资源涵盖了原理篇，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值