synchronized实现同步的基础：Java中的每一个对象都可以作为锁，3中形式

  • 对于普通同步方法，锁时当前实例对象
  • 对于静态同步方法，锁是当前类的Class对象

  • 对于同步方法块，锁是Synchronized括号里配置的对象

    1、公平锁与非公平锁

  • private Lock lock=new ReentrantLock();//无参构造，默认为false，非公平锁

相当于private Lock lock=new ReentrantLock(false)

  • private Lock lock=new ReentrantLock(true);//有参构造，值为true，公平锁

非公平锁：饿死线程，但是效率相对较高
公平锁：阳光普照，效率相对较低

2、可重入锁

三层用的是同一把锁，所以三层的代码都可被执行。
image.png

2.1、Synchronized实现可重入锁

代码演示：由于最外层，中层和内层用的是同一把锁，所以代码均会被执行。
输出结果：

  • 最外层
  • 中层

  • 内存

    1. public class Demo {
    2.   public static void main(String[] args) {
    4.       Demo demo = new Demo();
    5.       new Thread(()->{
    6.           synchronized (demo){
    7.               System.out.println("最外层");
    8.               synchronized (demo){
    9.                   System.out.println("中层");
    10.                   synchronized (demo){
    11.                       System.out.println("内层");
    12.                   }
    13.               }
    14.           }
    15.       }).start();
    16.   }
    17. }

    由于同步方法上的锁为当前实例对象，所以会不断递归调用，直至栈溢出

    1. public class Demo {
    2.   public synchronized void add(){
    3.       add();
    4.   }
    5.   public static void main(String[] args) {
    7.       Demo demo = new Demo();
    8.       new Thread(()->{
    9.          demo.add;
    10.       }).start();
    11.   }
    12. }

    2.2、Lock实现可重入锁

    注意：上锁与解锁缺一不可，否则其他线程在获取锁的时候，得不到锁会出现死锁的情况。 ```java public class Demo { public static void main(String[] args) {

    1.   Lock lock=new ReentrantLock();
    3.   new Thread(()->{
    4.      try{
    5.          lock.lock();
    6.          System.out.println(Thread.currentThread().getName()+"最外层");
    7.          try {
    8.              lock.lock();
    9.              System.out.println(Thread.currentThread().getName()+"内层");
    10.          }finally {
    11.              lock.unlock();
    12.          }
    13.      }finally {
    14.          lock.unlock();
    15.      }
    16.   },"t1").start();

    } }

  1. <a name="NOw0W"></a>
  2. ## 3、死锁
  4. - 什么是死锁？
  6. 两个或者两个以上的进程在执行过程中，因为争夺资源而造成一种互相等待的现象，如果没有外力干涉，他们无法再执行下去。
  8. - 产生死锁的原因
  10. -系统资源不足<br />-进程运行推进顺序不合适<br />-资源分配不当
  12. - 死锁演示-为了增减概率sleep
  13. ```java
  14. public class DeadLockDemo {
  16.     static Object a = new Object();
  17.     static Object b = new Object();
  19.     public static void main(String[] args) {
  21.         new Thread(() -> {
  22.             synchronized (a) {
  23.                 System.out.println(Thread.currentThread().getName() + "拥有锁a,等待获取锁b");
  25.                 try {
  26.                     TimeUnit.SECONDS.sleep(1);
  27.                 } catch (InterruptedException e) {
  28.                     e.printStackTrace();
  29.                 }
  31.                 synchronized (b) {
  32.                     System.out.println(Thread.currentThread().getName() + "拥有锁b,等待获取锁a");
  33.                 }
  34.             }
  35.         },"A").start();
  37.         new Thread(() -> {
  38.             synchronized (b) {
  39.                 System.out.println(Thread.currentThread().getName() + "拥有锁b,等待获取锁a");
  41.                 try {
  42.                     TimeUnit.SECONDS.sleep(1);
  43.                 } catch (InterruptedException e) {
  44.                     e.printStackTrace();
  45.                 }
  47.                 synchronized (a) {
  48.                     System.out.println(Thread.currentThread().getName() + "拥有锁a,等待获取锁b");
  49.                 }
  50.             }
  51.         },"B").start();
  52.     }
  53. }
  • 验证死锁

1、jps 类似于Linux ps -ef，在jdk的bin安装目录下，环境变量必须配置
2、jstack jvm自带的堆栈跟踪工具

1、演示
第一步 jps -l
第二步 jstack 端口号 此时便会提示是否有死锁