锁¶
1.公平锁/非公平锁¶
1.1 是什么¶
- 公平锁
是指多个线程按照申请锁的顺序来获取锁，类似排队打饭，先来后到；
- 非公平锁
是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取到锁，在高并发情况下，有可能会造成优先级反转或者饥饿现象；
1.2 两者的区别¶
- 并发包中，ReentrantLock的创建可以指定构造函数的boolean类型来得到公平锁和非公平锁，默认是非公平锁；
- 两者的区别：
- 公平锁，就是很公平，在并发环境中，每个线程在获取锁时会先查看此锁维护的等待队列，如果为空，或者当前线程是等待队列的第一个，就占有锁，否则就会加入到等待队列中，以后会按照FIFO的规则从队列中取到自己；
- 非公平锁：非公平锁相对比较粗鲁，上来就直接尝试占有锁，如果失败了，就在采用类似公平锁那种方式；
ReentrantLock，通过构造函数指定是公平锁还是非公平锁；
Synchronized，是一种非公平锁；
- 非公平锁的吞吐量较大
2.可重入锁¶
2.1 是什么¶
可重入锁（有名递归锁）
指的是同一线程外层函数获得锁之后，内层递归函数仍能获得该锁的代码，在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁；
也就是说，线程可以进入任何一个他已经拥有的锁同步的代码块。
ReentrantLock 和 synchronized 都是可重入锁
- 最大的作用是，防止死锁；
范例：synchronized
package reentrantLock;
class Phone {
public synchronized void sendSMS() throws Exception {
System.out.println(Thread.currentThread().getName() + "\t invoked sendSMS");
sendEmail();
}
public synchronized void sendEmail() throws Exception {
System.out.println(Thread.currentThread().getName() + "\t invoked sendEmail -----");
}
}
public class demo {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(()->{
try {
phone.sendSMS();
} catch (Exception e) {
e.printStackTrace();
}
},"t1").start();
new Thread(()->{
try {
phone.sendSMS();
} catch (Exception e) {
e.printStackTrace();
}
},"t2").start();
}
}
范例：ReentrantLock
package reentrantLock;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class Phone implements Runnable {
private Lock lock = new ReentrantLock();
@Override
public void run() {
get();
}
private void get() {
lock.lock();
try {
System.out.println(Thread.currentThread().getName()+"\t 获取...");
show();
}finally {
lock.unlock();
}
}
void show(){
lock.lock();
try {
System.out.println(Thread.currentThread().getName()+"\t 显示...");
}finally {
lock.unlock();
}
}
}
public class demo {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(phone,"t1").start();
new Thread(phone,"t2").start();
new Thread(phone,"t3").start();
new Thread(phone,"t4").start();
}
}
注意：开启几个锁，就要关闭几个锁；否则线程一致占用资源；
3.自旋锁¶
- 自旋锁
是指尝试获取线程不会立即阻塞，而是**采用循环的方式去尝试获取锁**，这样的好处是减少上下文切换的消耗，缺点是会循环消耗CPU
范例：手写自旋锁
package spinLock;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
/**
* 手写自旋锁
*/
public class demo {
// 原子引用线程
AtomicReference<Thread> atomicReference = new AtomicReference<>();
public void myLock(){
Thread thread = Thread.currentThread();
System.out.println(Thread.currentThread().getName()+"\t come in .");
//如果是空的,就把自己放进去
while (!atomicReference.compareAndSet(null,thread)){
System.out.print(">");
}
System.out.println();
}
public void myUnlock(){
Thread thread = Thread.currentThread();
//用完了,把线程变为空
atomicReference.compareAndSet(thread,null);
System.out.println(Thread.currentThread().getName()+"\t invoked myUnlock");
}
public static void main(String[] args) {
demo demo = new demo();
new Thread(()->{
demo.myLock();
try{
TimeUnit.SECONDS.sleep(5);
}catch (Exception e){}
demo.myUnlock();
},"A").start();
new Thread(()->{
demo.myLock();
demo.myUnlock();
},"B").start();
}
}
运行结果：
B come in .
A come in .
>>>>>>>
B invoked myUnlock
A invoked myUnlock
4.独占锁（写锁）、共享锁（读锁）、互斥锁¶
- 独占锁
该锁只能一次被一个线程所持有。对ReentrantLock 和 Synchronized 而言都是独占锁；
synchronized → ReentrantLock → ReentrantReadWriteLock
- 读写锁
多线程同时度一个资源类没有任何问题，所以为了满足并发量，读取共享资源应该可以同时进行。但是如果有一个线程想去写共享资源，就不应该有其他线程可以对他进行读或者写；
- 读：共存
- 读写：不能共存
- 写：不能共存
范例：自写缓存
```java package readwirtelock;
import java.util.HashMap; import java.util.Map; import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; import java.util.concurrent.locks.ReentrantReadWriteLock;
class MyCache {//资源类
private volatile Map
public Object get(String key) {
readWriteLock.readLock().lock();
Object o = null;
try {
TimeUnit.SECONDS.sleep(2);
o = map.get(key);
System.out.println(Thread.currentThread().getName() + "geting key=" + key + "result=" + o);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
readWriteLock.readLock().unlock();
}
return o;
}
public void put(String key, Object object) {
readWriteLock.writeLock().lock();
try {
System.out.println(Thread.currentThread().getName() + "puting key=" + key);
try {
TimeUnit.SECONDS.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
map.put(key, object);
}catch (Exception e){
}finally {
readWriteLock.writeLock().unlock();
}
}
public void clear() {
System.out.println(Thread.currentThread().getName() + "clear");
map = new HashMap<>();
}
}
public class demo { public static void main(String[] args) { MyCache myCache = new MyCache(); for (int i = 0; i < 5; i++) { final int tempI = i; new Thread(() -> { myCache.put(tempI + "", tempI + ""); }).start(); }
for (int i = 0; i < 5; i++) {
final int tempI = i;
new Thread(() -> {
myCache.get(tempI + "");
}).start();
}
}
} ```