Android多线程研究（9）——线程锁Lock

  在前面我们在解决线程同步问题的时候使用了synchronized关键字，今天我们来看看Java 5.0以后提供的线程锁Lock.                   >>>>>>>>>>>>盗QQ号详细教程

   

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

1     2     3     4     5     6     7     8     9     10     11     12     13     14     15     16

@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控制的。

1     2     3     4     5     6     7     8     9     10     11     12     13     14     15     16     17     18     19     20     21     22     23     24     25     26     27     28     29     30     31     32     33     34     35     36     37     38     39     40     41     42     43     44     45     46     47     48     49     50     51     52     53

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();     }     }     }

  ReentrantLock是一个可重入的互斥锁，重入锁是一种递归无阻塞的同步机制。ReentrantLock由最近成功获取锁，还没有释放的线程所拥有，当锁被另一个线程拥有时，调用lock的线程可以成功获取锁。如果锁已经被当前线程拥有，当前线程会立即返回。

 

重入锁的构造方法提供一个可选的公平参数：

     公平情况下，操作会排一个队按顺序执行，来保证执行顺序。

     不公平情况下，是无序状态允许插队，jvm会自动计算如何处理更快速来调度插队。（

 

1、防止重复执行（忽略重复触发）

 

Java代码  

1. ReentrantLock lock = new ReentrantLock();  
2. if (lock.tryLock()) {  //如果已经被lock，则立即返回false不会等待，达到忽略操作的效果   
3.     try {  
4.         //操作  
5.     } finally {  
6.         lock.unlock();  
7.     }  
8. }  

 

 

2、同步执行，类似synchronized

 

Java代码  

1. ReentrantLock lock = new ReentrantLock(); //参数默认false，不公平锁  
2. ReentrantLock lock = new ReentrantLock(true); //公平锁  
3.   
4. lock.lock(); //如果被其它资源锁定，会在此等待锁释放，达到暂停的效果  
5. try {  
6.     //操作  
7. } finally {  
8.     lock.unlock();  
9. }  

 

 

3、尝试等待执行

 

Java代码  

1. ReentrantLock lock = new ReentrantLock(true); //公平锁  
2. try {  
3.     if (lock.tryLock(5, TimeUnit.SECONDS)) {      
4.         //如果已经被lock，尝试等待5s，看是否可以获得锁，如果5s后仍然无法获得锁则返回false继续执行  
5.         try {  
6.             //操作  
7.         } finally {  
8.             lock.unlock();  
9.         }  
10.     }  
11. } catch (InterruptedException e) {  
12.     e.printStackTrace(); //当前线程被中断时(interrupt)，会抛InterruptedException                   
13. }  

 

 

4、可中断锁的同步执行

Java代码  

1. ReentrantLock lock = new ReentrantLock(true); //公平锁  
2. lock.lockInterruptibly();  
3. try {  
4.     //操作  
5. } catch (InterruptedException e) {  
6.     e.printStackTrace();  
7. } finally {  
8.     lock.unlock();  
9. }