Java中的锁实战

￡神魔★判官ぃ 2021-07-24 13:13 297阅读 0赞

# 一 对某个对象加锁 #

// 锁的是对象，不是代码
    public class T {
        private int count = 10;
        private Object o = new Object();
    
        public void m() {
            // 任何线程要执行下面的代码，必须先拿到 o 的锁，只有拿到 o 这把锁，才能执行下面这段代码。
            // 一旦 A 线程拿到这把锁，B 线程只有等 A 线程执行完，释放了 o 这把锁，B 再获取这把锁，B 线程才能执行。
            synchronized (o) {
                count--;
                System.out.println(Thread.currentThread().getName() + " count = " + count);
            }
        }
    }

# 二 用当前对象当锁 #

public class T {
        private int count = 10;
    
        public void m() {
            // 锁的是 this
            synchronized (this) { // 任何线程要执行下面的代码，必须先拿到 this 的锁，用当前对象当锁
                count--;
                System.out.println(Thread.currentThread().getName() + " count = " + count);
            }
        }
    }

# 三 在方法前加 synchronized #

public class T {
        private int count = 10;
        public synchronized void m() { // 等同于在方法代码执行时加 synchronized(this)
            count--;
            System.out.println(Thread.currentThread().getName() + " count = " + count);
        }
    }

# 四 静态方法前加 synchronized #

public class T {
        private static int count = 10;
        // 锁的是 XX.class
        public synchronized static void m() { // 这里等同于 synchronized(T.class)
            count--;
            System.out.println(Thread.currentThread().getName() + " count = " + count);
        }
    
        public static void mm() {
            synchronized (T.class) { // 这里不能写成 synchronized(this)
                count--;
            }
        }
    }

# 五 synchronized 的小测试 #

## 1 代码 ##

public class T implements Runnable {
        private /*volatile*/ int count = 100;
    
    
        public synchronized void run() { // 必须加 synchronized ，否则两个不同的线程可能会输出相同的值
            count--;
            System.out.println(Thread.currentThread().getName() + " count = " + count);
        }
    
        public static void main(String[] args) {
            T t = new T();
            for (int i = 0; i < 100; i++) {
                new Thread(t, "THREAD" + i).start();
            }
        }
    }

## 2 测试 ##

......
    THREAD32 count = 9
    THREAD68 count = 8
    THREAD69 count = 7
    THREAD82 count = 6
    THREAD55 count = 5
    THREAD59 count = 4
    THREAD66 count = 3
    THREAD62 count = 2
    THREAD63 count = 1
    THREAD47 count = 0

# 六 各个线程对应的锁对象必须相同，否则是锁不住的 #

## 1 代码 ##

public class T implements Runnable {
        private int count = 10;
    
    
        public synchronized void run() {
            count--;
            System.out.println(Thread.currentThread().getName() + " count = " + count);
        }
    
        public static void main(String[] args) {
            for (int i = 0; i < 5; i++) {
                T t = new T(); // 注意：这里5个线程对应T对象是不同的，所以并不能锁住
                new Thread(t, "THREAD" + i).start();
            }
        }
    }

## 2 测试 ##

THREAD1 count = 9
    THREAD2 count = 9
    THREAD0 count = 9
    THREAD4 count = 9
    THREAD3 count = 9

# 七 同步方法和非同步方法同时执行 #

## 1 代码 ##

// 同步方法和非同步方法可以同时调用，是锁不住的
    public class T {
        // 同步方法
        public synchronized void m1() {
            System.out.println(Thread.currentThread().getName() + " m1 start...");
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " m1 end");
        }
    
        // 非同步方法
        public void m2() {
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " m2 ");
        }
    
        public static void main(String[] args) {
            T t = new T();
            new Thread(t::m1, "t1").start();
            new Thread(t::m2, "t2").start();
            
          /*
          lambda 表达式写法
          new Thread(()->t.m1(), "t1").start();
          new Thread(()->t.m2(), "t2").start();
          */
          
          /*
          //1.8 之前的写法
          new Thread(new Runnable() {
    
    
             @Override
             public void run() {
                t.m1();
             }
             
          });
          */
        }
    }

## 2 测试 ##

t1 m1 start...
    t2 m2
    t1 m1 end

# 八 写方法加锁读方法不加锁问题 #

## 1 代码 ##

/**
    * @className: Account
    * @description: 面试题：模拟银行账户
    * 对业务写方法加锁
    * 对业务读方法不加锁
    * 这样实现容易产生脏读问题
    * @date: 2021/6/20
    */
    import java.util.concurrent.TimeUnit;
    
    public class Account {
        String name;
        double balance;
        // 对业务写方法加锁
        public synchronized void set(String name, double balance) {
            this.name = name;
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.balance = balance;
        }
    
        // 对业务读方法不加锁
        public /*synchronized*/ double getBalance(String name) { // 只有在这里加锁，才不会产生脏读问题
            return this.balance;
        }
    
        public static void main(String[] args) {
            Account a = new Account();
            new Thread(() -> a.set("zhangsan", 100.0)).start();
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            System.out.println(a.getBalance("zhangsan"));
    
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(a.getBalance("zhangsan"));
        }
    }

