Java并发编程之 locks

于 2021-10-02 08:57:49 发布
阅读量862 收藏
点赞数
分类专栏： Java 文章标签： java lock 锁 并发 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43613793/article/details/120569489
版权

文章目录


锁是用来控制多个线程访问共享资源的方式，一般来说，一个锁能够防止多个线程同时访问共享资源（但是有些锁可以允许多个线程并发的访问共享资源，比如读写锁）。在Lock接口出现之前，Java程序是靠synchronized关键字实现锁功能的，而Java SE 5之后，并发包中新增了Lock接口（以及相关实现类）用来实现锁功能，它提供了与synchronized关键字类似的同步功能，只是在使用时需要显式地获取和释放锁。虽然它缺少了（通过synchronized块或者方法所提供的）隐式获取释放锁的便捷性，但是却拥有了锁获取与释放的可操作性、可中断的获取锁以及超时获取锁等多种synchronized关键字所不具备的同步特性。

使用synchronized关键字将会隐式地获取锁，但是它将锁的获取和释放固化了，也就是先获取再释放。虽然这种方式简化了同步的管理，但是扩展性没有显示的锁获取和释放来的好。

锁的使用方式

lock.lock();
try{
} finally{
    lock.unlock();
}

在finally块中释放锁，目的是保证在获取到锁之后，最终能够被释放。

不要将获取锁的过程写在try块中，因为如果在获取锁（自定义锁的实现）时发生了异常，异常抛出的同时，也会导致锁无故释放。

可重入锁ReentrantLock

可重入锁，顾名思义，就是支持重进入的锁。它表示该锁能够支持一个线程对资源的重复加锁。除此之外，该锁的还支持获取锁时的公平和非公平性选择。

而synchronized关键字隐式的支持重进入，比如一个synchronized修饰的递归方法，在方法执行时，执行线程在获取了锁之后仍能连续多次地获得该锁。

ReentrantLock虽然没能像synchronized关键字一样支持隐式的重进入，但是在调用lock()方法时，已经获取到锁的线程，能够再次调用lock()方法获取锁而不被阻塞。

ReentrantLock提供了一个构造函数，能够控制锁是否是公平的：

public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

如何实现可重入

ReentrantLock是通过组合自定义同步器（AQS）来实现锁的获取与释放。

已获得锁的线程重新获取锁

以非公平性（默认的）实现为例：

final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

通过判断当前线程是否为获取锁的线程来决定获取操作是否成功，如果是获取锁的线程再次请求，则将同步状态值进行增加并返回true，表示获取同步状态成功。

锁的最终释放

成功获取锁的线程再次获取锁，只是增加了同步状态值，这也就要求ReentrantLock在释放同步状态时减少同步状态值：

protected final boolean tryRelease(int releases) {
    int c = getState() - releases;
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
    }
    setState(c);
    return free;
}

如果该锁被获取了n次，那么前(n-1)次tryRelease(int releases)方法必须返回false，而只有同步状态完全释放了，才能返回true。可以看到，该方法将同步状态是否为0作为最终释放的条件，当同步状态为0时，将占有线程设置为null，并返回true，表示释放成功。

公平与非公平获取锁的区别

公平方式获取锁：

protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (!hasQueuedPredecessors() &&
            compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

public final boolean hasQueuedPredecessors() {
    Node t = tail; 
    Node h = head;
    Node s;
    return h != t && ((s = h.next) == null || s.thread != Thread.currentThread());
}

他们获取锁的方式都是：首先判断state是否为0，如果为0，说明这个锁还没有被线程占有，那么就CAS将state的值加一（compareAndSetState(0, acquires)），然后将该线程设置为具有这把锁的访问权限的线程（setExclusiveOwnerThread(current)）；如果state不等于0，说明这把锁已经被某个线程对象持有了，接下来判断想要获取这把锁的线程是不是已经拥有这把锁的线程（判断重入），如果是的话，就将state的值用CAS的方式加一，并且返回true，表示重入获取锁成功。否则直接返回false，表示获取锁失败。

公平方式获取锁tryAcquire(int acquires)与非公平方式获取锁nonfairTryAcquire(int acquires)的唯一的不同点就是当state为0即这个锁还没有被线程占有时，会先调用hasQueuedPredecessors()方法判断加入了同步队列中当前节点是否有前驱节点，如果该方法返回true，则表示有线程比当前线程更早地请求获取锁，因此需要等待前驱线程获取并释放锁之后才能继续获取锁。

可重入读写锁ReentrantReadWriteLock

ReentrantLock和synchronized都是排他锁，这些锁在同一时刻只允许一个线程进行访问，而读写锁在同一时刻可以允许多个读线程访问，但是在写线程访问时，所有的读线程和其他写线程均被阻塞。读写锁维护了一对锁，一个读锁和一个写锁，通过分离读锁和写锁，使得并发性相比一般的排他锁有了很大提升。

ReentrantReadWriteLock实现了ReadWriteLock接口，ReadWriteLock仅定义了获取读锁和写锁的两个方法，即readLock()方法和writeLock()方法；而ReentrantReadWriteLock除了接口方法之外，还提供了一些便于外界监控其
内部工作状态的方法：
在这里插入图片描述
ReentrantReadWriteLock有五个内部类，Sync继承自AQS、NonfairSync和FairSync继承自Sync类（通过构造函数传入的布尔值决定要构造哪一种Sync实例）；ReadLock和WriteLock实现了Lock接口：
在这里插入图片描述

读写状态的设计

读锁ReadLock是共享锁：

public void lock() {
    sync.acquireShared(1);
}

写锁WriteLock是独占锁：

public void lock() {
    sync.acquire(1);
}

但是一个AQS对象只有一个state，想要表示两种不同的状态，就需要使用“按位切割”的方法，将整型的state的二进制位数切分为两部分，高16位表示读，低16位表示写（比如这张图就说明一个线程已经获取了写锁，且重进入了两次，同时也连续获取了两次读锁）：
在这里插入图片描述
假设当前同步状态值为c

获取写状态（获取写锁数量exclusiveCount）： c & ((1 << 16) - 1) (0x0000ffff/65535)（将高16位全部抹去）

static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;
static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }

获取读状态（获取读锁数量sharedCount）： c >>> 16（无符号右移16位）

static final int SHARED_SHIFT   = 16;
static int sharedCount(int c)    { return c >>> SHARED_SHIFT; }

写状态加一： c + 1

compareAndSetState(c, c + 1)

读状态加一： c +（1<<16）

static final int SHARED_SHIFT   = 16;
static final int SHARED_UNIT    = (1 << SHARED_SHIFT);
compareAndSetState(c, c + SHARED_UNIT)

c不等于0时，当写状态等于0时，则读状态一定大于0，即读锁已被获取。

写锁的获取与释放

写锁是一个支持重进入的排它锁。如果当前线程已经获取了写锁，则增加写状态。如果当前线程在获取写锁时，读锁已经被获取（读状态不为0）或者该线程不是已经获取写锁的线程，则当前线程进入等待状态。

获取

写锁的获取由tryAcquire()实现：

protected final boolean tryAcquire(int acquires) {
    Thread current = Thread.currentThread();
    int c = getState();
    //写线程数量（即获取独占锁的重入数）
    int w = exclusiveCount(c);
    //当前同步状态state != 0，说明已经有其他线程获取了读锁或写锁
    if (c != 0) {
        //总锁数量不为0，但写锁数量为0，说明读锁数量不为0，返回false
        if (w == 0 || current != getExclusiveOwnerThread())
            return false;
        if (w + exclusiveCount(acquires) > MAX_COUNT)
            throw new Error("Maximum lock count exceeded");
        setState(c + acquires);
        return true;
    }
    if (writerShouldBlock() ||
        !compareAndSetState(c, c + acquires))
        return false;
    setExclusiveOwnerThread(current);
    return true;
}

