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的思想也是悲观锁;