Shulou(Shulou.com)06/01 Report--

This article mainly introduces the classification of locks in Java and how to achieve the relevant knowledge, the content is detailed and easy to understand, the operation is simple and fast, has a certain reference value, I believe that after reading this Java lock classification and how to achieve the article will have a harvest, let's take a look at it.

Lock and synchronized

A lock is a tool that controls access to shared resources

Lock and synchronized, the two most created locks, can both achieve thread safety, but are quite different in use and functionality

Lock is not a complete replacement for synchronized, but provides advanced features when using synchronized is inappropriate or insufficient to meet the requirements

The most common Lock is the ReentrantLock implementation

Why do you need Lock

Syn is inefficient: locks are rarely released, timeouts cannot be set when trying to acquire a lock, and a thread that is trying to acquire a lock cannot be interrupted

It is not flexible enough, the timing of lock and release is single, and each lock has only a single condition (an object), which may not be enough.

Can't know if the lock was acquired successfully.

Main methods

Lock ()

The most common acquisition lock, the best practice is to release the lock in finally to ensure that the lock will be released in the event of an exception

/ * description: unlike syn, Lock automatically releases locks when an exception occurs * so the best practice is to release locks in finally to ensure that locks are released in the event of an exception * / private static Lock lock = new ReentrantLock (); public static void main (String [] args) {lock.lock () Try {/ / get the resource protected by this lock System.out.println (Thread.currentThread (). GetName () + "start task");} finally {lock.unlock ();}} tryLock (long time,TimeUnit unit) Give up when you time out.

It is used to acquire the lock. If the current lock is not occupied by another thread, true is returned. Otherwise, false is returned, which means that the lock acquisition failed.

