【Java多线程与并发库】10.java5的线程锁(读写锁)技术

Lock&Condition实现线程同步通信

(1)Lock概念

Lock比传统线程模型中的synchronized方式更加面向对象，与生活中的锁类似，

锁本身也是一个对象。两个线程执行的代码片段要实现同步互斥的效果，它们

必须用同一个Lock对象。锁是加在代表要操作的资源的类的内部方法中，而不是

线程代码中！

例子:

package cn.edu.hpu.test;

public class LockTest {
public static void main(String[] args) {
new TraditionalThreadSynchronized().init();
}

public void init(){

final Outputer outputer=new Outputer();

new Thread(new Runnable(){
public void run() {
while(true){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
outputer.output("ABCDEFGHIJKLNOPQRST");
}
}
}
).start();

new Thread(new Runnable(){
public void run() {
while(true){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
outputer.output("abcdefghijklmnopqrst");
}
}
}
).start();
}

class Outputer{
public void output(String name){
int len=name.length();
for (int i = 0; i < len; i++) {
System.out.print(name.charAt(i));
}
System.out.println();
}
}
}

这段代码是没有加锁的，所以会发生在打印某个线程的数据的时候，内存会突然让给其它线程

去打印数据，导致数据只打印一半:



加锁:

package cn.edu.hpu.test;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockTest {
public static void main(String[] args) {
new TraditionalThreadSynchronized().init();
}

public void init(){

final Outputer outputer=new Outputer();

new Thread(new Runnable(){
public void run() {
while(true){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
outputer.output("ABCDEFGHIJKLNOPQRST");
}
}
}
).start();

new Thread(new Runnable(){
public void run() {
while(true){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
outputer.output("abcdefghijklmnopqrst");
}
}
}
).start();
}

class Outputer{
Lock lock = new ReentrantLock();//创建一个锁
public void output(String name){
int len=name.length();
lock.lock();//上锁
try {
for (int i = 0; i < len; i++) {
System.out.print(name.charAt(i));
}
System.out.println();
}finally{
//这么做是防止线程死掉大家都进不去
lock.unlock();//开锁
}
}
}
}

加锁之后所有的线程都不会被打断:



(2)读写锁

读写锁:分为读锁和写锁，多个读锁不互斥，读锁与写锁互斥，写锁与写锁互斥，

这是由JVM自己控制的，你只要加好相应的锁即可。如果代码只读数据，可以很

多人同时读，但是不能同时写，那就加读锁；如果代码修改数据，只能有一个人

在写，且不能同时读取，那就加写锁。总之，读的时候加读锁，写的时候加写锁。

读写锁例子:

产生三个线程，用来读数据，然后产生另外三个线程，用来写数据。如果不加线程锁，

我们就会看到读和写的线程交替运行，也即是“读中有写，写中有读”。

package cn.edu.hpu.test;

import java.util.Random;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockTest {
public static void main(String[] args) {
final Queue q = new Queue();
for (int i = 0; i < 3; i++) {
new Thread(){
public void run(){
while(true){
q.get();
}
}
}.start();

new Thread(){
public void run(){
while(true){
q.put(new Random().nextInt(10000));
}
}
}.start();
}
}
}

