公平和非公平锁公平锁:是指多个线程按照申请的顺序来获取值
非公平锁:是指多个线程获取值的顺序并不是按照申请锁的顺序,有可能后申请的线程比先申请的线程优选获取锁,在高并发的情况下,有可能造成优先反转或者饥饿现象
两者区别:
公平锁:
在并发环境下,每一个线程在获取锁时会先查看此锁维护的等待队列,如果为空,或者当前线程是等待队列的第一个就占有锁,否则就加入等待队列中,以后会按照FIFO的规则获取锁
非公平锁:
比较粗鲁,一上来就尝试占有锁,如果失败再进行排队,也就是采用类似公平锁中方式
并发包中ReentrantLock创建指定构造函数的boolean来得到公平锁或者非公平锁,默认是非公平锁;Synchronized也是一种非公平锁,非公平锁的优点是吞吐量比公平锁大
可重入锁和不可重入锁可重入锁:指的是同一个线程外层函数获得锁之后,内层仍然能获取该锁,在同一个线程在外层方法获取锁的时候,在进入内层方法会自动获取该锁
不可重入锁:所谓不可重入锁,即若当前线程执行某个方法已经获取了该锁,那么在方法中尝试再次获取锁时,就会获取不到被阻塞;
代码实现:
可重入锁:ReentranLock和synchronized都是典型的可重入锁,可重入锁最多的作用就是避免死锁
// synchronizedclass 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 ReenterLockDemo {
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();
}
/**** t1 invoked sendSMS t1线程在外层获取锁的时候* t1 ############ invoked sendEmail t1线程在进入内层方法会自动获取锁* t2 invoked sendSMS* t2 ############ invoked sendEmail**/
}
// ReentranLockclass Phone implements Runnable {
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");
}
Lock lock = new ReentrantLock(false);
@Override
public void run() {
get();
}
public void get() {
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + "\t invoked get()");
set();
} finally {
lock.unlock();
}
}
public void set() {
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + "\t ############ invoked set()");
} finally {
lock.unlock();
}
}
}
public class ReenterLockDemo {
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();
try {
TimeUnit.SECONDS.sleep(1L);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println();
System.out.println();
System.out.println();
System.out.println();
Thread t3 = new Thread(phone,"t3");
Thread t4 = new Thread(phone,"t4");
t3.start();
t4.start();
}
/**** t1 invoked sendSMS t1线程在外层获取锁的时候* t1 ############ invoked sendEmail t1线程在进入内层方法会自动获取锁* t2 invoked sendSMS* t2 ############ invoked sendEmail**/
}
不可重入锁:ReentranLock和synchronized都是典型的可重入锁
独占锁(写锁)/共享锁(读锁)/互斥锁
独占锁:指该锁一次只能被一个线程所持有,对ReentrantLock和Synchronized而言都是独占锁
共享锁:指该锁可以被多个线程所持有,对ReentrantReadWriteLock其读锁是共享锁,其写锁是独占锁
读锁的共享锁可保证并发是非常高效的,读写,写读,写写的过程是互斥的
总结:
多个线程同事读取一个资源类没有问题,所以为了满足并发量,读取共享资源应该同时进行
如果有一个线程想去写共享资源,就不应该再有其他线程对该资源进行读或写
读和读能共存
读和写不能共存
写和写不能共存
案例:
class Mycache{
private volatile Map map = new HashMap<>();
private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
public void put(String key, Object value) {
rwLock.writeLock().lock();
System.out.println(Thread.currentThread().getName() + "\t 正在写入:" + key);
try {
TimeUnit.MILLISECONDS.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
rwLock.writeLock().unlock();
}
System.out.println(Thread.currentThread().getName() + "\t 写入完成:");
}
public void get(String key) {
rwLock.readLock().lock();
try {
System.out.println(Thread.currentThread().getName() + "\t 正在读取:" );
try {
TimeUnit.MILLISECONDS.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "\t 读取完成:"+key);
} finally {
rwLock.readLock().unlock();
}
}
}
public class ReadWriteLockDemo {
public static void main(String[] args) {
Mycache mycache = new Mycache();
for (int i = 1; i <= 5; i++) {
int tempInt = i;
new Thread(() -> {
mycache.put(tempInt + "", tempInt + "");
}, String.valueOf(i)).start();
}
for (int i = 1; i <= 5; i++) {
int tempInt = i;
new Thread(() -> {
mycache.get(tempInt + "");
}, String.valueOf(i)).start();
}
}
}
自旋锁(spnlock):
UnSafe类+CAS思想(自旋)
AtomicInteger
CAS->UnSafe->CAS底层思想->ABA->原子引用更新->如果规避ABA问题
是指尝试获取锁的线程不会立即阻塞,而是采用循环的方式尝试获取锁,这样做的好处是减少线程上下文的切换的消耗,缺点是循环会消耗CPU
如图:
手写一个自旋锁:
public class SpinLockDemo {
// 原子引用线程 AtomicReference atomicReference= new AtomicReference<>();
public void MyLock(){
Thread thread=Thread.currentThread();
System.out.println(Thread.currentThread().getName()+"\t come in ");
while (!atomicReference.compareAndSet(null,thread)){
}
}
public void MyUnLock(){
Thread thread =Thread.currentThread();
System.out.println(Thread.currentThread().getName()+"\t invoked MyUnLock ");
atomicReference.compareAndSet(thread,null);
}
public static void main(String[] args) {
SpinLockDemo spinLockDemo=new SpinLockDemo();
new Thread(()->{
spinLockDemo.MyLock();
try {
TimeUnit.SECONDS.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
spinLockDemo.MyUnLock();
},"AAA").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
spinLockDemo.MyLock();
try {
TimeUnit.SECONDS.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
spinLockDemo.MyUnLock();
},"BBB").start();
}
}