1.重入锁

目的：避免死锁的现象

锁作为并发共享数据，保证一致性的工具，在java平台有多种实现synchronized(重量级)和ReentrantLock(轻量级)等等，这些已经写好提供的锁为我们开发提供了便利；

重入锁：也叫作递归所，指的是同一线程外层函数获得锁之后，内层递归函数仍然有取该锁的代码，但不受影响；；

在java环境下，ReentrantLock和synchronized都是可重入锁；

1.1 不可重入锁

package com.wn.lock;public classMyLock {//标识锁是否可用，如果值为true代表当前有线程正在使用该锁，如果为false代表没有人用锁

private boolean isLocked=false;//获取锁：加锁

public synchronized void lock() throws InterruptedException {while(isLocked){

wait();

}//当前没有人使用情况下占用锁

isLocked=true;

}//释放锁

public synchronized voidunlock(){//将当前锁资源释放

isLocked=false;//唤醒正在等待使用锁的线程

notify();

}

}

package com.wn.lock;public classMyLockTest {

MyLock myLock=newMyLock();//业务一

public voidprint() throws InterruptedException {//获取一把锁

myLock.lock();

System.out.println("print业务方法~~");

doAdd();//释放锁

myLock.unlock();

}//业务二

public voiddoAdd() throws InterruptedException {

myLock.lock();

System.out.println("doAdd业务方法~~");

myLock.unlock();

}public static voidmain(String[] args) throws InterruptedException {

MyLockTest test= newMyLockTest();

test.print();

}

}

1.2 synchronized实例

package com.wn.lock;/** 锁作为并发共享数据，保证一致性工具，在java平台有多种实现和ReentrantLock轻量级等等。这些已经写好提供的锁为我们开发提供了便利

* 重入锁：也叫递归锁，指的是同一线程，外层函数获得锁之后，内层递归函数仍然有获取该锁的代码，但不受影响

* 在java环境下ReentrantLock和synchronized都是可重入锁的

**/

public classReentrantLockTest implements Runnable {//业务一

public synchronized void get(){

System.out.println("name:"+Thread.currentThread().getName()+"get();");set();

}//业务二

public synchronized void set(){

System.out.println("name:"+Thread.currentThread().getName()+"set()");

}

@Overridepublic voidrun() {get();

}public static voidmain(String[] args){

ReentrantLockTest test= newReentrantLockTest();newThread(test).start();newThread(test).start();newThread(test).start();newThread(test).start();

}

}

1.3 ReentrantLock实例

package com.wn.lock;

import java.util.concurrent.locks.ReentrantLock;public classReentrantLockTest02 extends ReentrantLockTest {//创建锁对象

ReentrantLock lock=newReentrantLock();//业务一

public void get(){//获取一把锁

lock.lock();

System.out.println(Thread.currentThread().getName());set();//释放一把锁

lock.unlock();

}//业务二

public void set(){//获取一把锁

lock.lock();

System.out.println(Thread.currentThread().getName());//释放一把锁

lock.unlock();

}public voidrun(){get();

}public static voidmain(String[] args){

ReentrantLockTest test= newReentrantLockTest();newThread(test).start();newThread(test).start();newThread(test).start();

}

}

2.读写锁

相比java中的锁(Lock in java)里Lock实现，读写锁更复杂一些；

假设你的程序中涉及到对一些共享资源的读和写操作，且写操作没有读操作那么频繁。在没有写操作的时候，两个线程同时第一个资源没有任务问题，所以应该允许多个线程能在同时读取共享资源。但是如果有一个线程想去写这些共享资源，就不应该再有其他线程对该资源进行读或写(也就是说：读和读能共享，读和写不能共享，写和写不能共享)。这就需要一个读写锁来解决这个问题。在java5中java.util.concurrent包中已经包含读写锁；

package com.wn.lock;

import java.util.HashMap;

import java.util.Map;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantReadWriteLock;/** 相比java中的锁Locks in java 里lock实现，读写锁更负载一些；

* 假设你的程序中涉及到一些共享资源的读和写操作，且写操作没有读操作那么频繁。在没有写操作的时候，两个线程同时读一个资源没有任何问题，所以应该都允许多个线程能在同时读取共享数据，

* 但是如果一个线程想去写这些共享资源，就不应该再有其他线程对该资源进行读或写；

**/

public classCacheTest {//创建map集合

static Map map=new HashMap();//创建读写锁

static ReentrantReadWriteLock rwl=newReentrantReadWriteLock();//获取读操作

static Lock r=rwl.readLock();//获取写操作

static Lock w=rwl.writeLock();//获取一个key对应的value

public static final Object get(String key){

r.lock();try{

System.out.println("正在做读的操作，key:"+key+"开始");

Thread.sleep(100);

Objectobject = map.get(key);

System.out.println("正在做读的操作，key:"+key+"结束");

System.out.println();return object;

}catch(InterruptedException e) {

e.printStackTrace();

}finally{

r.unlock();

}returnkey;

}//设置key对应的value，并返回旧的value

public staticfinal Object put(String key,Object value){

w.lock();try{

System.out.println("正在做写的操作，key:"+key+",value:"+value+"开始");

Thread.sleep(100);

Object o=map.put(key, value);

System.out.println("正在做写的操作，key:"+key+",value:"+value+"结束");

System.out.println();returno;

}catch(InterruptedException e) {

e.printStackTrace();

}finally{

w.unlock();

}returnvalue;

}public static voidmain(String[] args){new Thread(newRunnable() {

@Overridepublic voidrun() {for (int i=0;i<3;i++){

CacheTest.put(i+"",i+"");

}

}

}).start();new Thread(newRunnable() {

@Overridepublic voidrun() {for (int i=0;i<3;i++){

CacheTest.get(i+"");

}

}

}).start();

}

}

3.乐观锁

乐观锁总是任务不会产生并发问题，每次去取数据的时候总认为不会有其他线程对数据进行修改，因此不会上锁，但是在更新时会判断其他新城在这之前有没有对数据进行修改，一般会使用版本号或CAS操作实现；

乐观锁：本质没有锁，效率高，无阻塞，无等待，重试；

version方式：一般是在数据表中加上一个数据版本号version字段，表示数据被修改的次数，当数据被修改时，version值会加一。当线程A要更新数据值时，在读取数据的同时夜壶读取version值，在提交更新时，若刚才读取到的version值为当前数据库中的version值相等时才更新，否则重试更新操作，直到更新成功；

update table set x=x+1, version=version+1 where id=#{id} and version=#{version};

CAS操作方式：即compare and swap或者compare and set，涉及到三个操作数，数据所在的内存值，预期值，新值。当需要更新时，判断当前内存值与之前取到的值是否相等，若相等，则用新值更新，若失败则重试，一般情况下是一个自旋操作，即不断的重试；

4.悲观锁

总是假设最坏的情况，每次取数据时都任务其他线程会修改，所以都会加锁(读锁，写锁，行锁等)，当其他线程想要访问数据时，都需要阻塞挂起。可以依靠数据库实现，如行锁，读锁和写锁等，都是在操作之前加锁，在java中，synchronized的思想也是悲观锁；