公平锁和非公平锁
在并发包ReentrantLock的创建可以指定构造函数的boolean类型来得到公平锁或非公平锁,默认是非公平锁
1 public ReentrantLock(boolean fair) {
2 sync = fair ? new FairSync() : new NonfairSync();
3 }
公平锁
是指多个线程按照申请锁的顺序来获取锁,类似排队打饭,先来后到.
非公平锁
是指多个线程获取锁的顺序并不是按照申请锁的顺序,有可能后申请的线程比新申请的线程优先获得锁,在高并发的情况下,有可能会造成优先级反转或者饥饿现象.
区别
公平锁:就是很共平,在并发环境中,每个线程在获取锁时会先查看此锁维护的等待队列,如果为空,或者当前线程是等待队列的第一个,就占有锁,紑则就会按照FIFO的规则从队列中取到自己
非公平锁:非公平锁比较粗鲁,上来就直接尝试占有锁,如果尝试失败,就再采用类似公平锁那种方式.
题外话
对Java ReentrantLock而言,通过构造函数指定该锁是否是公平锁,默认是非公平锁.非公平锁的有点在于吞吐量比公平锁大.
对于Synchronized而言,也是一种非公平锁.
可重入锁(递归锁)
是什么
指的是同一线程外层函数获得锁之后,内层递归函数人能获取该锁的代码,在同一线程在外层方法获取锁的时候,在进入内层方法会自动获取锁.也即是说,线程可以进入任何一个它已经拥有的锁所同步着的代码块
代码示例
对于synchronized
1package com.atguigu.unit1.unit2;
2
3import java.util.concurrent.locks.Lock;
4import java.util.concurrent.locks.ReentrantLock;
5
6public class LockDemo {
7 public static void main(String[] args) {
8 final Phone phone = new Phone();
9 new Thread(new Runnable() {
10 public void run() {
11 phone.sendMsg();
12 }
13 }).start();
14
15 new Thread(new Runnable() {
16 public void run() {
17 phone.sendMsg();
18 }
19 }).start();
20
21 }
22}/**Output
2311 invoke sendMsg()
2411 invoke sendEmail()
2512 invoke sendMsg()
2612 invoke sendEmail()
27*///~
28
29
30class Phone {
31
32 public synchronized void sendMsg() {
33 System.out.println(Thread.currentThread().getId() + "\tinvoke sendMsg()");
34 sendEmail();
35 }
36
37 public synchronized void sendEmail() {
38 System.out.println(Thread.currentThread().getId() + "\tinvoke sendEmail()");
39 }
40}
对于ReentrantLock
1package com.atguigu.unit1.unit2;
2
3import java.util.concurrent.locks.Lock;
4import java.util.concurrent.locks.ReentrantLock;
5
6public class LockDemo {
7 public static void main(String[] args) {
8 final Phone phone = new Phone();
9 new Thread(new Runnable() {
10 public void run() {
11 phone.sendMsg();
12 }
13 }).start();
14
15 new Thread(new Runnable() {
16 public void run() {
17 phone.sendMsg();
18 }
19 }).start();
20
21 }
22}/**Output
2311 invoke sendMsg()
2411 invoke sendEmail()
2512 invoke sendMsg()
2612 invoke sendEmail()
27*///~
28
29
30class Phone {
31 Lock lock = new ReentrantLock();
32
33 public void sendMsg() {
34 lock.lock();
35 System.out.println(Thread.currentThread().getId() + "\tinvoke sendMsg()");
36 sendEmail();
37 lock.unlock();
38 }
39
40 public void sendEmail() {
41 lock.lock();
42 System.out.println(Thread.currentThread().getId() + "\tinvoke sendEmail()");
43 lock.unlock();
44 }
45
46
47}
自旋锁
是什么
是指尝试获取锁的线程不会立即阻塞,而是采用循环的方式去尝试获取锁,这样的好处是减少线程上下文切换的消耗,缺点是循环会消耗CPU.
代码示例
1package com.atguigu.unit1.unit2;
2
3import java.util.concurrent.atomic.AtomicReference;
4
5public class SpinLock {
6
7 public AtomicReference<Thread> atomicReference = new AtomicReference<Thread>();
8
9 public void myLock() {
10 Thread thread = Thread.currentThread();
11 System.out.println(Thread.currentThread().getName() + "come on");
12 // 不断循环获得锁
13 while (!atomicReference.compareAndSet(null, thread)){
14
15 }
16 }
17
18 // 自定义锁
19 public void myUnLock() {
20 Thread thread = Thread.currentThread();
21 System.out.println(Thread.currentThread().getName() + "invoked myunlock");
22 atomicReference.compareAndSet(thread, null);
23 }
24
25 // 自定义释放锁
26 public static void main(String[] args) {
27 final SpinLock spinLock = new SpinLock();
28 new Thread(new Runnable() {
29 public void run() {
30 spinLock.myLock();
31 System.out.println("I am " + Thread.currentThread().getName());
32 try {
33 Thread.sleep(2000);
34 }catch (Exception e) {
35 e.printStackTrace();
36 }finally {
37 spinLock.myUnLock();
38 }
39 }
40 }).start();
41
42 new Thread(new Runnable() {
43 public void run() {
44 spinLock.myLock();
45 System.out.println("I am " + Thread.currentThread().getName());
46 spinLock.myUnLock();
47 }
48 }).start();
49 }
50
51
52}/**Output
53Thread-0come on
54I am Thread-0
55Thread-1come on
56Thread-0invoked myunlock
57I am Thread-1
58Thread-1invoked myunlock
59*///~
独占锁(写锁)/共享锁(读锁)/互斥锁
读写锁案例
1package com.atguigu.unit1.unit2;
2
3import java.util.HashMap;
4import java.util.Map;
5import java.util.concurrent.locks.ReentrantReadWriteLock;
6
7public class ReadWriteLock {
8 public volatile Map<String, Object> map = new HashMap<String, Object>();
9 ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
10
11 public void put(String key, Object value) {
12 rwLock.writeLock().lock();
13 try {
14 System.out.println(Thread.currentThread().getName()+" 正在写入 " + key);
15 Thread.sleep(2000);
16 map.put(key, value);
17 System.out.println(Thread.currentThread().getName()+ " 写入完成" + key);
18 }catch (Exception e) {
19 e.printStackTrace();
20 }finally {
21 rwLock.writeLock().unlock();
22 }
23
24 }
25
26 public void get(String key) {
27 rwLock.readLock().lock();
28 try {
29 System.out.println(Thread.currentThread().getName() + " 正在读取...");
30 Thread.sleep(2000);
31 Object object = map.get(key);
32 System.out.println(Thread.currentThread().getName() + " 读取完成:" + object);
33 }catch (Exception e) {
34 e.printStackTrace();
35 }finally {
36 rwLock.readLock().unlock();
37 }
38
39 }
40
41 public static void main(String[] args) {
42 final ReadWriteLock readWriteLock = new ReadWriteLock();
43 for (int i = 0; i < 5; i++) {
44 final int input = i;
45 new Thread(new Runnable() {
46 public void run() {
47 readWriteLock.put(input + "" , input + "");
48 }
49 },String.valueOf(i)).start();
50 }
51
52 for (int i = 0; i < 5; i++) {
53 final int output = i;
54 new Thread(new Runnable() {
55 public void run() {
56 readWriteLock.get(output + "");
57 }
58 }, String.valueOf(i)).start();
59 }
60 }
61}/**Output
620 正在写入 0
630 写入完成0
642 正在写入 2
652 写入完成2
661 正在写入 1
671 写入完成1
683 正在写入 3
693 写入完成3
704 正在写入 4
714 写入完成4
721 正在读取...
732 正在读取...
740 正在读取...
753 正在读取...
764 正在读取...
771 读取完成:1
782 读取完成:2
790 读取完成:0
803 读取完成:3
814 读取完成:4
82*///~
由运行结果可以看出,写锁互斥,读锁共享
268
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
