代码浅析 Android Lock 、ReentrantLock线程锁及其作用
先来了解什么是“互斥锁”？
百度一下，解释如下：在编程中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。每个对象都对应于一个可称为" 互斥锁" 的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。
是的，面对高并发的读、写访问，可能会出现数据丢失的问题，而Andriod系统基于Linux内核，使得并发读、写数据可以没有限制的进行。因此，出于对数据，尤其是共享数据的完整性和一致性，我们需要用到锁机制来确保数据的可靠性。
在Android中，有三类锁可以解决上述问题：
1：synchronized
这是java中比较常见的一种同步锁关键字，由于常见，这里就不一一介绍了，详见：http://blog.csdn.net/luoweifu/article/details/46613015
2：Lock
先看看继承关系：
使用之前我们先看看，模拟并发的情况：
package SychronizedTest;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class SychronizedTest {
/**
* @author zy_style
* @param args
*/
public static void main(String[] args) {
final Outputter outputter = new Outputter();
// 开启一条线程输出名字的每个字符
new Thread() {
@Override
public void run() {
try {
outputter.output("abcde");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}.start();
// 开启另一条线程
new Thread() {
@Override
public void run() {
try {
outputter.output("fghij");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}.start();
}
}
class Outputter {
public void output(String name) throws InterruptedException {
for (int i = 0; i < name.length(); i++) {
System.out.println(name.charAt(i));
Thread.sleep(1000);
}
}
}得到的输出结果：
a
f
g
b
h
c
d
i
j
e
现在我们加上Lock:
package SychronizedTest;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class SychronizedTest {
/**
* @author zy_style
* @param args
*/
public static void main(String[] args) {
final Outputter outputter = new Outputter();
// 开启一条线程输出名字的每个字符
new Thread() {
@Override
public void run() {
try {
outputter.output("abcde");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}.start();
// 开启另一条线程
new Thread() {
@Override
public void run() {
try {
outputter.output("fghij");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}.start();
}
}
class Outputter {
private Lock lock = new ReentrantLock(); // 定义锁对象
public void output(String text) throws InterruptedException {
lock.lock(); // 得到锁
try {
for (int i = 0; i < text.length(); i++) {
System.out.println(text.charAt(i));
Thread.sleep(1000);
}
} finally {
lock.unlock(); // 释放锁
}
}
}
现在，输出结果如下：
a
b
c
d
e
f
g
h
i
j3：ReadWriteLock
可以发现，上面的情况并不能解决并发读写的同步问题，比如说读与写互斥、写与写互斥的问题。先看看不考虑互斥问题的代码：
package SychronizedTest;
/**
* 读写锁测试
*
* @author zy_style
*/
public class ReadWriteLockTest {
/**
* @author zhouyang 2016-12-1
* @time 下午3:01:27
* @param args
*/
public static void main(String[] args) {
final Data data = new Data();
// 开启3个子线程,分别写入数据
for (int i = 0; i < 3; i++) {
new Thread() {
public void run() {
for (int j = 0; j < 5; j++) {
try {
data.set(j); // 写入数据
} catch (Exception e) {
e.printStackTrace();
}
}
};
}.start();
}
// 分别读取数据
for (int i = 0; i < 3; i++) {
new Thread() {
public void run() {
for (int j = 0; j < 5; j++) {
try {
data.get(); // 读取数据
} catch (Exception e) {
e.printStackTrace();
}
}
};
}.start();
}
}
}
/**
* 需要操作的数据
*
* @author zy_style
*/
class Data {
private int data;
public void set(int data) throws Exception {
System.out.println(Thread.currentThread().getName() + "准备写入数据...");
Thread.sleep(50); // 模拟耗时操作
this.data = data;
System.out.println(Thread.currentThread().getName() + "写入数据成功!");
}
public void get() throws Exception {
System.out.println(Thread.currentThread().getName() + "准备读取数据...");
Thread.sleep(50); // 模拟耗时操作
System.out.println(Thread.currentThread().getName() + "读取数据:"
+ this.data);
}
}
Thread-1写入数据成功!
Thread-1准备写入数据...
Thread-2写入数据成功!
Thread-2准备写入数据...
Thread-0准备写入数据...
Thread-4读取数据:0
Thread-4准备读取数据...
Thread-3读取数据:0
Thread-5读取数据:0
Thread-3准备读取数据...
Thread-5准备读取数据...
Thread-1写入数据成功!如果现在有这么一个需求：读与写互斥、写与写互斥、读与读互斥，说白了就是让所有的读写操作都互斥，互不干扰。其实很简单，在set()和get()方法前加上sychronized修饰符即可：
public synchronized void set(int data) throws Exception {
System.out.println(Thread.currentThread().getName() + "准备写入数据...");
Thread.sleep(50); // 模拟耗时操作
this.data = data;
System.out.println(Thread.currentThread().getName() + "写入数据成功!");
}
public synchronized void get() throws Exception {
System.out.println(Thread.currentThread().getName() + "准备读取数据...");
Thread.sleep(50); // 模拟耗时操作
System.out.println(Thread.currentThread().getName() + "读取数据:"
+ this.data);
}部分运行结果如下：
Thread-0准备写入数据...
Thread-0写入数据成功!
Thread-0准备写入数据...
Thread-0写入数据成功!
Thread-5准备读取数据...
Thread-5读取数据:4
Thread-4准备读取数据...
Thread-4读取数据:4
Thread-4准备读取数据...
Thread-4读取数据:4
Thread-3准备读取数据...
Thread-3读取数据:4既然结果确实是读、写互斥了，但是考虑到实际情况，我们为了提高并发的效率，其实读与读可以不互斥，只用保证读与写、读与读之间互斥，这样才能最高效的执行并发操作并保证数据的完整性。这里就用到ReadWriteLock了：
package SychronizedTest;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* 读写锁测试
*
* @author zy_style
*/
public class ReadWriteLockTest {
/**
* @author zhouyang 2016-12-1
* @time 下午3:01:27
* @param args
*/
public static void main(String[] args) {
final Data data = new Data();
// 开启3个子线程,分别写入数据
for (int i = 0; i < 3; i++) {
new Thread() {
public void run() {
for (int j = 0; j < 5; j++) {
try {
data.set(j); // 写入数据
} catch (Exception e) {
e.printStackTrace();
}
}
};
}.start();
}
// 分别读取数据
for (int i = 0; i < 3; i++) {
new Thread() {
public void run() {
for (int j = 0; j < 5; j++) {
try {
data.get(); // 读取数据
} catch (Exception e) {
e.printStackTrace();
}
}
};
}.start();
}
}
}
/**
* 需要操作的数据
*
* @author zy_style
*/
class Data {
private int data;
private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
public void set(int data) throws Exception {
readWriteLock.writeLock().lock(); // 获取写锁
try {
System.out.println(Thread.currentThread().getName() + "准备写入数据...");
Thread.sleep(50); // 模拟耗时操作
this.data = data;
System.out.println(Thread.currentThread().getName() + "写入数据成功!");
} finally {
readWriteLock.writeLock().unlock(); // 释放写锁
}
}
public void get() throws Exception {
readWriteLock.readLock().lock(); // 获取读锁
try {
System.out.println(Thread.currentThread().getName() + "准备读取数据...");
Thread.sleep(50); // 模拟耗时操作
System.out.println(Thread.currentThread().getName() + "读取数据:"
+ this.data);
} finally {
readWriteLock.readLock().unlock(); // 释放读锁
}
}
}
部分运行结果如下：
Thread-1准备写入数据...
Thread-1写入数据成功!
Thread-2准备写入数据...
Thread-2写入数据成功!
Thread-5准备读取数据...
Thread-3准备读取数据...
Thread-4准备读取数据...
Thread-5读取数据:0
Thread-3读取数据:0
Thread-4读取数据:0可以看到，读与写、写与写确实互斥了，但是读与读没有互斥，这就是ReadWriteLock带来的好处，它在保证共享数据并发操作的完整性和一致性，最重要的是提高了读写的效率~！