/ * description: avoid deadlocks with TryLock * / static class TryLockDeadlock implements Runnable {int flag = 1; static Lock lock1 = new ReentrantLock (); static Lock lock2 = new ReentrantLock (); @ Override public void run () {for (int I = 0; I)

< 100; i++) { if (flag == 1) { try { if (lock1.tryLock(800, TimeUnit.MILLISECONDS)) { try { System.out.println("线程1获取到了锁1"); Thread.sleep(new Random().nextInt(1000)); if (lock2.tryLock(800,TimeUnit.MILLISECONDS)){ try { System.out.println("线程1获取到了锁2"); System.out.println("线程1成功获取到了2把锁"); break; }finally { lock2.unlock(); } }else{ System.out.println("线程1获取锁2失败，已重试"); } } finally { lock1.unlock(); Thread.sleep(new Random().nextInt(1000)); } } else { System.out.println("线程1获取锁1失败，已重试"); } } catch (InterruptedException e) { e.printStackTrace(); } } if (flag == 0) { try { if (lock2.tryLock(3000, TimeUnit.MILLISECONDS)) { try { System.out.println("线程2获取到了锁2"); Thread.sleep(new Random().nextInt(1000)); if (lock1.tryLock(800,TimeUnit.MILLISECONDS)){ try { System.out.println("线程2获取到了锁1"); System.out.println("线程2成功获取到了2把锁"); break; }finally { lock1.unlock(); } }else{ System.out.println("线程2获取锁1失败，已重试"); } } finally { lock2.unlock(); Thread.sleep(new Random().nextInt(1000)); } } else { System.out.println("线程2获取锁2失败，已经重试"); } } catch (InterruptedException e) { e.printStackTrace(); } } } } public static void main(String[] args) { TryLockDeadlock r1 = new TryLockDeadlock(); TryLockDeadlock r2 = new TryLockDeadlock(); r1.flag = 1; r2.flag = 0; new Thread(r1).start(); new Thread(r2).start(); } } 执行结果：线程1获取到了锁1线程2获取到了锁2线程1获取锁2失败，已重试线程2获取到了锁1线程2成功获取到了2把锁线程1获取到了锁1线程1获取到了锁2线程1成功获取到了2把锁lockInterruptibly(); 中断 相当于tryLock(long time,TimeUnit unit) 把超时时间设置为无限，在等待锁的过程中，线程可以被中断 /** * 描述：获取锁的过程中，中断了 */ static class LockInterruptibly implements Runnable { private Lock lock = new ReentrantLock(); @Override public void run() { System.out.println(Thread.currentThread().getName() + "尝试获取锁"); try { lock.lockInterruptibly(); try { System.out.println(Thread.currentThread().getName() + "获取到了锁"); Thread.sleep(5000); } catch (InterruptedException e) { System.out.println(Thread.currentThread().getName() + "睡眠中被中断了"); } finally { lock.unlock(); System.out.println(Thread.currentThread().getName() + "释放了锁"); } } catch (InterruptedException e) { System.out.println(Thread.currentThread().getName() + "等锁期间被中断了"); } } public static void main(String[] args) { LockInterruptibly lockInterruptibly = new LockInterruptibly(); Thread thread0 = new Thread(lockInterruptibly); Thread thread1 = new Thread(lockInterruptibly); thread0.start(); thread1.start(); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } thread0.interrupt(); } } 执行结果：Thread-0尝试获取锁Thread-1尝试获取锁Thread-0获取到了锁Thread-0睡眠中被中断了Thread-0释放了锁Thread-1获取到了锁Thread-1释放了锁Java锁分类： 乐观锁和悲观锁： 乐观锁： 比较乐观，认为自己在处理操作的时候，不会有其它线程来干扰，所以并不会锁住操作对象 在更新的时候，去对比我修改期间的数据有没有被改变过，如没有，就正常的修改数据 如果数据和我一开始拿到的不一样了，说明其他人在这段时间内改过，会选择放弃，报错，重试等策略 乐观锁的实现一般都是利用CAS算法来实现的 劣势： 可能造成ABA问题，就是不知道是不是修改过 使用场景： 适合并发写入少的情况，大部分是读取的场景，不加锁的能让读取的性能大幅提高 悲观锁： 比较悲观，认为如果我不锁住这个资源，别人就会来争抢，就会造成数据结果错误，所以它会锁住操作对象，Java中悲观锁的实现就是syn和Lock相关类 劣势： 阻塞和唤醒带来的性能劣势 如果持有锁的线程被永久阻塞，比如遇到了无限循环，死锁等活跃性问题，那么等待该线程释放锁的那几个线程，永远也得不到执行 优先级反转，优先级低的线程拿到锁不释放或释放的比较慢，就会造成这个问题 使用场景： 适合并发写入多的情况，适用于临界区持锁时间比较长的情况： 临界区有IO操作 临界区代码复杂或者循环量大 临界区竞争非常激烈 可重入锁： 可重入就是说某个线程已经获得某个锁，可以再次获取锁而不会出现死锁 ReentrantLock 和 synchronized 都是可重入锁 // 递归调用演示可重入锁 static class RecursionDemo{ public static ReentrantLock lock = new ReentrantLock(); private static void accessResource(){ lock.lock(); try { System.out.println("已经对资源处理了"); if (lock.getHoldCount() < 5){ System.out.println("已经处理了"+lock.getHoldCount()+"次"); accessResource(); } }finally { lock.unlock(); } } public static void main(String[] args) { new RecursionDemo().accessResource(); } } 执行结果：已经对资源处理了已经处理了1次已经对资源处理了已经处理了2次已经对资源处理了已经处理了3次已经对资源处理了已经处理了4次已经对资源处理了 ReentrantLock的其它方法 isHeldByCurrentThread 可以看出锁是否被当前线程持有 getQueueLength()可以返回当前正在等待这把锁的队列有多长，一般这两个方法是开发和调试时候使用，上线后用到的不多 公平锁和非公平锁 公平指的是按照线程请求的顺序，来分配锁； 非公平指的是，不完全按照请求的顺序，在一定情况下，可以插队 非公平锁可以避免唤醒带来的空档期 /** * 描述：演示公平锁和非公平锁 */class FairLock{ public static void main(String[] args) { PrintQueue printQueue = new PrintQueue(); Thread[] thread = new Thread[10]; for (int i = 0; i < 10; i++) { thread[i] = new Thread(new Job(printQueue)); } for (int i = 0; i < 5; i++) { thread[i].start(); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } } } class Job implements Runnable{ PrintQueue printQueue; public Job(PrintQueue printQueue) { this.printQueue = printQueue; } @Override public void run() { System.out.println(Thread.currentThread().getName()+"开始打印"); printQueue.printJob(new Object()); System.out.println(Thread.currentThread().getName()+"打印完成"); }} class PrintQueue{ // true 公平，false是非公平 private Lock queueLock = new ReentrantLock(true); public void printJob(Object document){ queueLock.lock(); try { int duration = new Random().nextInt(10)+1; System.out.println(Thread.currentThread().getName()+"正在打印，需要"+duration+"秒"); Thread.sleep(duration * 1000); } catch (InterruptedException e) { e.printStackTrace(); } finally { queueLock.unlock(); } queueLock.lock(); try { int duration = new Random().nextInt(10)+1; System.out.println(Thread.currentThread().getName()+"正在打印，需要"+duration+"秒"); Thread.sleep(duration * 1000); } catch (InterruptedException e) { e.printStackTrace(); } finally { queueLock.unlock(); } }} 执行结果：Thread-0开始打印Thread-0正在打印，需要10秒Thread-1开始打印Thread-2开始打印Thread-3开始打印Thread-4开始打印Thread-1正在打印，需要2秒Thread-2正在打印，需要2秒Thread-3正在打印，需要2秒Thread-4正在打印，需要4秒Thread-0正在打印，需要2秒Thread-0打印完成Thread-1正在打印，需要7秒Thread-1打印完成Thread-2正在打印，需要8秒Thread-2打印完成Thread-3正在打印，需要3秒Thread-3打印完成Thread-4正在打印，需要8秒Thread-4打印完成 true改为false演示非公平锁：Lock queueLock = new ReentrantLock(false);执行结果：Thread-0正在打印，需要7秒Thread-1开始打印Thread-2开始打印Thread-3开始打印Thread-4开始打印Thread-0正在打印，需要9秒Thread-0打印完成Thread-1正在打印，需要3秒Thread-1正在打印，需要2秒Thread-1打印完成Thread-2正在打印，需要4秒Thread-2正在打印，需要7秒Thread-2打印完成Thread-3正在打印，需要10秒Thread-3正在打印，需要2秒Thread-3打印完成Thread-4正在打印，需要7秒Thread-4正在打印，需要8秒Thread-4打印完成共享锁和排它锁： 排它锁，又称为独占锁，独享锁 共享锁，又称为读锁，获得共享锁之后，可以查看但无法修改和删除数据，其他线程此时也可以获取到共享锁，也可以查看但无法修改和删除数据 共享锁和排它锁的典型是读写锁 ReentrantReadWriteLock,其中读锁是共享锁，写锁是独享锁 读写锁的作用： 在没有读写锁之前，我们假设使用ReentrantLock，那么虽然我们保证了线程安全，但是也浪费了一定的资源： /** * 描述：演示可以多个一起读，只能一个写 */class CinemaReadWrite{ private static ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock(); private static ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock(); private static ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock(); private static void read(){ readLock.lock(); try { System.out.println(Thread.currentThread().getName() + "得到了读锁，正在读取"); Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } finally { System.out.println(Thread.currentThread().getName() + "释放了读锁"); readLock.unlock(); } } private static void write(){ writeLock.lock(); try { System.out.println(Thread.currentThread().getName() + "得到了写锁，正在写入"); Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } finally { System.out.println(Thread.currentThread().getName() + "释放了写锁"); writeLock.unlock(); } } public static void main(String[] args) { new Thread(()->

