多线程锁

常见锁介绍

synchronized锁的八中情况

1. package com.shaonian.juc.more_thread_lock;
3. import java.util.concurrent.TimeUnit;
5. class Phone {
7.     public static synchronized void sendSMS() throws Exception {
8.         //停留4秒
9.         TimeUnit.SECONDS.sleep(4);
10.         System.out.println("------sendSMS");
11.     }
13.     public synchronized void sendEmail() throws Exception {
14.         System.out.println("------sendEmail");
15.     }
17.     public void getHello() {
18.         System.out.println("------getHello");
19.     }
20. }
22. /**
23. * @Description: 8锁
24. *
25. 1 标准访问，先打印短信还是邮件
26. ------sendSMS
27. ------sendEmail
29. 2 停4秒在短信方法内，先打印短信还是邮件
30. ------sendSMS
31. ------sendEmail
33. 3 新增普通的hello方法，是先打短信还是hello
34. ------getHello
35. ------sendSMS
37. 4 现在有两部手机，先打印短信还是邮件
38. ------sendEmail
39. ------sendSMS
41. 5 两个静态同步方法，1部手机，先打印短信还是邮件
42. ------sendSMS
43. ------sendEmail
45. 6 两个静态同步方法，2部手机，先打印短信还是邮件
46. ------sendSMS
47. ------sendEmail
49. 7 1个静态同步方法,1个普通同步方法，1部手机，先打印短信还是邮件
50. ------sendEmail
51. ------sendSMS
53. 8 1个静态同步方法,1个普通同步方法，2部手机，先打印短信还是邮件
54. ------sendEmail
55. ------sendSMS
57. */
59. public class Lock8QuestionBySynchronized {
60.     public static void main(String[] args) throws Exception {
62.         Phone phone = new Phone();
63.         Phone phone2 = new Phone();
65.         new Thread(() -> {
66.             try {
67.                 phone.sendSMS();
68.             } catch (Exception e) {
69.                 e.printStackTrace();
70.             }
71.         }, "AA").start();
73.         Thread.sleep(100);
75.         new Thread(() -> {
76.             try {
77.                 // phone.sendEmail();
78.                 // phone.getHello();
79.                 phone2.sendEmail();
80.             } catch (Exception e) {
81.                 e.printStackTrace();
82.             }
83.         }, "BB").start();
84.     }
85. }

复制代码

代码结果原因分析，见博客中synchronized关键字回顾。
ReentrantLock读写锁分析

1. /**
2.      * Creates an instance of {@code ReentrantLock}.
3.      * This is equivalent to using {@code ReentrantLock(false)}.
4.      */
5.     public ReentrantLock() {
6.         sync = new NonfairSync();//默认是非公平锁
7.     }
9.     /**
10.      * Creates an instance of {@code ReentrantLock} with the
11.      * given fairness policy.
12.      *
13.      * @param fair {@code true} if this lock should use a fair ordering policy
14.      */
15.     public ReentrantLock(boolean fair) {//传入false，定义的就是非公平的读写锁
16.         sync = fair ? new FairSync() : new NonfairSync();
17.     }

复制代码

非公平锁(ReentrantLock实现)

非公平锁是多个线程加锁时直接尝试获取锁，能抢到锁到直接占有锁，抢不到才会到等待队列的队尾等待。确定可能会出现线程饿死现象(锁一直被一个线程持有，某些线程一直拿不到锁)，优点是执行效率高，可以直接获取锁。

1. static final class NonfairSync extends Sync {//ReentrantLock中的静态内部类
2.         private static final long serialVersionUID = 7316153563782823691L;
4. /**
5. * Performs lock.  Try immediate barge, backing up to normal
6. * acquire on failure.
7. */
8.     final void lock() {
9.         if (compareAndSetState(0, 1))
10.             setExclusiveOwnerThread(Thread.currentThread());
11.         else
12.             acquire(1);
13.     }
15.     protected final boolean tryAcquire(int acquires) {
16.         return nonfairTryAcquire(acquires);
17.     }
18. }

复制代码

公平锁(ReentrantLock实现)

公平锁是指多个线程按照申请锁的顺序来获取锁，线程直接进入队列中排队，队列中的第一个线程才能获得锁。保证每个线程都能拿到锁，优点是执行效率比非公平锁低，优点是不会出现线程饿死现象。

