1、Lock

  • Lock类同样可达到synchronized效果，且在使用上比synchronized更加灵活
  • Lock lock = new ReentrantLock();
  • 加锁：lock.lock();
  • 解锁：lock.unlock(); ``` public class Main { public static void main(String[] args) {
  1.     MyRunnable runnable = new MyRunnable();
  2.     new Thread(runnable, "SyncThread1").start();
  3.     new Thread(runnable, "SyncThread2").start();
  5.     /**
  6.      SyncThread1:0
  7.      SyncThread1:1
  8.      SyncThread1:2
  9.      SyncThread1:3
  10.      SyncThread1:4
  11.      SyncThread2:5
  12.      SyncThread2:6
  13.      SyncThread2:7
  14.      SyncThread2:8
  15.      SyncThread2:9
  16.      */
  17. }
  19. static class MyRunnable implements Runnable {
  21.     public static int count;
  23.     private Lock lock = new ReentrantLock();
  25.     public MyRunnable() {
  26.         count = 0;
  27.     }
  29.     public void run() {
  30.         // 此处锁的是MyRunnable对象
  31.         lock.lock();
  33.         try {
  34.             for (int i = 0; i < 5; i++) {
  35.                 try {
  36.                     System.out.println(Thread.currentThread().getName() + ":" + (count++));
  37.                     Thread.sleep(100);
  38.                 } catch (InterruptedException e) {
  39.                     e.printStackTrace();
  40.                 }
  41.             }
  42.         } finally {
  43.             lock.unlock();
  44.         }
  47.     }
  48. }

} ```