Read (), "Thrad1"). Start (); new Thread (()-> read (), "Thrad2"). Start (); new Thread (()-> write (), "Thrad3"). Start (); new Thread (()-> write (), "Thrad4"). Start () }} execution result: Thrad1 got read lock, was reading Thrad2 got read lock, was reading Thrad2 released read lock Thrad1 released read lock Thrad3 got write lock, was writing Thrad3 released write lock Thrad4 got write lock, was writing

Thrad4 releases the write lock for multiple reads at the same time, and there is no thread safety problem

Use the read lock in the place of reading and the write lock in the place of writing, and control flexibly. If there is no write lock, the read is non-blocking, which improves the execution efficiency of the program.

Rules for read-write locks:

Multiple thread values can be applied for read locks.

Either one or more read together, or one write, both will not be applied for at the same time, only one write lock can exist.

How read locks and write locks interact:

Read lock queue jumping strategy:

Fair lock: queue jumping is not allowed.

Unfair lock: the write lock can jump the queue at any time, and the read lock can jump the queue only when the queue header node does not want to obtain the write lock thread.

Spin lock and blocking lock

Let the current thread spin, and if the thread that locked the synchronization resource after the spin is completed has released the lock, then the current thread can obtain the synchronization resource directly without blocking, thus avoiding the overhead of switching threads. This is the spin lock.