class Queue{
private Object data = null;//共享数据，只有一个线程能写该数据，但可以有多个线程同时读该数据
public void get(){
System.out.println(Thread.currentThread().getName().toString()+"准备读取数据");
try {
Thread.sleep((long)Math.random()*1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName().toString()+"读取数据："+data);
}

public void put(Object data){
System.out.println(Thread.currentThread().getName().toString()+"准备改写数据");
try {
Thread.sleep((long)Math.random()*1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.data=data;
System.out.println(Thread.currentThread().getName().toString()+"改写数据为："+data);
}
}

效果:



可以看到，在线程5准备改写数据的时候，线程1去改写了数据，然后等线程1准备改写数据

的时候，线程5去改写了数据，此时对于变量data是线程不安全的。

如果我们上了读写锁，读的时候没有写，写的时候没有读和其它写，

即是“读中无写，写中无读写”。

package cn.edu.hpu.test;

import java.util.Random;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockTest {
public static void main(String[] args) {
final Queue q = new Queue();
for (int i = 0; i < 3; i++) {
new Thread(){
public void run(){
while(true){
q.get();
}
}
}.start();

new Thread(){
public void run(){
while(true){
q.put(new Random().nextInt(10000));
}
}
}.start();
}
}
}

class Queue{
private Object data = null;//共享数据，只有一个线程能写该数据，但可以有多个线程同时读该数据
private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
public void get(){
rwl.readLock().lock();
try {
System.out.println(Thread.currentThread().getName().toString()+"准备读取数据");
Thread.sleep((long)Math.random()*1000);
System.out.println(Thread.currentThread().getName().toString()+"读取数据："+data);
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
rwl.readLock().unlock();
}
}

public void put(Object data){
rwl.writeLock().lock();
try {
System.out.println(Thread.currentThread().getName().toString()+"准备改写数据");
Thread.sleep((long)Math.random()*1000);
this.data=data;
System.out.println(Thread.currentThread().getName().toString()+"改写数据为："+data);
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
rwl.writeLock().unlock();
}
}
}

结果:



可以看到，当一个线程去写的时候，永远都不会被读取动作或者改写动作打断，而当一个线程

去读取的时候，永远都不会被改写动作打断，但是可以被另外的读取动作打断，这是合理的。

这里，大家看一下JavaAPI给我们的一个读写锁的例子:

public class CacheData {
Object data;
volatile boolean cacheValid;
ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

void processCacheData(){
rwl.readLock().lock();
if(!cacheValid){//是否有缓存可用
//在加写锁之前必须释放读锁
rwl.readLock().unlock();
rwl.writeLock().lock();
//再次检查一下校验状态，以防止有其他线程修改
if(!cacheValid){
data=... //去真实的库中取值
cacheValid=true;
}
//在释放写锁之前要加读锁
rwl.readLock().lock();
rwl.writeLock().unlock();
}

use(data);//直接取缓存来使用
rwl.readLock().unlock();
}
}

看起来像是一个多个线程操作缓存数据的代码。在hibernate的二级缓存中出现过类似思想，

例如:

User user = session.get(id,User.class);

User user = session.load(id,User.class);

上下的区别是:

上面的是直接从数据库中把相应id的user数据取出来封装到User对象中去，

如果没有这个数据，返回的值是null;

下面是，不管数据库中有没有这个记录，都会得到一个User对象代理，实际

就是User$Proxy，该代理大概长这个样子(伪代码):

User$Proxy extends User{
private Integer id = id;

User realUser = null;
getName(){
if(realUser == null){
realUser = session.get(id);
if(realUser == null) throw exception;
}
return realUser;
}
}

即是，当真正的User不存在的时候，代理User从数据中去取数据，如果下次请求，

代理发现之前去过，就把缓存数据提供出去。

(3)缓存系统模拟

接下来我们通过使用读写锁，自己设计一个缓存系统。

package cn.edu.hpu.test;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class CacheDemo {

private Map<String,Object> cache=new HashMap<String,Object>();//缓存池
private ReadWriteLock rwl=new ReentrantReadWriteLock();

public static void main(String[] args) {
CacheDemo cacheDemo=new CacheDemo();
System.out.println("第一次取数据结果:"+cacheDemo.getData("1"));
System.out.println("第二次取数据结果:"+cacheDemo.getData("1"));
}

public Object getData(String key){
rwl.readLock().lock();
Object value = null;
try {
value = cache.get(key);//先去缓存中去取
if (value == null) {
rwl.readLock().unlock();
rwl.writeLock().lock();

try {
if(value == null){
value = MySqlDB.getData(key);//实际去数据库取数据
cache.put(key, value);
}
} catch (Exception e) {
e.printStackTrace();
}finally{
rwl.writeLock().unlock();
}
rwl.readLock().lock();
}
} catch (Exception e) {
e.printStackTrace();
}finally{
rwl.readLock().unlock();
}
return value;
}
}

class MySqlDB{

public static Object getData(String key) throws InterruptedException{

Object data=null;

System.out.println("获取数据库连接...");
Thread.sleep(2000);
System.out.println("开启事务...");
Thread.sleep(2000);
System.out.println("编译sql语句...");
Thread.sleep(2000);
System.out.println("查找数据...");
Thread.sleep(5000);
System.out.println("返回数据...");
Thread.sleep(2000);
if(key.equals("1")){
data=new String("张三");
}
System.out.println("关闭事务...");
Thread.sleep(2000);
System.out.println("关闭数据库连接...");
Thread.sleep(2000);

return data;
}
}

结果:



这样就是实现了，当第一次取数据的时候去数据库取，后面取数据从缓存中取，
而且其中的读写都是线程绝对安全的。

转载请注明出处：http://blog.csdn.net/acmman/article/details/52902128