## 2 测试 ##

0.0
    100.0

# 九 可重入锁 #

## 1 代码 ##

/**
    * @className: T
    * @description: 可重入锁
    * 一个同步方法可以调用另外一个同步方法，一个线程已经拥有某个对象的锁，再次申请的时候仍然会得到该对象的锁
    * 也就是说 synchronized 获得的锁是可重入的
    * @date: 2021/6/20
    */
    import java.util.concurrent.TimeUnit;
    
    public class T {
       synchronized void m1() {
          System.out.println("m1 start");
          try {
             TimeUnit.SECONDS.sleep(1);
          } catch (InterruptedException e) {
             e.printStackTrace();
          }
          m2();
          System.out.println("m1 end");
       }
       
       synchronized void m2() {
          try {
             TimeUnit.SECONDS.sleep(2);
          } catch (InterruptedException e) {
             e.printStackTrace();
          }
          System.out.println("m2");
       }
    
       public static void main(String[] args) {
          new T().m1();
       }
    }

## 2 测试 ##

m1 start
    m2
    m1 end

# 十 父子类可重入锁，它们锁的都是 this 对象 #

## 1 代码 ##

/**
    * @className: T
    * @description: 父子类相同方法是可重入加锁
    * @date: 2021/6/20
    */
    import java.util.concurrent.TimeUnit;
    
    public class T {
        // 父类 m 方法是对 TT 对象加锁，是可重入锁
        synchronized void m() {
            System.out.println("m start");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("m end");
        }
    
        public static void main(String[] args) {
            new TT().m();
        }
    }
    
    class TT extends T {
        // 子类 m 方法是对 TT 对象加锁
        @Override
        synchronized void m() {
            System.out.println("child m start");
            super.m();
            System.out.println("child m end");
        }
    }

## 2 测试 ##

child m start
    m start
    m end
    child m end

# 十一 锁和异常 #

## 1 代码 ##

/**
    * 程序在执行过程中，如果出现异常，默认情况锁会被释放
    * 所以，在并发处理的过程中，有异常要多加小心，不然可能会发生不一致的情况。
    * 比如，在一个web app处理过程中，多个servlet线程共同访问同一个资源，这时如果异常处理不合适，
    * 在第一个线程中抛出异常，其他线程就会进入同步代码区，有可能会访问到异常产生时的数据。
    * 因此要非常小心的处理同步业务逻辑中的异常
    */
    import java.util.concurrent.TimeUnit;
    
    public class T {
        int count = 0;
        synchronized void m() {
            System.out.println(Thread.currentThread().getName() + " start");
            while (true) {
                count++;
                System.out.println(Thread.currentThread().getName() + " count = " + count);
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
    
                if (count == 5) {
                    int i = 1 / 0; // 此处抛出异常，锁将被释放，要想不被释放，可以在这里进行catch，然后让循环继续
                    System.out.println(i);
                }
            }
        }
    
        public static void main(String[] args) {
            T t = new T();
            Runnable r = new Runnable() {
                @Override
                public void run() {
                    t.m();
                }
            };
            new Thread(r, "t1").start();
    
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            new Thread(r, "t2").start();
        }
    }

## 2 测试 ##

t1 start
    t1 count = 1
    t1 count = 2
    t1 count = 3
    t1 count = 4
    t1 count = 5
    t2 start
    t2 count = 6
    Exception in thread "t1" java.lang.ArithmeticException: / by zero
        at com.mashibing.juc.c_011.T.m(T.java:27)
        at com.mashibing.juc.c_011.T$1.run(T.java:38)
        at java.lang.Thread.run(Thread.java:748)
    t2 count = 7
    t2 count = 8
    t2 count = 9
    t2 count = 10

# 十二 小结 #

1 JDK 早期的是重量级的，它要到OS底层申请锁。

2 锁升级

当 sync (Object)

第1步：markword 在 Object 记录这个线程 ID ，这个机制是偏向锁。

第2步：如果发生线程争用：升级为自旋锁。

第3步：旋10次以后，升级为重量级锁，到 OS 申请锁。

3 锁的使用场景

执行时间短（加锁代码），线程数少，用自旋锁（占CPU，不占用OS）。

执行时间长，线程数多，用重量级锁。（不占CPU，在等待队列中）

锁只能升级，不能降级。

4 synchronized(Object)