Java的锁

今天练习了Java的多线程，提到多线程就基本就会用到锁

Java通过关键字及几个类实现了锁的机制，这里先介绍下Java都有哪些锁：

 

一、Java实现锁的机制：

Java运行到包含锁的代码时，获取尝试获取对应的锁，如果锁被其他线程占用着，则该线程默认等待，待这个锁得以释放在去获取，进而执行锁中的代码。

注：这里说的尝试获取对应的锁是指当多个线程公用一个锁的时候。

 

二、锁的种类

Java总共就两个锁：对象锁和类锁

 

区别：

具体这里分为了对象锁和类锁，是因为锁作用的范围不同，如果多个线程采用的是对象锁，需要要求他们引用同一个对象实例的锁才起作用，一旦一个线程使用的是不同的对象实例，就不受这个锁的干预了，但是类锁不同，类锁对应的是class对象，这个类的所有实例对应一个class对象，所以他们相当于争抢同一个锁。

 

对象锁：

说到对象锁，需要在这了统一一个认识：Java里的所有代码都是对对象执行的操作

其实每个对象都有一个锁，只不过对于没有加锁的代码而言，他们对这个锁视而不见，因为普通代码的执行根本就不依赖锁。

对象锁的具体表现形式是：

1. 对方法加的锁
   
2. 代码块加的锁

 

