1. Java中常用锁
1.1 乐观锁
乐观锁是一种思想，不是具体的锁。
1.1.1 实现方式
① 数据库中，用version/state 控制
update user set name=mike where version=0
这个修改语句并没有锁，但是每次修改都要比较version的值。只有version为一定值时才能修改，即CAS思想（CompareAndSwap)。
② 在jdk中，原子操作类（AutomicXXX）提供乐观锁。
原子操作类提供了基于CAS的无锁原子操作，用于在多线程环境下高效地进行原子更新，
// 常用函数
int get() // 获取当前值
int getAndIncrement() // 原子性自增（返回旧值）
int incrementAndGet() // 原子性自增（返回新值）
int getAndDecrement() // 原子性自减（返回旧值）
int decrementAndGet() // 原子性自减（返回新值）
int getAndAdd(int delta) // 原子性增加delta（返回旧值）
int addAndGet(int delta) // 原子性增加delta（返回新值）
int getAndSet(int newValue)// 原子性设置为newValue（返回旧值）
boolean compareAndSet(int expect, int update) // CAS操作
1.1.2 jdk中AutomicXXX性能缺点
① 乐观锁是基于CAS实现的,CAS如果在compare时不相等,会无限循环尝试compare (自旋),消耗大量cpu资源. 竞争激烈时,性能下降明显.
② 原子操作类通过函数来实现自增自减等操作,如果需要执行乘除等更复杂的运算操作,比如(i*2+10) 就做不到了.
③ ABA问题: CAS只负责比较和交换, 不记录中间发生过的变换. ABA如果是对于8大基础数据类型没有影响; 如果对于引用原子类AtomicReference,会有影响.
ABA的解决方案: 用AtomicStampedReference类, 该类在compareAndSet函数中加了一个stamp时间戳参数, 只有当时间戳和值都等于期望值时,才会set.
1.2 Lock
在jdk里，Lock是一个接口，有很多实现类，用的最多的一种是ReentrantLock；
ReentrantLock是Java中一个基于AQS实现的可重入的互斥锁；
1.3 Synchronized
1.3.1 Synchronized修饰方法上
synchronized修饰静态方法，任何线程在调用该方法时，需要先获取锁，锁的是该类；
synchronized修饰动态方法，则锁的是调用该方法的实例对象；
1.3.2 Synchronized用在对象上
锁的是该对象；
如果是synchronized(XX.class)，则锁的是该类；
1.3.3 Synchronized中的锁升级
Synchronized锁的状态:
偏向锁(只有一个线程访问时,记录偏向线程id,如果是该id进入可直接获得锁)
轻量级锁(多个线程交替访问,无实际竞争,CAS获取.)
重量级锁(当CAS自选次数超过阈值或有实际竞争时,升级为重量级锁. 依赖操作系统的Mutex实现,阻塞挂起,锁释放后再唤醒)
2. 代码示例
2.1 当不加锁，用多线程模拟减少库存操作时
初始化tickets=6000，然后用100个线程，每个线程减掉600张票，如果不出现线程安全问题，最终tickets应为0；
由于tickets--实际上是三个步骤：获取tickets的值、减一、更新tickets的值；因此，再未做任何加锁操作的情况下，会出现最后tickets>0的情况。
import java.util.concurrent.CountDownLatch;
public class MultiThread {
int tickets = 60000;
public void rushOrder(){
tickets--;
}
public static void main(String[] args) throws InterruptedException {
int threadN = 100;
CountDownLatch countDownLatch = new CountDownLatch(threadN);
MultiThread mt = new MultiThread();
for(int i = 0; i < threadN; i++){
new Thread(()->{
for(int j = 0; j < 600; j++){
mt.rushOrder();
System.out.println(Thread.currentThread().getName() + ": "+ mt.tickets);
}
countDownLatch.countDown();
}).start();
}
countDownLatch.await(); // 等待所有子线程完成
System.out.println(mt.tickets);
}
}
2.2 通过AtomicInteger原子操作类来实现乐观锁
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;
public class MultiThread {
AtomicInteger tickets = new AtomicInteger(60000);
public void rushOrder(){
tickets.decrementAndGet(); // 原子类-1
}
public static void main(String[] args) throws InterruptedException {
int threadN = 100;
CountDownLatch countDownLatch = new CountDownLatch(threadN); // 计数器
MultiThread mt = new MultiThread();
for(int i = 0; i < threadN; i++){
new Thread(()->{
for(int j = 0; j < 600; j++){
mt.rushOrder();
System.out.println(Thread.currentThread().getName() + ": "+ mt.tickets);
}
countDownLatch.countDown(); // 计数器-1
}).start();
}
countDownLatch.await(); // 等待所有子线程完成
System.out.println(mt.tickets);
}
}
2.3 Lock 显示锁
一定要在finally中释放锁，避免异常情况下发生死锁.
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class MultiThread {
int tickets = 60000;
Lock mylock = new ReentrantLock(); // 创建锁
public void rushOrder(){
mylock.lock(); // 加锁
try{
tickets--;
}finally {
mylock.unlock(); // 释放锁
}
}
public static void main(String[] args) throws InterruptedException {
int threadN = 100;
CountDownLatch countDownLatch = new CountDownLatch(threadN); // 计数器
MultiThread mt = new MultiThread();
for(int i = 0; i < threadN; i++){
new Thread(()->{
for(int j = 0; j < 600; j++){
mt.rushOrder();
System.out.println(Thread.currentThread().getName() + ": "+ mt.tickets);
}
countDownLatch.countDown(); // 每执行完一个线程，计数器-1
}).start();
}
countDownLatch.await(); // 当计数器为0时继续执行
System.out.println(mt.tickets);
}
}
2.4 Synchronized方式
2.4.1 给rushOrder方法加锁
用synchronized 修饰rushOrder方法，当线程执行 mt.rushOrder() 时，需要先获取锁，这个锁是加在调用者也就是mt对象实例上的。由于所有线程共用一个mt实例，所以能够保证tickets的线程安全。
import java.util.concurrent.CountDownLatch;
public class MultiThread {
int tickets = 60000;
public synchronized void rushOrder(){
tickets--;
}
public static void main(String[] args) throws InterruptedException {
int threadN = 100;
CountDownLatch countDownLatch = new CountDownLatch(threadN); // 计数器
MultiThread mt = new MultiThread();
for(int i = 0; i < threadN; i++){
new Thread(()->{
for(int j = 0; j < 600; j++){
mt.rushOrder();
System.out.println(Thread.currentThread().getName() + ": "+ mt.tickets);
}
countDownLatch.countDown(); // 每执行完一个线程，计数器-1
}).start();
}
countDownLatch.await(); // 当计数器为0时继续执行
System.out.println(mt.tickets);
}
}
2.4.2 synchronized 给对象加锁
一般会使用给对象加锁的方式，以尽可能地减少加锁的代码行。
给对象加锁，要注意的是加锁的对象是共享的。比如下代码，obj是所有线程共享的对象，因为所有线程都是通过同一个mt调用rushOrder() 函数，obj是mt的成员变量，因此，所有线程的obj对象是同一个，如此，所有线程才能竞争锁。
如果 Object obj = new Object(); 语句写在rushOrder() 函数里面，obj作为局部变量，在栈上存储。每一次函数调用，都会生成一个obj对象，不同的线程的obj对象不是同一个，那就起不到竞争作用，锁会失效。
import java.util.concurrent.CountDownLatch;
public class MultiThread {
int tickets = 60000;
Object obj = new Object(); //只要所有的线程获取的是同一个对象的锁，这个锁就有效
public void rushOrder(){
synchronized (obj){
// 简单一点可以直接synchronized (this)：由mt调用，所以this是mt，所有线程是同一个mt
tickets--;
}
}
public static void main(String[] args) throws InterruptedException {
int threadN = 100;
CountDownLatch countDownLatch = new CountDownLatch(threadN); // 计数器
MultiThread mt = new MultiThread();
for(int i = 0; i < threadN; i++){
new Thread(()->{
for(int j = 0; j < 600; j++){
mt.rushOrder();
System.out.println(Thread.currentThread().getName() + ": "+ mt.tickets);
}
countDownLatch.countDown(); // 每执行完一个线程，计数器-1
}).start();
}
countDownLatch.await(); // 当计数器为0时继续执行
System.out.println(mt.tickets);
}
}
扫一扫
5193
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
