1.重入锁
目的：避免死锁的现象
锁作为并发共享数据，保证一致性的工具，在java平台有多种实现synchronized（重量级）和ReentrantLock（轻量级）等等，这些已经写好提供的锁为我们开发提供了便利；
重入锁：也叫作递归所，指的是同一线程外层函数获得锁之后，内层递归函数仍然有取该锁的代码，但不受影响；；
在java环境下，ReentrantLock和synchronized都是可重入锁；
1.1 不可重入锁
package com.wn.lock;
public class MyLock {
//标识锁是否可用，如果值为true代表当前有线程正在使用该锁，如果为false代表没有人用锁
private boolean isLocked=false;
//获取锁：加锁
public synchronized void lock() throws InterruptedException {
while (isLocked){
wait();
}
//当前没有人使用情况下占用锁
isLocked=true;
}
//释放锁
public synchronized void unlock(){
//将当前锁资源释放
isLocked=false;
//唤醒正在等待使用锁的线程
notify();
}
}
package com.wn.lock;
public class MyLockTest {
MyLock myLock=new MyLock();
//业务一
public void print() throws InterruptedException {
//获取一把锁
myLock.lock();
System.out.println("print业务方法~~");
doAdd();
//释放锁
myLock.unlock();
}
//业务二
public void doAdd() throws InterruptedException {
myLock.lock();
System.out.println("doAdd业务方法~~");
myLock.unlock();
}
public static void main(String[] args) throws InterruptedException {
MyLockTest test = new MyLockTest();
test.print();
}
}
1.2 synchronized实例
package com.wn.lock;
/*
* 锁作为并发共享数据，保证一致性工具，在java平台有多种实现和ReentrantLock轻量级等等。这些已经写好提供的锁为我们开发提供了便利
* 重入锁：也叫递归锁，指的是同一线程，外层函数获得锁之后，内层递归函数仍然有获取该锁的代码，但不受影响
* 在java环境下ReentrantLock和synchronized都是可重入锁的
* */
public class ReentrantLockTest 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()");
}
@Override
public void run() {
get();
}
public static void main(String[] args){
ReentrantLockTest test = new ReentrantLockTest();
new Thread(test).start();
new Thread(test).start();
new Thread(test).start();
new Thread(test).start();
}
}
1.3 ReentrantLock实例
package com.wn.lock;
import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockTest02 extends ReentrantLockTest {
//创建锁对象
ReentrantLock lock=new ReentrantLock();
//业务一
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 void run(){
get();
}
public static void main(String[] args){
ReentrantLockTest test = new ReentrantLockTest();
new Thread(test).start();
new Thread(test).start();
new Thread(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 class CacheTest {
//创建map集合
static Map<String,Object> map=new HashMap<String,Object>();
//创建读写锁
static ReentrantReadWriteLock rwl=new ReentrantReadWriteLock();
//获取读操作
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);
Object object = map.get(key);
System.out.println("正在做读的操作，key:"+key+"结束");
System.out.println();
return object;
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
r.unlock();
}
return key;
}
//设置key对应的value，并返回旧的value
public static final 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();
return o;
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
w.unlock();
}
return value;
}
public static void main(String[] args){
new Thread(new Runnable() {
@Override
public void run() {
for (int i=0;i<3;i++){
CacheTest.put(i+"",i+"");
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
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的思想也是悲观锁；
posted on
