Java学习（锁机制）

锁机制

对象锁：同步方法，锁住的对象

全局锁：类锁，静态方法，锁住的是class类

synchronized使用场景

用于实现代码的同步处理，保持可见性、有序性和原子性

数据不安全的2个条件：共享的临界资源、多线程同时访问并改变数据

synchronized三种形式

synchronized修饰普通方法，锁对象是当前对象

synchronized修饰静态方法，锁对象是当前类

synchronized修饰同步代码块，锁对象是synchronized后面括号中的配置对象

当时有synchronized修饰同步代码块是，编译后的字节码中就会有monitorenter和monitorexit两个字节码指令，分别对应的是获取锁和解锁操作，（2个monitorexit保证正常执行完毕的解锁和异常结束的解锁操作）。当时有synchronized修饰方法时，会给方法上添加标记ACC_SYNCHRONIZED，这样JVM就知道这个方法是一个同步方法，于是进入同步方法时就会进行竞争锁的操作，只有获取锁才能继续执行。不管是哪种锁多线程获取锁的本质就是获取monitor对象。

锁状态

无锁、偏向锁、轻量级锁、重量级锁

随着竞争情况的逐步升级而升级，不能降级

编码：生产者-消费者模式

Lock

Lock接口是Java1.5引入的线程同步工具，主要用于

多线程下共享资源的控制，可以通过显示定义同步锁对象来实现同步处理，可以提供比synchronized更广泛灵活的锁定操作，并支持多个相关的Condition对象

void lock() 用于尝试获取锁，如果获取到锁则返回，否则阻塞当前线程等待

void lockInterruptbily() 尝试获取锁，线程可以在成功获取锁之前被中断，则放弃获取锁操作，而抛出异常

boolean tryLock() 尝试获取锁，获取成功则返回true，否则也是理解返回false，不会阻塞

boolean tryLock(long,TimeUnit) 尝试获取锁，获取成功则返回true，否则会阻塞一段时间等待，超时时间显示为long + 单位时间TimeUnit，线程在成功获取锁之前可以被中断，则放弃获取锁操作，而抛出异常

void unlock()释放锁

Condition newCondition()返回当前锁的条件对象，通过条件对象可以实现类似notif/wait的功能，一个锁可以有多个条件变量

Lock接口在juc包[java.util.concurrent]中提供了3种实现，ReentrantLock重入锁，另外时ReentrantReadWriteLock类中的两个静态内部类ReadLock读锁和WriteLock写锁

注意：ReentrantLock重入锁，当前线程已经调用lock()方法持有锁时，还允许再次调用lock方法申请锁，申请多少次锁，就必须释放unlock()方法多少次，一般加可以try/finally结构释放lock

一般编程结构

属性 private final [static] Lock lock = new RentrantLock();

具体方法中使用锁

lock.lock();
try{
	...
}finally{
	lock.unlock();
}

需求：有 5 个线程输出 A，有 5 个线程输出 B，要求所实现的输出必须 ABABAB…

实验代码

public class 输出资源 {
	private static final Lock lock = new ReentrantLock();
	private final Condition aCondition = lock.newCondition();
	private final Condition bCondition = lock.newCondition();
	volatile boolean isA = false;

	public void printA() {
		lock.lock();
		try {
			while (isA) {
				try {
					aCondition.await();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println("A" + Thread.currentThread().getName() + " ");
			isA = true;
			bCondition.signalAll();
		} finally {
			lock.unlock();
		}
	}

	public void printB() {
		lock.lock();
		try {
			while(!isA){
				try {
					bCondition.await();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}  
			}
			System.out.println("B"+Thread.currentThread().getName());
			isA=false;
			aCondition.signalAll();
		} finally {
			lock.unlock();
		}
	}
}

测试类

public class Test {
	public static void main(String[] args) {
		输出资源 res=new 输出资源();
		for(int i=0;i<5;i++){
			new Thread(()->{
				for(int k=0;k<20;k++)
					res.printA();
			}).start();
			new Thread(()->{
				for(int k=0;k<20;k++)
					res.printB();
			}).start();
		}
	}
}

当调用 condition.await()方法阻塞线程时会自动释放锁【类似 obj.wait()】，不管当前线程调用了多少次 lock.lock() 获取锁，这时阻塞在 lock.lock()方法上其它线程就可以获取锁

当调用 condition.signall()唤醒执行继续上次阻塞的线程【类似于 obj.notify()和 notifyAll()】，从上次阻塞的位置 继续执行，默认会自动重新获取锁，注意和阻塞时获取锁的次数一致

ReentrantReadWriteLock 是 Lock 接口的另外一种实现，ReentrantLock 是一种排他锁，同一个时间只允许一个线程访问，但是 ReentrantReadWriteLock 可以分为读锁和写锁，允许多个读线程同时访问，但是不允许写线程和 读线程、写线程和写线程同时访问。在实际应用种大部分对共享数据的访问都是读操作远多于写操作，这种情况下

使用 ReentrantReadWriteLock 能够比排他锁有更好的并发性和吞吐量

Lock和synchronized的区别：

从性能来看，如果竞争不太激烈，两者性能相差不大，但是当线程竞争非常激烈（有大量的线程同时参与理解资源的访问），此时Lock性能优于synchronized，在具体使用时可以预估线程的激烈程度进行选用

Condition

条件变量就是表示条件的一种变量，这里的条件实际上没有实际含义，仅仅只是一个标记，并且条件的含义往往是通过代码赋予含义的。条件变量都实现了 Condition 接口，条件变量的实例化是通过 lock 对象上调用

newCondition 方法来获取的。这样达到将条件和一个锁对象进行绑定的目的。可以通过 Condition 来控制并发程序访问竞争资源的安全。

await()导致当前线程阻塞等待，直到其它线程调用该 condition 的 sign 或者 signall 方法来进行唤醒

sign()唤醒在 lock 对象上处于阻塞等待的单个线程，如果有多个等待线程则会随机选中一个线程。

signall()唤醒在 lock 对象上等待的所有线程，只有当前线程释放对该 lock 对象的锁定后，才可以执行被唤醒的线程

ReadWriteLock接口

ReentrantLock 在特定情况下使用是有局限性的。如果使用 ReentrantLock 本身是为了放置线程 A 在写数据时，线程 B 在读数据，从而造成的数据不一致。如果线程 A 在读数据，线程 B 也在读数据，读数据是不会改变数据的，此时加锁是没有必要。但是由于使用 ReentrantLock 还是添加上了排他锁，这样实际上就是降低了程序的性能。所 以引入读写锁

ReentrantReadWriteLock 是 ReadWriteLock 接口的实现类，实现了读写分离，读锁是共享的，写锁是独占的，从而提供读写性能

ReadWriteLock lock=new ReentrantReadWriteLock();

Lock lock1=lock.readLock();

Condition c1=lock1.newCondition();

lock1.lock();

… …

lock1.unlock();