1. static final class FairSync extends Sync {
2.     private static final long serialVersionUID = -3000897897090466540L;
4.     final void lock() {
5.         acquire(1);
6.     }
8.     /**
9.      * Fair version of tryAcquire.  Don't grant access unless
10.      * recursive call or no waiters or is first.
11.      */
12.     protected final boolean tryAcquire(int acquires) {
13.         final Thread current = Thread.currentThread();
14.         int c = getState();
15.         if (c == 0) {
16.             if (!hasQueuedPredecessors() &&
17.                 compareAndSetState(0, acquires)) {
18.                 setExclusiveOwnerThread(current);
19.                 return true;
20.             }
21.         }
22.         else if (current == getExclusiveOwnerThread()) {
23.             int nextc = c + acquires;
24.             if (nextc < 0)
25.                 throw new Error("Maximum lock count exceeded");
26.             setState(nextc);
27.             return true;
28.         }
29.         return false;
30.     }
31. }

复制代码

可重入锁(ReentrantLock实现)

synchronized(隐式)和Lock(显式)都是可重入锁，也叫递归锁。特点，类似于，有了第一把锁，此锁内部锁的代码都可以访问。像开了大门，开剩下的门就不用再用钥匙开门了。

1. /**
2. * @author 长名06
3. * @version 1.0
4. * 可重入锁案例
5. */
6. public class ReentrantLockDemo {
8.     private synchronized void add(){
9.         add();
10.     }
13.     public static void main(String[] args) {
15.         //new ReentrantLockDemo().add();//会出现StackOverflowError
17.         Object o = new Object();
19.         new Thread(() -> {
20.             synchronized (o){
21.                 System.out.println(Thread.currentThread().getName() + "外部");
22.                 synchronized (o){
23.                     System.out.println(Thread.currentThread().getName() + "中部");
24.                     synchronized (o){
25.                         System.out.println(Thread.currentThread().getName() + "内部");
26.                     }
27.                 }
28.             }
29.         },"aa").start();
30.         
31.         ReentrantLock lock = new ReentrantLock();
32.         new Thread(() -> {
33.             try{
34.                 lock.lock();
35.                 System.out.println(Thread.currentThread().getName() + "外层操作");
36.                 try{
37.                     lock.lock();
38.                     System.out.println(Thread.currentThread().getName() + "内层操作");
40.                 }finally {
41.                     lock.unlock();
42.                 }
43.             }finally {
44.                 lock.unlock();
45.             }
46.         }).start();
47.      //结果
48.      //Thread-0外层操作
49.      //Thread-0内层操作
50.     }
51. }

复制代码

死锁

基本介绍

死锁，是一种多个线程在执行过程中，因竞争资源时，导致线程互相持有其他线程执行需要的锁，从而引起线程等待的现象。在没有外力的作用下，程序会崩溃。
引起死锁的原因

• 1.系统资源不足。
  
• 2.进程运行顺序不合适。
  
• 3.资源分配不当。
  

1. /**
2. * @author 长名06
3. * @version 1.0
4. * 死锁代码
5. */
6. public class DeadLock {
8.     static Object a = new Object();
9.     static Object b = new Object();
10.     public static void main(String[] args) {
12.         new Thread(() -> {
13.             synchronized (a){
14.                 System.out.println(Thread.currentThread().getName() + "持有锁a，试图后去锁b");
15.                 try {
16.                     TimeUnit.SECONDS.sleep(1);
17.                 } catch (InterruptedException e) {
18.                     e.printStackTrace();
19.                 }
20.                 synchronized (b){
21.                     System.out.println(Thread.currentThread().getName() + "获取锁b");
22.                 }
23.             }
24.         },"a").start();
26.         new Thread(() -> {
27.             synchronized (b){
28.                 System.out.println(Thread.currentThread().getName() + "持有锁b，试图后去锁a");
29.                 try {
30.                     TimeUnit.SECONDS.sleep(1);
31.                 } catch (InterruptedException e) {
32.                     e.printStackTrace();
33.                 }
34.                 synchronized (a){
35.                     System.out.println(Thread.currentThread().getName() + "获取锁a");
36.                 }
37.             }
38.         },"b").start();
39.     }
40. }

复制代码

验证线程一直等待是否是死锁

• 1.jps -l 命令类似linux下的ps - ef 可以查询java的线程
  
  正在执行的死锁代码的进程id
  
• 2.jstack工具(JVM 自带的堆栈工具) jstack 线程id 可以查询对应线程的信息
  执行jstack pid指令
  提示语句中会有 Found 1 deadlock
  

只是为了记录自己的学习历程，且本人水平有限，不对之处，请指正。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！