该方法除了重入条件（当前线程为获取了写锁的线程）之外，增加了一个读锁是否存在的判断。如果存在读锁，则写锁不能被获取。原因在于：读写锁要确保写锁的操作对读锁可见。如果允许读锁在已被获取的情况下对写锁的获取，那么正在运行的其他读线程就无法感知到当前写线程的操作。因此，只有等待其他读线程都释放了读锁，写锁才能被当前线程获取。而写锁一旦被获取，则其他读写线程的后续访问均被阻塞。

释放

写锁的释放与ReentrantLock的释放过程基本类似，每次释放均减少写状态，当写状态为0时表示写锁已被释放，从而等待的读写线程能够继续访问读写锁，同时前次写线程的修改对后续读写线程可见。

protected final boolean tryRelease(int releases) {
    //若锁的持有者不是当前线程，抛出异常
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    //写锁的新线程数
    int nextc = getState() - releases;
    //如果独占模式重入数为0了，说明独占模式被释放
    boolean free = exclusiveCount(nextc) == 0;
    if (free)
        //若写锁的新线程数为0，则将锁的持有者设置为null
        setExclusiveOwnerThread(null);
    //设置写锁的新线程数
    //不管独占模式是否被释放，更新独占重入数
    setState(nextc);
    return free;
}

读锁的获取与释放

获取

读锁是一个支持重进入的共享锁，它能够被多个线程同时获取，在没有其他写线程访问（或者写状态为0）时，读锁总会被成功地获取，而所做的也只是增加读状态。如果当前线程已经获取了读锁，则增加读状态。如果当前线程在获取读锁时，写锁已被其他线程获取，则进入等待状态。

protected final int tryAcquireShared (int unused){
    for (;;) {
        int c = getState();
        int nextc = c + (1 << 16);
        if (nextc < c)
            throw new Error("Maximum lock count exceeded");
        if (exclusiveCount(c) != 0 && owner != Thread.currentThread())
            return -1;
        if (compareAndSetState(c, nextc))
            return 1;
    }
}

如果其他线程已经获取了写锁（exclusiveCount(c) != 0），则当前线程获取读锁失败，进入等待状态（返回-1）。如果当前线程获取了写锁或者写锁未被获取，则当前线程（线程安全，依靠CAS保证）增加读状态，成功获取读锁（返回1）。

释放

读锁的每次释放（线程安全的，可能有多个读线程同时释放读锁）均减少读状态，减少的值是（1<<16）。

static final int SHARED_SHIFT = 16;
static final int SHARED_UNIT = (1 << SHARED_SHIFT);

for (;;) {
    int c = getState();
    int nextc = c - SHARED_UNIT;
    if (compareAndSetState(c, nextc))
        return nextc == 0;
}

锁降级

锁降级指的是写锁降级成为读锁。如果当前线程拥有写锁，然后将其释放，最后再获取读锁，这种分段完成的过程不能称之为锁降级。锁降级是指在已获取一把写锁的前提下，再获取到读锁，随后释放先前拥有的写锁的过程。

ReentrantReadWriteLock总结

  • 在线程持有读锁的情况下，该线程不能取得写锁(因为获取写锁的时候，如果发现当前的读锁被占用，就马上获取失败，不管读锁是不是被当前线程持有)
  • 在线程持有写锁的情况下，该线程可以继续获取读锁（获取读锁时如果发现写锁被占用，只有写锁没有被当前线程占用的情况才会获取失败）
  • 一个线程要想同时持有写锁和读锁，必须先获取写锁再获取读锁
  • 写锁可以“降级”为读锁。对于获得写锁的线程，它一定独占了读写锁，因此可以继续让它获取读锁，当它同时获取了写锁和读锁后，还可以先释放写锁继续持有读锁，这样一个写锁就“降级”为了读锁
  • 读锁不能“升级”为写锁。当线程获取读锁的时候，可能有其他线程同时也在持有读锁，因此不能把获取读锁的线程“升级”为写锁

LockSupport

LockSupport是一个编程工具类，主要是为了阻塞和唤醒线程用的。

