公司做网站推广有没有用,广州十大网站开发公司,视觉传达设计作品集,wordpress主git题目录 1、乐观锁悲观锁
1.1 乐观锁的定义
1.2 乐观锁的实现#xff08;CAS机制#xff09;
1.3 乐观锁存在的问题#xff1a;ABA问题
1.4 悲观锁
2、公平锁非公平锁
3、读写锁
4、独占锁共享锁
5、可重入锁自旋锁 1、乐观锁悲观锁
1.1 乐观…目录 1、乐观锁悲观锁
1.1 乐观锁的定义
1.2 乐观锁的实现CAS机制
1.3 乐观锁存在的问题ABA问题
1.4 悲观锁
2、公平锁非公平锁
3、读写锁
4、独占锁共享锁
5、可重入锁自旋锁 1、乐观锁悲观锁
1.1 乐观锁的定义
乐观锁认为一般情况下不会出现冲突所以只会在更新数据的时候才对冲突进行数据检测如果没有发生冲突则直接修改如果发生冲突则不做任何修改然后把结果返回给用户让用户自行处理。
1.2 乐观锁的实现CAS机制
CASCOMPARE AND SWAP对比替换
V内存中的值
A预期的旧值
B要替换的新值
CAS实现机制比较V和A是否相等相等则将V更改为B否则提示修改失败。核心先比较再替换 CAS实现借助Unsafe类Unsafe类调用操作系统的Atomic::cmpxchg原子性汇编指令
我们一般不用Unsafe类因为其中的方法可以直接对内存进行操作是不安全的。
我们推荐使用Atomicxxx来实现CAS机制保证线程安全。如下
import java.util.concurrent.atomic.AtomicInteger;/*** CAS 使用*/
public class CASDemo1 {private static int number 0;private static AtomicInteger atomicInteger new AtomicInteger(0);private final static int MAX_COUNT 100000;public static void main(String[] args) throws InterruptedException {// Thread t1 new Thread(() - {for (int i 0; i MAX_COUNT; i) {atomicInteger.getAndIncrement(); // i
// number;}});t1.start();// --Thread t2 new Thread(() - {for (int i 0; i MAX_COUNT; i) {atomicInteger.getAndDecrement(); // i--
// number--;}});t2.start();t1.join();t2.join();System.out.println(最终结果 atomicInteger.get());}
}
1.3 乐观锁存在的问题ABA问题 ABA问题代码演示
import java.util.concurrent.atomic.AtomicInteger;/*** CAS ABA 演示*/
public class ABADemo1 {private static AtomicInteger money new AtomicInteger(100);public static void main(String[] args) throws InterruptedException {//第一次点击转账(-50)Thread t1 new Thread(()-{int old_money money.get();try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}money.compareAndSet(old_money,old_money50);});t1.start();//第二次点击转账(-50)[不小心点击的因为第一次点击没有反应所以又点了一次]Thread t2 new Thread(()-{int old_money money.get();money.compareAndSet(old_money,old_money50);});t2.start();//给账户50元Thread t3 new Thread(()-{//执行花费1stry {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}int old_money money.get();money.compareAndSet(old_money,old_money50);});t1.join();t2.join();t3.join();System.out.println(最终账户余额money.get());}
}
ABA解决方案
引入版本号每次操作之后让版本号1执行下一步操作前判断值和版本号如果二者都为true才进行操作。 import java.util.concurrent.atomic.AtomicStampedReference;/*** ABA 问题演示*/
public class ABADemo2 {private static AtomicStampedReferenceInteger money new AtomicStampedReference(100, 0);public static void main(String[] args) throws InterruptedException {// 第 1 次点击转账按钮(-50)Thread t1 new Thread(() - {int old_money money.getReference(); // 先得到余额int version money.getStamp(); // 得到版本号// 执行花费 2stry {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}money.compareAndSet(old_money, old_money - 50, version, version 1);});t1.start();// 第 2 次点击转账按钮(-50)【不小心点击的因为第一次点击之后没反应所以不小心又点了一次】Thread t2 new Thread(() - {int old_money money.getReference(); // 先得到余额int version money.getStamp(); // 得到版本号money.compareAndSet(old_money, old_money - 50,version, version 1);});t2.start();// 给账户 50 元Thread t3 new Thread(() - {// 执行花费 1stry {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}int old_money money.getReference();int version money.getStamp();money.compareAndSet(old_money, old_money 50,version, version 1);});t3.start();t1.join();t2.join();t3.join();System.out.println(最终账号余额 money.getReference());}
}
1.4 悲观锁
定义总是假设最坏的情况每次去拿数据的时候就认为别人会修改所以每次进行访问都要进行上锁这样被人拿数据时就会阻塞直到它拿到锁。
应用synchronized、lock 都是悲观锁 2、公平锁非公平锁
非公平锁抢占式执行有一些先来的任务还在排队刚好释放锁的时候新来了一个任务此时并不会通知任务队列来执行任务而是执行新来的任务。
公平锁所有任务来了之后先排队线程空闲之后去任务队列按顺序执行最早任务。排队做核酸 3、读写锁
读写锁 Readers-Writer Lock顾名思义就是把一把锁分为两个部分读锁和写锁读锁允许多个线程同时获得因为读本身就是线程安全的而写锁是互斥锁不允许多个线程同时获得并且读写也是互斥的。ALL IN ALL :读读不互斥、读写互斥、写写互斥。
JAVA标准库提供了ReentrantReadWriteLock类实现了读写锁
读写锁适合于“频繁读不频繁写”的场景
import java.time.LocalDateTime;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;/*** 演示读写锁的使用*/
public class ReadWriteLockDemo {public static void main(String[] args) {//创建读写锁final ReentrantReadWriteLock readWriteLock new ReentrantReadWriteLock();//创建读锁final ReentrantReadWriteLock.ReadLock readLock readWriteLock.readLock();//创建写锁final ReentrantReadWriteLock.WriteLock writeLock readWriteLock.writeLock();//创建线程池ThreadPoolExecutor threadPool new ThreadPoolExecutor(5,5,0,TimeUnit.SECONDS,new LinkedBlockingQueue());//线程池执行任务1【读操作】threadPool.submit(()-{//加锁操作readLock.lock();try {System.out.println(执行读锁1 LocalDateTime.now());TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();}finally {readLock.unlock();}});//线程池执行任务2【读操作】threadPool.submit(()-{//加锁操作readLock.lock();try {System.out.println(执行读锁2 LocalDateTime.now());TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();}finally {readLock.unlock();}});//线程池执行任务3【写操作】threadPool.submit(()-{//加锁操作writeLock.lock();try {System.out.println(执行写锁1 LocalDateTime.now());TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();}finally {writeLock.unlock();}});//线程池执行任务4【写操作】threadPool.submit(()-{//加锁操作writeLock.lock();try {System.out.println(执行写锁2 LocalDateTime.now());TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();}finally {writeLock.unlock();}});}
}由此可看出读操作是同时进行的而写操作则不能同时操作
4、独占锁共享锁
独占锁任何时候只有一个线程能执行资源操作synchronized、lock
共享锁可以同时被多个线程读取但只能被一个线程修改。比如java中的读写锁。读锁可以同时被多个线程读取而写锁则只能被一个线程修改。
5、可重入锁自旋锁
可重入锁指的是该线程获取了该锁之后可以无限次的进入该锁锁住的代码。
自旋锁是指尝试获取锁的线程不会立即阻塞而是采用循环的方式去尝试获取锁这样的好处是减少线程上下文切换的消耗缺点是循环会消耗CPU。