对方法加的锁长这样：

 public synchronized void output1() {
     for(int i=0;i<10;i++) {
         System.out.println(Thread.currentThread().getName());
         try {
             Thread.sleep(100);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }
 }

运行结果如下：

Synchronized test
thread1
thread1
thread1
thread1
thread1
thread1
thread1
thread1
thread1
thread1
thread2
thread2
thread2
thread2
thread2
thread2
thread2
thread2
thread2
thread2

 

对代码块加的锁长这样：

 public void output2() {
     for(int i=0;i<1;i++) {
         System.out.println(Thread.currentThread().getName() + "---read");
     }
     synchronized(Synchronized_test.syn) {
         for(int i=0;i<10;i++) {
             System.out.println(Thread.currentThread().getName() + "--- write");
             try {
                 Thread.sleep(100);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }
 }

运行结果如下：

Synchronized test
thread1---read
thread2---read
thread1---write
thread1---write
thread1---write
thread1---write
thread1---write
thread1---write
thread1---write
thread1---write
thread1---write
thread1---write
thread2---write
thread2---write
thread2---write
thread2---write
thread2---write
thread2---write
thread2---write
thread2---write
thread2---write
thread2—write

 

实现原理：

具体的实现方式是，当程序运行到包含锁的代码的时候，不管是方法还是代码块，线程会拿到锁域里的所有对象的锁。如果有方法调用也会递归式的获取。

 

类锁

类锁一半针对静态代码块或者静态方法。例子这里就不写了，就是相当于在上面两个例子前面加个static关键字。

只要是调用这个类的方法，引用类锁的线程争抢的就都是一把锁。

 

 

三、关于锁的关键字：

synchronized  

注：可以指定方法，可以指定代码块

 

四、实现锁的类

1. ReentrantLock

2. Reentrant​ReadWriteLock

 

这两种锁和synchronized关键字的区别：

1. ​当锁被其他线程获取，当前线程可以不必阻塞住。
2. 关键字的方式是由系统自动释放锁，而下面必须要手动操作。

 

ReentranLock的用法

1. 简单的用法如下，功能同关键字synchronized

 @Override
 public void run() {
     lock.lock();
     for(int i=1;i<10;i++) {
         System.out.println(Thread.currentThread().getName());
         try {
             Thread.sleep(100);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
      }
     lock.unlock();
 }

运行结果如下：

lock test
Thread-0
Thread-0
Thread-0
Thread-0
Thread-0
Thread-0
Thread-0
Thread-0
Thread-0
Thread-1
Thread-1
Thread-1
Thread-1
Thread-1
Thread-1
Thread-1
Thread-1
Thread-1

 

1. ​实现中断线程

 public class Lock_interrupt_test implements Runnable {
     private Lock lock = null;
     public Lock_interrupt_test() {
         lock = new ReentrantLock();
     }

     @Override
     public void run() {
         try {
             lock.lockInterruptibly();
             for (int i = 0; i < 10; i++) {
                 System.out.println(Thread.currentThread().getName());
                 Thread.sleep(100);
             }
         } catch (InterruptedException e1) {
             e1.printStackTrace();
         } finally {
             lock.unlock();
         }
 }
 public static void main(String[] args) {
     System.out.println("lock interrupt test");
     Lock_interrupt_test lock_interrupt_test = new
 Lock_interrupt_test();
     Thread thread1 = new Thread(lock_interrupt_test, "thread1");
     Thread thread2 = new Thread(lock_interrupt_test, "thread2");
     thread1.start();
     thread2.start();
     try {
         Thread.sleep(400);
     } catch (InterruptedException e) {
         e.printStackTrace();
     }
     State state1 = thread1.getState();
     Thread thread = state1.toString().equals("TIMED_WAITING")?
 thread1:thread2;
     System.out.println("interrupt " + thread.getName());
     thread.interrupt();
     }
 }

运行结果如下：

lock interrupt test
thread1
thread1
thread1
thread1
interrupt thread1
java.lang.InterruptedException: sleep interrupted
at java.base/java.lang.Thread.sleep(Native Method)
at lock_type.Lock_interrupt_test.run(Lock_interrupt_test.java:21)
at java.base/java.lang.Thread.run(Thread.java:844)
thread2
thread2
thread2
thread2
thread2
thread2
thread2
thread2
thread2
thread2

 

1. ​实现检测锁状态

 @Override
 public void run() {
     try {
         if (lock.tryLock(400,TimeUnit.MILLISECONDS)) {
             System.out.println(Thread.currentThread().getName() + " have get the lock");
             for (int i = 1; i < 10; i++) {
                 System.out.println(Thread.currentThread().getName());
                 try {
                    Thread.sleep(100);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
             System.out.println(Thread.currentThread().getName() + " have
             return the lock");
             lock.unlock();
         }
         else {
             for (int i = 1; i < 10; i++) {
                 System.out.println(Thread.currentThread().getName() + " locking");
                 try {
                     Thread.sleep(100);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
         }
     } catch (InterruptedException e) {
         e.printStackTrace();
     }
 }

运行结果如下：

lock try test
Thread-0 have get the lock
Thread-0
Thread-0
Thread-0
Thread-0
Thread-1 locking
Thread-0
Thread-1 locking
Thread-0
Thread-1 locking
Thread-0
Thread-1 locking
Thread-0
Thread-1 locking
Thread-0
Thread-1 locking
Thread-0 have return the lock
Thread-1 locking
Thread-1 locking
Thread-1 locking

 

ReentrantReadWriteLock的用法

实现读写分离锁：

 @Override
 public void run() {
     lock.readLock().lock();
     for(int i=0;i<10;i++) {
         System.out.println(Thread.currentThread().getName() + "---read");
         try {
             Thread.sleep(100);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }
     lock.readLock().unlock();
     lock.writeLock().lock();
     for(int i=0;i<10;i++) {
         System.out.println(Thread.currentThread().getName() + "---write");
         try {
              Thread.sleep(100);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }
     lock.writeLock().unlock();
 }

运行结果如下：

lock read write test
thread2---read
thread1---read
thread1---read
thread2---read
thread1---read
thread2---read
thread2---read
thread1---read
thread1---read
thread2---read
thread1---read
thread2---read
thread1---read
thread2---read
thread1---read
thread2---read
thread2---read
thread1---read
thread2---read
thread1---read
thread1---write
thread1---write
thread1---write
thread1---write
thread1---write
thread1---write
thread1---write
thread1---write
thread1---write
thread1---write
thread2---write
thread2---write
thread2---write
thread2---write
thread2---write
thread2---write
thread2---write
thread2---write
thread2---write
thread2---write