它的内部其实两类主要的方法：park（停车阻塞线程）和unpark（启动唤醒线程）。他们也都是调用的UnSafe类的park和unpark方法。

特点

  1. 释放锁方法unpark()可以优先于获取锁park()方法调用：
    在这里插入图片描述

  2. 释放锁unpark()可以多次调用
    在这里插入图片描述

  3. LockSupport锁是不可重入的，他不像synchronized那样可重入是通过对ObjectWaiter的_count进行加减操作，也不像ReentrantLock那样可重入是通过对AQS的state进行加减操作，他只有一个“许可证”，这个许可证如果被一个线程占有了，不但其他线程拿不到，即便是已拥有“许可证”的线程想要重新获取都是不可以的，只有等该线程释放掉“许可证”后才可以重新获取“许可证”。

park/unpark与wait/notify的区别

  1. wait()和notify()都是Object中的方法,在调用这两个方法前必须先获得锁对象，但是park()不需要获取某个对象的锁就可以锁住线程。即LockSupport不需要在同步代码块里 。所以线程间也不需要维护一个共享的同步对象了，实现了线程间的解耦。
  2. notify()只能随机选择一个线程唤醒，无法唤醒指定的线程，unpark()却可以唤醒一个指定的线程。

写一段例子代码，线程A执行一段业务逻辑后调用wait阻塞住自己。主线程调用notify方法唤醒线程A，线程A然后打印自己执行的结果。

