Android多线程研究(9)——线程锁Lock
2014-06-08 21:08
459 查看
在前面我们在解决线程同步问题的时候使用了synchronized关键字,今天我们来看看Java 5.0以后提供的线程锁Lock.
![](https://img-blog.csdn.net/20140608190728031?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZGF3YW5nYW5iYW4=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
Lock接口的实现类提供了比使用synchronized关键字更加灵活和广泛的锁定对象操作,而且是以面向对象的方式进行对象加锁。
@Override
public void run() {
while(true){
Lock lock = new ReentrantLock();
try {
lock.lock();
Thread.sleep(new Random().nextInt(3000));
String data = readData();
System.out.print("读取数据: " + data);
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
lock.unlock();
}
}
}读写锁:分为读锁和写锁,多个读锁不互斥,读锁与写锁互斥,写锁与写锁互斥,这是由JVM控制的。
import java.util.Random;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class ReadWriteLockTest {
static ReadWriteLock rwl = new ReentrantReadWriteLock();
private static String data = null;
public static void main(String[] args) {
Runnable runnable1 = new MyRunnable1();
Runnable runnable2 = new MyRunnable2();
for(int i=0; i<3; i++){
new Thread(runnable1).start();
new Thread(runnable2).start();
}
}
static class MyRunnable1 implements Runnable{
@Override
public void run() {
writeData("" + new Random().nextInt(100));
}
}
static class MyRunnable2 implements Runnable{
@Override
public void run() {
readData();
}
}
private static void writeData(String var){
rwl.writeLock().lock();
try {
System.out.println(Thread.currentThread().getName() + " 准备写");
Thread.sleep(new Random().nextInt(3000));
data = var;
System.out.println(Thread.currentThread().getName() + " 写完毕");
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
rwl.writeLock().unlock();
}
}
private static void readData(){
rwl.readLock().lock(); //用读锁锁住
try {
System.out.println(Thread.currentThread().getName() + " 准备读");
Thread.sleep(new Random().nextInt(3000));
System.out.println(Thread.currentThread().getName() + " 读完毕");
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
rwl.readLock().unlock();
}
}
}
![](https://img-blog.csdn.net/20140608204813656?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZGF3YW5nYW5iYW4=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
用过Hibernate框架的朋友可能知道,Hibernate查询数据库有缓存机制,如果某个数据在内存中存在则可以并发的去读取,如果缓存中没有数据则需要互斥的去从数据库取数据。
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class CacheDemo {
private Map<String, Object> cache = new HashMap<String, Object>();
public static void main(String[] args) {
}
private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
/**
* 实现多个并发读,互斥的写
* @param key
* @return
*/
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 = "去数据库查询"; //这里模拟从数据库查询
if(value == null){
//TODO 抛出异常
}
}
}finally{
rwl.writeLock().unlock();
}
rwl.readLock().lock(); //锁还给读线程
}
}finally{
rwl.readLock().unlock();
}
return value;
}
}
上面获取数据的大概过程如下:1、获取读锁,读取数据
2、如果有数据则直接返回,并释放读锁让其他线程读。
3、如果内存中没有数据则从数据库写入内存,释放读锁并添加写锁(这样写入数据就可以达到可以互斥)
4、读入内存后释放写锁并还回读锁(和后面的unlock()对应)
5、如果在添加写锁的时候同时有多个线程,则只能有其中一个线程抢到锁,等拥有锁的线程释放写锁后,其他线程就会抢到写锁,但是此时数据已经写入内存,则需要判断内存数据是否为null如果不为null则直接释放写锁。
Lock接口的实现类提供了比使用synchronized关键字更加灵活和广泛的锁定对象操作,而且是以面向对象的方式进行对象加锁。
@Override
public void run() {
while(true){
Lock lock = new ReentrantLock();
try {
lock.lock();
Thread.sleep(new Random().nextInt(3000));
String data = readData();
System.out.print("读取数据: " + data);
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
lock.unlock();
}
}
}读写锁:分为读锁和写锁,多个读锁不互斥,读锁与写锁互斥,写锁与写锁互斥,这是由JVM控制的。
import java.util.Random;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class ReadWriteLockTest {
static ReadWriteLock rwl = new ReentrantReadWriteLock();
private static String data = null;
public static void main(String[] args) {
Runnable runnable1 = new MyRunnable1();
Runnable runnable2 = new MyRunnable2();
for(int i=0; i<3; i++){
new Thread(runnable1).start();
new Thread(runnable2).start();
}
}
static class MyRunnable1 implements Runnable{
@Override
public void run() {
writeData("" + new Random().nextInt(100));
}
}
static class MyRunnable2 implements Runnable{
@Override
public void run() {
readData();
}
}
private static void writeData(String var){
rwl.writeLock().lock();
try {
System.out.println(Thread.currentThread().getName() + " 准备写");
Thread.sleep(new Random().nextInt(3000));
data = var;
System.out.println(Thread.currentThread().getName() + " 写完毕");
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
rwl.writeLock().unlock();
}
}
private static void readData(){
rwl.readLock().lock(); //用读锁锁住
try {
System.out.println(Thread.currentThread().getName() + " 准备读");
Thread.sleep(new Random().nextInt(3000));
System.out.println(Thread.currentThread().getName() + " 读完毕");
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
rwl.readLock().unlock();
}
}
}
用过Hibernate框架的朋友可能知道,Hibernate查询数据库有缓存机制,如果某个数据在内存中存在则可以并发的去读取,如果缓存中没有数据则需要互斥的去从数据库取数据。
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class CacheDemo {
private Map<String, Object> cache = new HashMap<String, Object>();
public static void main(String[] args) {
}
private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
/**
* 实现多个并发读,互斥的写
* @param key
* @return
*/
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 = "去数据库查询"; //这里模拟从数据库查询
if(value == null){
//TODO 抛出异常
}
}
}finally{
rwl.writeLock().unlock();
}
rwl.readLock().lock(); //锁还给读线程
}
}finally{
rwl.readLock().unlock();
}
return value;
}
}
上面获取数据的大概过程如下:1、获取读锁,读取数据
2、如果有数据则直接返回,并释放读锁让其他线程读。
3、如果内存中没有数据则从数据库写入内存,释放读锁并添加写锁(这样写入数据就可以达到可以互斥)
4、读入内存后释放写锁并还回读锁(和后面的unlock()对应)
5、如果在添加写锁的时候同时有多个线程,则只能有其中一个线程抢到锁,等拥有锁的线程释放写锁后,其他线程就会抢到写锁,但是此时数据已经写入内存,则需要判断内存数据是否为null如果不为null则直接释放写锁。
相关文章推荐
- Android多线程研究(9)——线程锁Lock
- Android多线程研究(9)——线程锁Lock
- Android多线程研究(5)——线程之间共享数据
- Android多线程研究(8)——Java5中Futrue获取线程返回结果
- Android多线程研究(5)——线程之间共享数据
- Android多线程研究(7)——Java5中的线程并发库
- Android多线程的研究(8)——Java5于Futrue获取线程返回结果
- Android多线程研究(1)——线程基础及源码剖析
- Android多线程研究(8)——Java5中Futrue获取线程返回结果
- Android多线程研究(1)——线程基础及源代码剖析
- Android多线程研究(7)——Java5中的线程并发库
- Android多线程研究(1)——线程基础及源代码剖析
- Android多线程研究(1)——线程基础及源码剖析
- Android多线程任务优化2:实现后台预读线程
- Androidの多线程之Handler创建新线程
- Android 异步任务,通过PHP访问数据库,多线程,线程间通讯
- 线程对象Android 开发之多线程处理、Handler 详解
- Androidの多线程之Handler创建新线程
- Android--多线程之进程与线程