Java多线程同步和异步问题

我们首先来说一下多线程：

多线程很形象的例子就是：在一个时刻下，一个班级的学生有人在拖地，有人在擦窗户，有人在擦桌子

按照单线程程序，肯定是先去拖地，再去擦窗户，再去擦桌子。但是在多线程就好像他们在一个时间点同时发生了。

为什么要说好像？是因为在单核系统下，CPU不可能同时进行两个事件。它只是完成这个事件之后迅速切换到另外一个事件而造成两个事件好像是同时发生的一样的假象。

接下来说一下怎么写多线程程序：

写多线程程序有两种方法：

1、继承于Thread类（这个类就是实现了Runnable接口）

2、实现Runnable接口

两者区别不太大

1、下面给出继承Thread实现多线程程序示例：

使用这种方法你只需要覆盖重写Thread的run()方法就可以，run方法里面就写你要多线程运行的程序就可以

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //3.创建线程对象，实例化调用
        Tuodi t=new Tuodi("张三");
        //4. 启动线程
        t.start();
        new Chazuozi("李四").start();  //匿名调用
        new Chachuanghu("王五").start();
    }
    }

//1. 继承java.lang.Thread  类
//2. 线程体run 实现线程功能
class Tuodi  extends Thread{
    String name;
    public Tuodi(String name) {
        super();
        this.name = name;
    }
    @Override
    //线程体 实现线程功能
    public void run() {
        int len=100;
        while(len>0) {
            len-=1;
               System.out.println(name+"在拖地！");
            }
    }
}
class Chazuozi  extends Thread{
    String name;
    public Chazuozi(String name) {
        super();
        this.name = name;
    }
    @Override
    //线程体 实现线程功能
    public void run() {
        int len=100;
        while(len>0) {
            len-=1;
               System.out.println(name+"在擦桌子！");
            }
    }
}
class Chachuanghu  extends Thread{
    String name;
    public Chachuanghu(String name) {
        super();
        this.name = name;
    }
    @Override
    //线程体 实现线程功能
    public void run() {
        int len=100;
        while(len>0) {
            len-=1;
               System.out.println(name+"在擦窗户！");
            }
    }
}

我们来用一个多线程卖票程序来说一下多线程的同步和异步

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        new Thread(new SailWindow(),"窗口一").start();
        new Thread(new SailWindow(),"窗口二").start();
        new Thread(new SailWindow(),"窗口三").start();
        new Thread(new SailWindow(),"窗口四").start();
    }
}

class SailWindow implements Runnable{
    static int tickets=100;