public class Main {
    public static void main(String[] args) {
        final Object lock = new Object();
        Thread A = new Thread(() -> {
            int sum = 0;
            for (int i = 0; i < 10; i++) {
                sum += i;
            }
            try {
                lock.wait();
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(sum);
        });
        A.start();
        Thread.sleep(1000);
        lock.notify();
    }
}

这段代码会报非法监视器异常IllegalMonitorStateException：在这里插入图片描述
因为wait()、notify()/notifyAll()方法只能在同步代码块中使用：

public class Main {
    public static void main(String[] args) {
        final Object lock = new Object();
        Thread A = new Thread(() -> {
            int sum = 0;
            for (int i = 0; i < 10; i++) {
                sum += i;
            }
            try {
                synchronized (lock) {
                    lock.wait();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(sum);
        });
        A.start();
        Thread.sleep(1000);
        synchronized (lock) {
            lock.notify();
        }
    }
}

使用synchronized给lock对象上锁后再调用wait()/notify()方法就不会报错了。

使用LockSupport也可以实现：

public class Main {
    public static void main(String[] args) {
        Thread A = new Thread(() -> {
            int sum = 0;
            for (int i = 0; i < 10; i++) {
                sum += i;
            }
            LockSupport.park();
            System.out.println(sum);
        });
        A.start();
        Thread.sleep(1000);
        LockSupport.unpark(A);
    }
}

对于wait()/notify()而言，线程A启动后需要调用Thread.sleep()方法确保线程A执行完毕进入wait状态，如果没有这句代码，很有可能导致线程A还没有执行完累加操作，就已经调用了外面的notify()方法，即在wait()方法之前调用notify()方法，导致线程永远不会被唤醒：

public class Main {
    public static void main(String[] args) {
        final Object lock = new Object();
        Thread A = new Thread(() -> {
            int sum = 0;
            for (int i = 0; i < 10; i++) {
                sum += i;
            }
            try {
                synchronized (lock) {
                    lock.wait();
                    System.out.println("wait");
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(sum);
        });
        A.start();
        //Thread.sleep(1000);
        synchronized (lock) {
            lock.notify();
            System.out.println("notify");
        }
    }
}

在这里插入图片描述
而使用LockSupport则永远不会产生类似问题：

public class Main {
    public static void main(String[] args){
        Thread A = new Thread(() -> {
            int sum = 0;
            for (int i = 0; i < 10; i++) {
                sum += i;
            }
            LockSupport.park();
            System.out.println(sum);
        });
        A.start();
        //Thread.sleep(1000);
        LockSupport.unpark(A);
    }
}

Condition接口

任意一个Java对象，都拥有一组监视器方法（定义在java.lang.Object上），主要包括wait()、wait(long timeout)、notify()以及notifyAll()方法，这些方法与synchronized同步关键字配合，可以实现等待/通知模式。Condition接口也提供了类似Object的监视器方法：
在这里插入图片描述
Condition定义了等待/通知两种类型的方法，当前线程调用这些方法时，需要提前获取到Condition对象关联的锁。Condition对象是由Lock对象（调用Lock对象的newCondition()方法）创建出来的，换句话说，Condition是依赖Lock对象的：

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

ConditionObject

ConditionObject是同步器AbstractQueuedSynchronizer的内部类，实现了Condition接口。每个Condition对象都包含着一个队列（以下称为等待队列），该队列是Condition对象实现等待/通知功能的关键。

AQS同步队列和Condition等待队列

每个ConditionObject对象都包含一个等待队列，ConditionObject对象拥有首节点（firstWaiter）和尾节点（lastWaiter）。等待队列是一个FIFO的队列，在队列中的每个节点（AbstractQueuedSynchronizer.Node）都包含了一个线程引用，该线程就是在ConditionObject对象上等待的线程，如果一个线程调用了它的await()方法，那么该线程将会释放锁、构造成节点加入等待队列并进入等待状态（addConditionWaiter()）：
在这里插入图片描述
ConditionObject对象拥有首尾节点的引用，而新增节点只需要将原有的尾节点nextWaiter指向它，并且更新尾节点即可。上述节点引用更新的过程并没有使用CAS保证，原因在于调用await()方法的线程必定是获取了锁的线程，也就是说该过程是由锁来保证线程安全的：

private Node addConditionWaiter() {
    Node t = lastWaiter;
    if (t != null && t.waitStatus != Node.CONDITION) {
        unlinkCancelledWaiters();
        t = lastWaiter;
    }
    Node node = new Node(Thread.currentThread(), Node.CONDITION);
    if (t == null)
        firstWaiter = node;
    else
        t.nextWaiter = node;
    lastWaiter = node;
    return node;
}

在Object的监视器模型上，一个对象拥有一个同步队列和等待队列，而并发包中的Lock对象（更确切地说是同步器）拥有一个同步队列和多个等待队列（一个Lock对象可以调用多次newCondition()方法获得多个Condition对象）：
在这里插入图片描述

等待

调用ConditionObject对象的await()方法（或者以await开头的方法），会使当前线程进入等待队列并释放锁，同时线程状态变为等待状态。当从await()方法返回时，当前线程一定获取了ConditionObject对象相关联的锁。

如果从队列（同步队列和等待队列）的角度看await()方法，调用await()方法时相当于将同步队列的首节点（获取了锁的节点）移动到等待队列中（添加为等待队列的尾结点）：

public final void await() throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    //当前线程加入等待队列
    Node node = addConditionWaiter();
    //释放同步状态（释放锁）
    int savedState = fullyRelease(node);
    int interruptMode = 0;
    while (!isOnSyncQueue(node)) {
        LockSupport.park(this);
        if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
            break;
    }
    if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
        interruptMode = REINTERRUPT;
    if (node.nextWaiter != null)
        unlinkCancelledWaiters();
    if (interruptMode != 0)
        reportInterruptAfterWait(interruptMode);
}

调用await()的线程成功获取了锁的线程，也就是同步队列中的首节点，该方法会将当前线程构造成节点并加入等待队列中，然后释放同步状态，唤醒同步队列中的后继节点，然后当前线程会进入等待状态。
在这里插入图片描述
当等待队列中的节点被唤醒，则唤醒节点的线程开始尝试获取同步状态。如果不是通过其他线程调用signal()方法唤醒，而是对等待线程进行中断，则会抛出InterruptedException。

唤醒

调用await()方法时相当于将等待队列的首节点（获取了锁的节点）移动到同步队列中（添加为同步队列的尾结点）并唤醒：

public final void signal() {
    //当前线程必须是获取了锁的线程
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    Node first = firstWaiter;
    if (first != null)
        doSignal(first);
}

private void doSignal(Node first) {
    do {
        if ( (firstWaiter = first.nextWaiter) == null)
            lastWaiter = null;
        first.nextWaiter = null;
    } while (!transferForSignal(first) &&
             (first = firstWaiter) != null);
}

final boolean transferForSignal(Node node) {
    if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
        return false;
    //将等待队列的头结点添加到同步队列（作为同步队列的尾结点）
    Node p = enq(node);
    int ws = p.waitStatus;
    if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
        //唤醒刚刚从等待队列加入到同步队列的结点
        LockSupport.unpark(node.thread);
    return true;
}

在这里插入图片描述
signalAll()方法相当于对等待队列中的每个节点均执行一次signal()方法，效果就是将等待队列中所有节点全部移动到同步队列中，并唤醒每个节点的线程。

philpy_used
关注
专栏目录
Java并发基础(八)-locks包
_StriveG的专栏
10-07 1700
1. 前言Java锁的种类 java中的锁种类是真的多。而locks包下也有一些。包结构如下： AbstractOwnableSynchronizer 一个线程拥有的同步器，这个类提供了创建锁和相关同步器的基础 AbstractQueuedLongSynchronizer 所有的同步状态都是用long变量来维护的，而不是int，在需要64位的属性来表示状态的时候会很有用 AbstractQueu
《java 并发编程实战高清PDF版》
03-14
在Java并发编程中，多线程是核心概念之一。多线程允许程序同时执行多个任务，从而充分利用系统资源，提高程序性能。然而，多线程编程也带来了同步和竞态条件等问题，这需要开发者具备良好的线程管理和同步机制的知识...
java locks_java中Locks的使用
weixin_36202603的博客
02-16 185
之前文章中我们讲到，java中实现同步的方式是使用synchronized block。在java 5中，Locks被引入了，来提供更加灵活的同步控制。本文将会深入的讲解Lock的使用。Lock和Synchronized Block的区别我们在之前的Synchronized Block的文章中讲到了使用Synchronized来实现java的同步。既然Synchronized Block那么好用，...
java.util.concurrent.locks与synchronized及其异同
t225com
01-11 241
关键字：synchronized、java.util.concurrent.locks.Lock、同步、并发、锁一、【引言】 JDK1.5之前，实现同步主要是使用synchronized，而在JDK1.5中新增了java.util.concurrent包及其两个子包locks和atomic，其中子包locks中定义了系列关于锁的抽象的类。本文主要介绍java.util.concurrent.lo...
Locks in Java
Again的博客
03-06 287
Locks in JavaLocks in JavaA Simple LockLock ReentranceLock FairnessCalling unlock() From a finally-clause Locks in Java 锁也是一种像同步块一样的线程同步机制，但是锁可能比Java的同步块更复杂。 锁（以及其他更高级的同步机制）是使用synchronized块创建的，因此我们不能完...
java locks_【19】Java中的Locks
weixin_33665771的博客
02-16 144
作者： Jakob JenkovLock是一个类似同步代码块(synchronized block)的线程同步机制。同步代码块而言，Lock可以做到更细粒度的控制。 Lock(或者其他高级同步机制)也是基于同步代码块(synchronized block)，所以还不能完全摒弃synchronized关键字。从Java 5开始，java.util.concurrent.locks包提供了几个Lock...
13-Java并发编程学习宝典.zip
06-22
Java并发编程是软件开发中的重要领域，特别是在大型系统和高并发场景中不可或缺。"13-Java并发编程学习宝典.zip" 包含了一系列关于Java并发编程的学习资源，旨在帮助开发者掌握多线程编程的核心技术和最佳实践。以下...
JAVA并发编程实践.pdf+高清版+目录 书籍源码
12-11
《JAVA并发编程实践》这本书是Java开发者深入理解并发编程的重要参考资料。它涵盖了Java并发的核心概念、工具和最佳实践，旨在帮助读者在多线程环境下编写高效、安全的代码。 并发编程是现代软件开发中的关键技能，...
Java并发编程学习笔记
04-11
Java并发编程是Java开发中必不可少的一部分，涉及到多线程、同步机制、线程池以及并发工具类等多个核心知识点。以下是对这些主题的详细说明： 1. **线程安全与锁 Synchronized 底层实现原理**： 线程安全是指在多...
Java并发编程进程和线程之由来Java开发Java经验技
11-22
Java并发编程是Java开发中的重要领域，涉及到进程与线程的概念，这两个概念是理解多任务执行的基础。在现代计算机系统中，进程和线程被广泛用于实现高效的资源管理和任务调度。 **1. 进程** 进程是操作系统分配...
Java并发编程常识-梁飞.rar
06-13
Java并发编程是Java开发中的重要领域，特别是在多核处理器和分布式系统中，高效地利用并发可以极大地提升程序的性能和响应速度。阿里大牛梁飞编写的《Java并发编程常识》PPT，深入浅出地讲解了这个主题，对开发者来...
Java并发编程（一）
最新发布
07-29
Java并发编程是指在单个程序中同时执行多个任务的能力，这通常涉及到线程（Threads）、锁（Locks）以及并发容器（如ConcurrentHashMap）。以下是Java并发编程的一些核心概念： 线程（Thread）：线程是程序执行的...
Java并发编程之显式锁机制详解
08-29
Java并发编程中的显式锁机制是比`synchronized`关键字更为灵活的一种同步控制方式。显式锁允许程序员更精细地控制锁的获取与释放，从而在某些复杂场景下提供更高的性能和更多的功能。本文将深入探讨Java中Lock接口...
Java并发编程与高并发解决方案（高清视频教程）.rar
01-21
Java并发编程是Java开发语言中的一个关键领域，特别是在构建高性能、高并发的后端系统时。Apache作为流行的开源软件框架，提供了许多与并发处理相关的工具和库，使得开发者能够更有效地管理和优化多线程环境。本教程...
java中的Lock锁
热门推荐
纯洁的小魔鬼
07-15 1万+
一. 概述 Lock 是 java.util.concurrent.locks 包 下的接口，Lock 实现提供了比 synchronized 关键字 更广泛的锁操作，它能以更优雅的方式处理线程同步问题。Lock提供了比synchronized更多的功能。 1.Lock和ReadWriteLock是两大锁的根接口，Lock代表实现类是ReentrantLock（可重入锁），ReadWriteLock（读写锁）的代表实现类是ReentrantReadWriteLock。 　2.Lock 接口支...
locks java_Locks in Java
weixin_30278943的博客
02-26 123
A lock is a thread synchronization mechanism like synchronized blocks except locks can be more sophisticated than Java's synchronized blocks. Locks (and other more advanced synchronization mechanisms)...
Java基础——Locks锁机制
HDHunter的专栏
12-03 514
java.util.concurrent.locks 包中，为锁和等待条件提供一个框架的接口和类，它不同于内置同步和监视器。 接口 Lock public interface Lock Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。 锁是控制多个线程对共享资源进行访问的工具。通常，锁提供了对共享资源的独占访问。一次只能
java locks包下提供的锁。
记忆力不好的博客
04-07 2187
Java 并发包concurrent包下主要提供lock和ReadWrite两种接口，提供两种类型的锁。 1.ReentrantLock类 由于ReentrantLock是java.util.concurrent包下提供的一套互斥锁，相比Synchronized，ReentrantLock类提供了一些高级功能，主要有以下3项： 等待可中断 持有锁的线程长期不释放的时候，正在等待的
Java Explicit Locks
ytlcainiao的专栏
04-19 1044
Explicit locking mechanism can be used to coordinate access to shared resources in a multi-threaded environment. The Lock interface, which is declared in the java.util.concurrent.locks package, def
Java并发编程：CountDownLatch深度解析
"闭锁CountDownLatch是Java并发编程中的一个重要工具，常用于协调多个线程间的同步。这个概念在阿里巴巴的编程实践中也有广泛应用。CountDownLatch允许一个或多个线程等待其他线程完成操作，通常用于实现启动信号和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值