Blocking lock is the opposite of spin lock, blocking lock will block the thread directly until it is awakened if it doesn't get the lock.

Spin disadvantages:

If the lock is occupied for a long time, the spinning thread will only waste processor resources.

In the process of spin, cpu is consumed all the time, so although the initial cost of spin lock is lower than that of pessimistic lock, the cost increases linearly with the increase of spin time.

Principle:

The classes under the atmoic package of the Java1.5 version and above of the concurrent framework java.util.concurrent are basically spin-locked implementations.

Implementation of AtomicInteger: the implementation principle of spin lock is that the do-while loop in the source code that calls unsafe for self-increment operation in CAS,AtomicInteger is a spin operation. If you encounter competition from other threads in the process of modification and fail to modify it, it will loop in while until the modification is successful.

/ * description: spin lock demo * / class SpinLock {private AtomicReference sign = new AtomicReference (); public void lock () {Thread currentThread = Thread.currentThread (); while (! sign.compareAndSet (null,currentThread)) {System.out.println ("spin acquisition failed, try again");} public void unLock () {Thread currentThread = Thread.currentThread () Sign.compareAndSet (currentThread,null);} public static void main (String [] args) {SpinLock spinLock = new SpinLock (); Runnable runnable = new Runnable () {@ Override public void run () {System.out.println (Thread.currentThread (). GetName () + "start spin lock"); spinLock.lock () System.out.println (Thread.currentThread (). GetName () + "spin lock acquired"); try {Thread.sleep (1);} catch (InterruptedException e) {e.printStackTrace ();} finally {spinLock.unLock () System.out.println (Thread.currentThread (). GetName () + "spin lock released");}; Thread thread1 = new Thread (runnable); Thread thread2 = new Thread (runnable); thread1.start (); thread2.start () }} execution result: Thread-0 starts to try spin lock Thread-0 to get spin lock Thread-1 starts to try spin lock spin acquisition fails, spin acquisition fails again Failed to try spin acquisition again, Thread-0 released spin lock Thread-1 got spin lock Thread-1 released spin lock

Use the scene:

Spin locks are generally used in multicore servers and are more efficient than blocking locks when the degree of concurrency is not very high.

In addition, the spin lock is suitable for situations where the critical area is relatively short, otherwise it is not appropriate if the critical area is large (once the thread acquires the lock, it will not be released until a long time later).

This is the end of the article on "Classification and implementation of locks in Java". Thank you for reading! I believe you all have a certain understanding of the knowledge of "the classification and implementation of locks in Java". If you want to learn more knowledge, you are welcome to follow the industry information channel.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.