android 线程锁Lock

今天，简单讲讲android的线程锁



Lock的使用。

这个其实和SynchronizedClass 是一样的。我记得我的一篇博客写过这个内容。再次记录一下。

一、同步机制关键字synchronized
对于java来说，最常用的同步机制就是synchronized关键字，他是一种基于语言的粗略锁，能够作用于对象、函数、class。每个对象都只有一个锁，谁能够拿到这个锁谁就有访问权限。当synchronized作用于函数时，实际上锁的也是对象，锁定的对象就是该函数所在类的对象。而synchronized作用于class时则是锁的这个Class类，并非具体对象。

public class SynchronizedClass {
    public synchronized void syncMethod(){
        //代码
    }

    public void syncThis(){
        synchronized (this){
            //代码
        }
    }

    public void syncClassMethod(){
        synchronized (SynchronizedClass.class){
            //代码
        }
    }

    public synchronized static void syncStaticMethod(){
        //代码
    }
}

上面演示了同步方法、同步块、同步class对象、同步静态方法。前2种锁的是对象，而后两种锁的是class对象。对于class对象来说，它的作用是防止多个线程同时访问添加了synchronized锁的代码块，而synchronized作用于引用对象是防止其他线程访问同一个对象中synchronized代码块或者函数。

二、显示锁Lock。

Lock接口的实现类提供了比使用synchronized关键字更加灵活和广泛的锁定对象操作，而且是以面向对象的方式进行对象加锁。

public class ReentrantLockDemo {
    Lock lock = new ReentrantLock();

    public void doSth(){
        lock.lock();
        try {
            //执行某些操作
        }finally {
            lock.unlock();
        }
    }
}

区别：

需要注意的是，用sychronized修饰的方法或者语句块在代码执行完之后锁自动释放，而是用Lock需要我们手动释放锁，所以为了保证锁最终被释放(发生异常情况)，要把互斥区放在try内，释放锁放在finally内！！

3、读写锁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带来的好处，它在保证共享数据并发操作的完整性和一致性，最重要的是提高了读写的效率~！

android 线程锁Lock就讲完了。

就这么简单。