    @Override
    public void run() {
        // TODO Auto-generated method stub

        while(tickets>0) {
            System.out.println(Thread.currentThread().getName()+"正在卖出第"+tickets--+"张票！");
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

}

输出：

  1 窗口二正在卖出第100张票！
  2 窗口四正在卖出第97张票！
  3 窗口三正在卖出第98张票！
  4 窗口一正在卖出第99张票！
  5 窗口四正在卖出第96张票！
  6 窗口二正在卖出第94张票！
  7 窗口三正在卖出第95张票！
  8 窗口一正在卖出第93张票！
  9 窗口四正在卖出第92张票！
 10 窗口三正在卖出第91张票！
 11 窗口二正在卖出第90张票！
 12 窗口一正在卖出第89张票！
 13 窗口四正在卖出第88张票！
 14 窗口二正在卖出第87张票！
 15 窗口三正在卖出第87张票！
 16 窗口一正在卖出第86张票！
 17 窗口二正在卖出第85张票！
 18 窗口四正在卖出第84张票！
 19 窗口三正在卖出第83张票！
 20 窗口二正在卖出第82张票！
 21 窗口四正在卖出第80张票！
 22 窗口三正在卖出第81张票！
 23 窗口一正在卖出第79张票！
 24 窗口二正在卖出第78张票！
 25 窗口三正在卖出第77张票！
 26 窗口四正在卖出第76张票！
 27 窗口一正在卖出第75张票！
 28 窗口二正在卖出第74张票！
 29 窗口四正在卖出第71张票！
 30 窗口一正在卖出第72张票！
 31 窗口三正在卖出第73张票！
 32 窗口二正在卖出第70张票！
 33 窗口一正在卖出第70张票！
 34 窗口四正在卖出第70张票！
 35 窗口三正在卖出第70张票！
 36 窗口二正在卖出第69张票！
 37 窗口四正在卖出第66张票！
 38 窗口三正在卖出第67张票！
 39 窗口一正在卖出第68张票！
 40 窗口三正在卖出第64张票！
 41 窗口二正在卖出第65张票！
 42 窗口一正在卖出第65张票！
 43 窗口四正在卖出第65张票！
 44 窗口三正在卖出第63张票！
 45 窗口二正在卖出第61张票！
 46 窗口四正在卖出第63张票！
 47 窗口一正在卖出第62张票！
 48 窗口三正在卖出第60张票！
 49 窗口四正在卖出第58张票！
 50 窗口一正在卖出第58张票！
 51 窗口二正在卖出第59张票！
 52 窗口四正在卖出第57张票！
 53 窗口一正在卖出第55张票！
 54 窗口二正在卖出第55张票！
 55 窗口三正在卖出第56张票！
 56 窗口四正在卖出第54张票！
 57 窗口三正在卖出第52张票！
 58 窗口二正在卖出第52张票！
 59 窗口一正在卖出第53张票！
 60 窗口三正在卖出第51张票！
 61 窗口一正在卖出第50张票！
 62 窗口二正在卖出第49张票！
 63 窗口四正在卖出第50张票！
 64 窗口四正在卖出第48张票！
 65 窗口二正在卖出第46张票！
 66 窗口一正在卖出第45张票！
 67 窗口三正在卖出第47张票！
 68 窗口四正在卖出第44张票！
 69 窗口一正在卖出第42张票！
 70 窗口三正在卖出第42张票！
 71 窗口二正在卖出第43张票！
 72 窗口四正在卖出第41张票！
 73 窗口一正在卖出第38张票！
 74 窗口三正在卖出第39张票！
 75 窗口二正在卖出第40张票！
 76 窗口三正在卖出第37张票！
 77 窗口二正在卖出第35张票！
 78 窗口一正在卖出第35张票！
 79 窗口四正在卖出第36张票！
 80 窗口四正在卖出第34张票！
 81 窗口一正在卖出第32张票！
 82 窗口二正在卖出第31张票！
 83 窗口三正在卖出第33张票！
 84 窗口四正在卖出第30张票！
 85 窗口一正在卖出第29张票！
 86 窗口二正在卖出第28张票！
 87 窗口三正在卖出第28张票！
 88 窗口四正在卖出第27张票！
 89 窗口三正在卖出第26张票！
 90 窗口一正在卖出第26张票！
 91 窗口二正在卖出第25张票！
 92 窗口四正在卖出第24张票！
 93 窗口二正在卖出第22张票！
 94 窗口三正在卖出第23张票！
 95 窗口一正在卖出第22张票！
 96 窗口一正在卖出第21张票！
 97 窗口四正在卖出第20张票！
 98 窗口三正在卖出第19张票！
 99 窗口二正在卖出第19张票！
100 窗口一正在卖出第18张票！
101 窗口三正在卖出第17张票！
102 窗口二正在卖出第16张票！
103 窗口四正在卖出第16张票！
104 窗口四正在卖出第15张票！
105 窗口二正在卖出第12张票！
106 窗口一正在卖出第14张票！
107 窗口三正在卖出第13张票！
108 窗口一正在卖出第11张票！
109 窗口二正在卖出第10张票！
110 窗口三正在卖出第10张票！
111 窗口四正在卖出第11张票！
112 窗口四正在卖出第9张票！
113 窗口三正在卖出第6张票！
114 窗口一正在卖出第8张票！
115 窗口二正在卖出第7张票！
116 窗口三正在卖出第5张票！
117 窗口二正在卖出第3张票！
118 窗口一正在卖出第3张票！
119 窗口四正在卖出第4张票！
120 窗口四正在卖出第2张票！
121 窗口三正在卖出第0张票！
122 窗口一正在卖出第-1张票！
123 窗口二正在卖出第1张票！

你会发现输出的结果竟然还有卖出第-1张票，这就是没有进行同步处理引发的。

因为tickets是一个类变量，所以所有进程都共用这一个变量。

有可能有好多线程访问tickets的值的时候tickets大于0，但是这个时候可能对于一个线程来说它还没有对tickets-=1，也就是还没有更新tickets的值。这个时候就会发生上面的问题。

解决同步问题可以使用关键字synchronized或者是java.util.concurrent.locks的lock来实现同步访问。

下面给出使用关键字synchronized同步访问的示例：

public class Main {

//非同步
    static void method(Thread thread) {
        System.out.println("begin " + thread.getName());
        try {
            Thread.sleep(2000);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        System.out.println("end " + thread.getName());
    }

//同步方式一：同步方法
    synchronized static void method1(Thread thread) {// 这个方法是同步的方法，每次只有一
//个线程可以进来
        System.out.println("begin " + thread.getName());
        try {
            Thread.sleep(2000);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        System.out.println("end " + thread.getName());
    }

//同步方式二：同步代码块
    static void method2(Thread thread) {
        synchronized (Main.class) {
            System.out.println("begin " + thread.getName());
            try {
                Thread.sleep(2000);
            } catch (Exception ex) {
                ex.printStackTrace();
            }
            System.out.println("end " + thread.getName());
        }
    }

//同步方式三：使用同步对象锁
    private static Object _lock1 = new Object();
    private static byte _lock2[] = {};// 据说，此锁更可提高性能。源于：锁的对象越小越好

    static void method3(Thread thread) {
        synchronized (_lock1) {
            System.out.println("begin " + thread.getName());
            try {
                Thread.sleep(2000);
            } catch (Exception ex) {
                ex.printStackTrace();
            }
            System.out.println("end " + thread.getName());
        }
    }

    public static void main(String[] args) {
//启动3个线程，这里用了匿名类
        for (int i = 0; i < 3; i++) {
            new Thread() {
                public void run() {
                    method(this);
//method1(this);
//method2(this);
//method3(this);
                }
            }.start();
        }
    }
}

通过java.util.concurrent.locks的lock来实现同步访问（原文链接：https://www.cnblogs.com/dolphin0520/p/3923167.html）

下面内容为转载--------------------------------------------------------------------------------------------------------------------

------------------------------------------------------------------------------------------------------------------------------------------

在上一篇文章中我们讲到了如何使用关键字synchronized来实现同步访问。本文我们继续来探讨这个问题，从Java 5之后，在java.util.concurrent.locks包下提供了另外一种方式来实现同步访问，那就是Lock。

　　也许有朋友会问，既然都可以通过synchronized来实现同步访问了，那么为什么还需要提供Lock？这个问题将在下面进行阐述。本文先从synchronized的缺陷讲起，然后再讲述java.util.concurrent.locks包下常用的有哪些类和接口，最后讨论以下一些关于锁的概念方面的东西

　　以下是本文目录大纲：

　　一.synchronized的缺陷

　　二.java.util.concurrent.locks包下常用的类

　　三.锁的相关概念介绍

　　若有不正之处请多多谅解，并欢迎批评指正。

　　请尊重作者劳动成果，转载请标明原文链接：

　　http://www.cnblogs.com/dolphin0520/p/3923167.html

一.synchronized的缺陷

　　synchronized是java中的一个关键字，也就是说是Java语言内置的特性。那么为什么会出现Lock呢？

　　在上面一篇文章中，我们了解到如果一个代码块被synchronized修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只会有两种情况：

　　1）获取锁的线程执行完了该代码块，然后线程释放对锁的占有；

　　2）线程执行发生异常，此时JVM会让线程自动释放锁。

　　那么如果这个获取锁的线程由于要等待IO或者其他原因（比如调用sleep方法）被阻塞了，但是又没有释放锁，其他线程便只能干巴巴地等待，试想一下，这多么影响程序执行效率。

　　因此就需要有一种机制可以不让等待的线程一直无期限地等待下去（比如只等待一定的时间或者能够响应中断），通过Lock就可以办到。

　　再举个例子：当有多个线程读写文件时，读操作和写操作会发生冲突现象，写操作和写操作会发生冲突现象，但是读操作和读操作不会发生冲突现象。

　　但是采用synchronized关键字来实现同步的话，就会导致一个问题：

　　如果多个线程都只是进行读操作，所以当一个线程在进行读操作时，其他线程只能等待无法进行读操作。

　　因此就需要一种机制来使得多个线程都只是进行读操作时，线程之间不会发生冲突，通过Lock就可以办到。

　　另外，通过Lock可以知道线程有没有成功获取到锁。这个是synchronized无法办到的。

　　总结一下，也就是说Lock提供了比synchronized更多的功能。但是要注意以下几点：

　　1）Lock不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性。Lock是一个类，通过这个类可以实现同步访问；

　　2）Lock和synchronized有一点非常大的不同，采用synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；而Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。

二.java.util.concurrent.locks包下常用的类

　　下面我们就来探讨一下java.util.concurrent.locks包中常用的类和接口。

　　1.Lock

　　首先要说明的就是Lock，通过查看Lock的源码可知，Lock是一个接口：

public interface Lock {
    void lock();
    void lockInterruptibly() throws InterruptedException;
    boolean tryLock();
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    void unlock();
    Condition newCondition();
}

下面来逐个讲述Lock接口中每个方法的使用，lock()、tryLock()、tryLock(long time, TimeUnit unit)和lockInterruptibly()是用来获取锁的。unLock()方法是用来释放锁的。newCondition()这个方法暂且不在此讲述，会在后面的线程协作一文中讲述。

　　在Lock中声明了四个方法来获取锁，那么这四个方法有何区别呢？

　　首先lock()方法是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。

　　由于在前面讲到如果采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用Lock必须在try{}catch{}块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。通常使用Lock来进行同步的话，是以下面这种形式去使用的：

Lock lock = ...;
lock.lock();
try{
    //处理任务
}catch(Exception ex){

}finally{
    lock.unlock();   //释放锁
}

　　tryLock()方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false，也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。

　　tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的，只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false。如果如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。

　　所以，一般情况下通过tryLock来获取锁时是这样使用的：

Lock lock = ...;
if(lock.tryLock()) {
     try{
         //处理任务
     }catch(Exception ex){

     }finally{
         lock.unlock();   //释放锁
     }
}else {
    //如果不能获取锁，则直接做其他事情
}

lockInterruptibly()方法比较特殊，当通过这个方法去获取锁时，如果线程正在等待获取锁，则这个线程能够响应中断，即中断线程的等待状态。也就使说，当两个线程同时通过lock.lockInterruptibly()想获取某个锁时，假若此时线程A获取到了锁，而线程B只有在等待，那么对线程B调用threadB.interrupt()方法能够中断线程B的等待过程。

　　由于lockInterruptibly()的声明中抛出了异常，所以lock.lockInterruptibly()必须放在try块中或者在调用lockInterruptibly()的方法外声明抛出InterruptedException。

　　因此lockInterruptibly()一般的使用形式如下：

public void method() throws InterruptedException {
    lock.lockInterruptibly();
    try {
     //.....
    }
    finally {
        lock.unlock();
    }
}

注意，当一个线程获取了锁之后，是不会被interrupt()方法中断的。因为本身在前面的文章中讲过单独调用interrupt()方法不能中断正在运行过程中的线程，只能中断阻塞过程中的线程。

　　因此当通过lockInterruptibly()方法获取某个锁时，如果不能获取到，只有进行等待的情况下，是可以响应中断的。

　　而用synchronized修饰的话，当一个线程处于等待某个锁的状态，是无法被中断的，只有一直等待下去。

　　2.ReentrantLock

　　ReentrantLock，意思是“可重入锁”，关于可重入锁的概念在下一节讲述。ReentrantLock是唯一实现了Lock接口的类，并且ReentrantLock提供了更多的方法。下面通过一些实例看具体看一下如何使用ReentrantLock。

　　例子1，lock()的正确使用方法

java中main方法所在的类的实例化问题

有main方法的类和其它类在使用上没有区别。方法自己本身比较特殊， main方法是程序入口，也就是说生成了main方法那么就表示这个应用程序从main方法里面开始执行，仅此而已。
为什么没有实例化,因为你这个类没有被使用到，如果这个类本身包含其他方法，并且你在main里面要调用到，那么这个类肯定需要实例化才能调用
main方法的局部变量怎么调用?跟其他方法一样，局部变量在main方法内可以任意调用。
什么情况才会实例化main方法所在的类，只要你要使用这个类里面的非静态方法、非静态变量就一定会要实例化。

public class Test {
    private ArrayList<Integer> arrayList = new ArrayList<Integer>();
    public static void main(String[] args)  {
        final Test test = new Test();

        new Thread(){
            public void run() {
                test.insert(Thread.currentThread());
            };
        }.start();

        new Thread(){
            public void run() {
                test.insert(Thread.currentThread());
            };
        }.start();
    }  

    public void insert(Thread thread) {
        Lock lock = new ReentrantLock();    //注意这个地方
        lock.lock();
        try {
            System.out.println(thread.getName()+"得到了锁");
            for(int i=0;i<5;i++) {
                arrayList.add(i);
            }
        } catch (Exception e) {
            // TODO: handle exception
        }finally {
            System.out.println(thread.getName()+"释放了锁");
            lock.unlock();
        }
    }
}

输出：

Thread-0得到了锁
Thread-1得到了锁
Thread-0释放了锁
Thread-1释放了锁

也许有朋友会问，怎么会输出这个结果？第二个线程怎么会在第一个线程释放锁之前得到了锁？原因在于，在insert方法中的lock变量是局部变量，每个线程执行该方法时都会保存一个副本，那么理所当然每个线程执行到lock.lock()处获取的是不同的锁，所以就不会发生冲突。

　　知道了原因改起来就比较容易了，只需要将lock声明为类的属性即可。

public class Test {
    private ArrayList<Integer> arrayList = new ArrayList<Integer>();
    private Lock lock = new ReentrantLock();    //注意这个地方
    public static void main(String[] args)  {
        final Test test = new Test();

        new Thread(){
            public void run() {
                test.insert(Thread.currentThread());
            };
        }.start();

        new Thread(){
            public void run() {
                test.insert(Thread.currentThread());
            };
        }.start();
    }  

    public void insert(Thread thread) {
        lock.lock();
        try {
            System.out.println(thread.getName()+"得到了锁");
            for(int i=0;i<5;i++) {
                arrayList.add(i);
            }
        } catch (Exception e) {
            // TODO: handle exception
        }finally {
            System.out.println(thread.getName()+"释放了锁");
            lock.unlock();
        }
    }
}

这样就是正确地使用Lock的方法了。

　　例子2，tryLock()的使用方法

public class Test {
    private ArrayList<Integer> arrayList = new ArrayList<Integer>();
    private Lock lock = new ReentrantLock();    //注意这个地方
    public static void main(String[] args)  {
        final Test test = new Test();

        new Thread(){
            public void run() {
                test.insert(Thread.currentThread());
            };
        }.start();

        new Thread(){
            public void run() {
                test.insert(Thread.currentThread());
            };
        }.start();
    }  

    public void insert(Thread thread) {
        if(lock.tryLock()) {
            try {
                System.out.println(thread.getName()+"得到了锁");
                for(int i=0;i<5;i++) {
                    arrayList.add(i);
                }
            } catch (Exception e) {
                // TODO: handle exception
            }finally {
                System.out.println(thread.getName()+"释放了锁");
                lock.unlock();
            }
        } else {
            System.out.println(thread.getName()+"获取锁失败");
        }
    }
}

输出：

Thread-0得到了锁
Thread-1获取锁失败
Thread-0释放了锁

例子3，lockInterruptibly()响应中断的使用方法：

public class Test {
    private Lock lock = new ReentrantLock();
    public static void main(String[] args)  {
        Test test = new Test();
        MyThread thread1 = new MyThread(test);
        MyThread thread2 = new MyThread(test);
        thread1.start();
        thread2.start();

        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread2.interrupt();
    }  

    public void insert(Thread thread) throws InterruptedException{
        lock.lockInterruptibly();   //注意，如果需要正确中断等待锁的线程，必须将获取锁放在外面，然后将InterruptedException抛出
        try {
            System.out.println(thread.getName()+"得到了锁");
            long startTime = System.currentTimeMillis();
            for(    ;     ;) {
                if(System.currentTimeMillis() - startTime >= Integer.MAX_VALUE)
                    break;
                //插入数据
            }
        }
        finally {
            System.out.println(Thread.currentThread().getName()+"执行finally");
            lock.unlock();
            System.out.println(thread.getName()+"释放了锁");
        }
    }
}

class MyThread extends Thread {
    private Test test = null;
    public MyThread(Test test) {
        this.test = test;
    }
    @Override
    public void run() {

        try {
            test.insert(Thread.currentThread());
        } catch (InterruptedException e) {
            System.out.println(Thread.currentThread().getName()+"被中断");
        }
    }
}

运行之后，发现thread2能够被正确中断。

　　3.ReadWriteLock

　　ReadWriteLock也是一个接口，在它里面只定义了两个方法：

public interface ReadWriteLock {
    /**
     * Returns the lock used for reading.
     *
     * @return the lock used for reading.
     */
    Lock readLock();

    /**
     * Returns the lock used for writing.
     *
     * @return the lock used for writing.
     */
    Lock writeLock();
}

　　一个用来获取读锁，一个用来获取写锁。也就是说将文件的读写操作分开，分成2个锁来分配给线程，从而使得多个线程可以同时进行读操作。下面的ReentrantReadWriteLock实现了ReadWriteLock接口。

　　4.ReentrantReadWriteLock

　　ReentrantReadWriteLock里面提供了很多丰富的方法，不过最主要的有两个方法：readLock()和writeLock()用来获取读锁和写锁。

　　下面通过几个例子来看一下ReentrantReadWriteLock具体用法。

　　假如有多个线程要同时进行读操作的话，先看一下synchronized达到的效果：

public class Test {
    private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

    public static void main(String[] args)  {
        final Test test = new Test();

        new Thread(){
            public void run() {
                test.get(Thread.currentThread());
            };
        }.start();

        new Thread(){
            public void run() {
                test.get(Thread.currentThread());
            };
        }.start();

    }  

    public synchronized void get(Thread thread) {
        long start = System.currentTimeMillis();
        while(System.currentTimeMillis() - start <= 1) {
            System.out.println(thread.getName()+"正在进行读操作");
        }
        System.out.println(thread.getName()+"读操作完毕");
    }
}

这段程序的输出结果会是，直到thread1执行完读操作之后，才会打印thread2执行读操作的信息。

 1 Thread-0正在进行读操作
 2 Thread-0正在进行读操作
 3 Thread-0正在进行读操作
 4 Thread-0正在进行读操作
 5 Thread-0正在进行读操作
 6 Thread-0正在进行读操作
 7 Thread-0正在进行读操作
 8 Thread-0正在进行读操作
 9 Thread-0正在进行读操作
10 Thread-0正在进行读操作
11 Thread-0正在进行读操作
12 Thread-0正在进行读操作
13 Thread-0正在进行读操作
14 Thread-0正在进行读操作
15 Thread-0正在进行读操作
16 Thread-0正在进行读操作
17 Thread-0正在进行读操作
18 Thread-0正在进行读操作
19 Thread-0正在进行读操作
20 Thread-0正在进行读操作
21 Thread-0正在进行读操作
22 Thread-0正在进行读操作
23 Thread-0正在进行读操作
24 Thread-0正在进行读操作
25 Thread-0正在进行读操作
26 Thread-0正在进行读操作
27 Thread-0正在进行读操作
28 Thread-0正在进行读操作
29 Thread-0读操作完毕
30 Thread-1正在进行读操作
31 Thread-1正在进行读操作
32 Thread-1正在进行读操作
33 Thread-1正在进行读操作
34 Thread-1正在进行读操作
35 Thread-1正在进行读操作
36 Thread-1正在进行读操作
37 Thread-1正在进行读操作
38 Thread-1正在进行读操作
39 Thread-1正在进行读操作
40 Thread-1正在进行读操作
41 Thread-1正在进行读操作
42 Thread-1正在进行读操作
43 Thread-1正在进行读操作
44 Thread-1正在进行读操作
45 Thread-1正在进行读操作
46 Thread-1正在进行读操作
47 Thread-1正在进行读操作
48 Thread-1正在进行读操作
49 Thread-1正在进行读操作
50 Thread-1正在进行读操作
51 Thread-1正在进行读操作
52 Thread-1正在进行读操作
53 Thread-1正在进行读操作
54 Thread-1正在进行读操作
55 Thread-1正在进行读操作
56 Thread-1正在进行读操作
57 Thread-1正在进行读操作
58 Thread-1正在进行读操作
59 Thread-1正在进行读操作
60 Thread-1正在进行读操作
61 Thread-1正在进行读操作
62 Thread-1正在进行读操作
63 Thread-1正在进行读操作
64 Thread-1正在进行读操作
65 Thread-1正在进行读操作
66 Thread-1正在进行读操作
67 Thread-1正在进行读操作
68 Thread-1正在进行读操作
69 Thread-1正在进行读操作
70 Thread-1正在进行读操作
71 Thread-1正在进行读操作
72 Thread-1正在进行读操作
73 Thread-1读操作完毕

而改成用读写锁的话：

public class Test {
    private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

    public static void main(String[] args)  {
        final Test test = new Test();

        new Thread(){
            public void run() {
                test.get(Thread.currentThread());
            };
        }.start();

        new Thread(){
            public void run() {
                test.get(Thread.currentThread());
            };
        }.start();

    }  

    public void get(Thread thread) {
        rwl.readLock().lock();
        try {
            long start = System.currentTimeMillis();

            while(System.currentTimeMillis() - start <= 1) {
                System.out.println(thread.getName()+"正在进行读操作");
            }
            System.out.println(thread.getName()+"读操作完毕");
        } finally {
            rwl.readLock().unlock();
        }
    }
}

输出：

 1 Thread-0正在进行读操作
 2 Thread-0正在进行读操作
 3 Thread-1正在进行读操作
 4 Thread-0正在进行读操作
 5 Thread-1正在进行读操作
 6 Thread-0正在进行读操作
 7 Thread-1正在进行读操作
 8 Thread-1正在进行读操作
 9 Thread-1正在进行读操作
10 Thread-1正在进行读操作
11 Thread-1正在进行读操作
12 Thread-1正在进行读操作
13 Thread-0正在进行读操作
14 Thread-0正在进行读操作
15 Thread-0正在进行读操作
16 Thread-0正在进行读操作
17 Thread-1正在进行读操作
18 Thread-1正在进行读操作
19 Thread-1正在进行读操作
20 Thread-1正在进行读操作
21 Thread-0正在进行读操作
22 Thread-1正在进行读操作
23 Thread-1正在进行读操作
24 Thread-0正在进行读操作
25 Thread-1正在进行读操作
26 Thread-1正在进行读操作
27 Thread-0正在进行读操作
28 Thread-1正在进行读操作
29 Thread-1正在进行读操作
30 Thread-1正在进行读操作
31 Thread-0正在进行读操作
32 Thread-1正在进行读操作
33 Thread-1正在进行读操作
34 Thread-0正在进行读操作
35 Thread-1正在进行读操作
36 Thread-0正在进行读操作
37 Thread-1正在进行读操作
38 Thread-0正在进行读操作
39 Thread-1正在进行读操作
40 Thread-0正在进行读操作
41 Thread-1正在进行读操作
42 Thread-0正在进行读操作
43 Thread-1正在进行读操作
44 Thread-0正在进行读操作
45 Thread-1正在进行读操作
46 Thread-0正在进行读操作
47 Thread-1正在进行读操作
48 Thread-0读操作完毕
49 Thread-1读操作完毕

说明thread1和thread2在同时进行读操作。

　　这样就大大提升了读操作的效率。

　　不过要注意的是，如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。

　　如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，则申请的线程会一直等待释放写锁。

　　关于ReentrantReadWriteLock类中的其他方法感兴趣的朋友可以自行查阅API文档。

　　5.Lock和synchronized的选择

　　总结来说，Lock和synchronized有以下几点不同：

　　1）Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；

　　2）synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；

　　3）Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；

　　4）通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。

　　5）Lock可以提高多个线程进行读操作的效率。

　　在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。所以说，在具体使用时要根据适当情况选择。

三.锁的相关概念介绍

　　在前面介绍了Lock的基本使用，这一节来介绍一下与锁相关的几个概念。

　　1.可重入锁

　　如果锁具备可重入性，则称作为可重入锁。像synchronized和ReentrantLock都是可重入锁，可重入性在我看来实际上表明了锁的分配机制：基于线程的分配，而不是基于方法调用的分配。举个简单的例子，当一个线程执行到某个synchronized方法时，比如说method1，而在method1中会调用另外一个synchronized方法method2，此时线程不必重新去申请锁，而是可以直接执行方法method2。

　　看下面这段代码就明白了：

class MyClass {
    public synchronized void method1() {
        method2();
    }

    public synchronized void method2() {

    }
}

　　上述代码中的两个方法method1和method2都用synchronized修饰了，假如某一时刻，线程A执行到了method1，此时线程A获取了这个对象的锁，而由于method2也是synchronized方法，假如synchronized不具备可重入性，此时线程A需要重新申请锁。但是这就会造成一个问题，因为线程A已经持有了该对象的锁，而又在申请获取该对象的锁，这样就会线程A一直等待永远不会获取到的锁。

　　而由于synchronized和Lock都具备可重入性，所以不会发生上述现象。

　　2.可中断锁

　　可中断锁：顾名思义，就是可以相应中断的锁。

　　在Java中，synchronized就不是可中断锁，而Lock是可中断锁。

　　如果某一线程A正在执行锁中的代码，另一线程B正在等待获取该锁，可能由于等待时间过长，线程B不想等待了，想先处理其他事情，我们可以让它中断自己或者在别的线程中中断它，这种就是可中断锁。

　　在前面演示lockInterruptibly()的用法时已经体现了Lock的可中断性。

　　3.公平锁

　　公平锁即尽量以请求锁的顺序来获取锁。比如同是有多个线程在等待一个锁，当这个锁被释放时，等待时间最久的线程（最先请求的线程）会获得该所，这种就是公平锁。

　　非公平锁即无法保证锁的获取是按照请求锁的顺序进行的。这样就可能导致某个或者一些线程永远获取不到锁。

　　在Java中，synchronized就是非公平锁，它无法保证等待的线程获取锁的顺序。

　　而对于ReentrantLock和ReentrantReadWriteLock，它默认情况下是非公平锁，但是可以设置为公平锁。

　　看一下这2个类的源代码就清楚了：

　　在ReentrantLock中定义了2个静态内部类，一个是NotFairSync，一个是FairSync，分别用来实现非公平锁和公平锁。

　　我们可以在创建ReentrantLock对象时，通过以下方式来设置锁的公平性：

ReentrantLock lock = new ReentrantLock(true);

如果参数为true表示为公平锁，为fasle为非公平锁。默认情况下，如果使用无参构造器，则是非公平锁。

另外在ReentrantLock类中定义了很多方法，比如：

　　isFair()        //判断锁是否是公平锁

　　isLocked()    //判断锁是否被任何线程获取了

　　isHeldByCurrentThread()   //判断锁是否被当前线程获取了

　　hasQueuedThreads()   //判断是否有线程在等待该锁

　　在ReentrantReadWriteLock中也有类似的方法，同样也可以设置为公平锁和非公平锁。不过要记住，ReentrantReadWriteLock并未实现Lock接口，它实现的是ReadWriteLock接口。

　　4.读写锁

　　读写锁将对一个资源（比如文件）的访问分成了2个锁，一个读锁和一个写锁。

　　正因为有了读写锁，才使得多个线程之间的读操作不会发生冲突。

　　ReadWriteLock就是读写锁，它是一个接口，ReentrantReadWriteLock实现了这个接口。

　　可以通过readLock()获取读锁，通过writeLock()获取写锁。

　　上面已经演示过了读写锁的使用方法，在此不再赘述。

　　参考资料：

　　http://blog.csdn.net/ns_code/article/details/17487337

　　http://houlinyan.iteye.com/blog/1112535

　　http://ifeve.com/locks/

　　http://ifeve.com/read-write-locks/

　　http://blog.csdn.net/fancyerii/article/details/6783224

　　http://blog.csdn.net/ghsau/article/details/7461369/

　　http://blog.csdn.net/zhaozhenzuo/article/details/37109015

作者：Matrix海子

　　　　

出处：http://www.cnblogs.com/dolphin0520/

　　　　

本博客中未标明转载的文章归作者Matrix海子和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。