java多线程之-----Lock的使用

写这个主要是在魅族面试的时候被问到多线程同步的问题，我打可以使用Lock，但是那个面试官却说java中没有Lock这个东西。我一开始坚定有，后来只好说没有了。主要是自己只是看过，了解。不过这个面试也让自己知道了很多的不足吧。结果还没出，应该是挂了。

正题，在java多线程中，可以利用synchronized关键字来实现线程之间同步互斥，但在java1.5后，新增加了ReentranLock类也能达到同样的效果，并在扩展功能上也更加强大，比如嗅探锁定，多路分支通知功能，并在使用上也比synchronized更加的灵活。

使用reentrantLock实现同步：测试1

创建了MyService.java

public class Myservice {    private Lock lock = new ReentrantLock();    public void testMethod(){        lock.lock();        for(int i =0;i<5;i++){            System.out.println("threadname"+Thread.currentThread().getName()+"i="+i);        }        lock.unlock();    }}

tip：调用ReentranLockd对象的lock方法获取锁，调用unlock方法释放锁
创建类MyThread：

public class MyThread  extends Thread{    private Myservice myservice =  new Myservice();    public MyThread(Myservice myservice) {        // TODO Auto-generated constructor stub        super();        this.myservice = myservice;    }    @Override    public void run() {        // TODO Auto-generated method stub        super.run();        myservice.testMethod();    }}

运行测试类：‘

public class Run {    public static void main(String[] args) {        Myservice myservice =new Myservice();        MyThread a1 = new MyThread(myservice);        MyThread a2 = new MyThread(myservice);        MyThread a3= new MyThread(myservice);        MyThread a4 = new MyThread(myservice);        MyThread a5 = new MyThread(myservice);        a1.start();        a2.start();        a3.start();        a4.start();        a5.start();    }}

运行结果：

运行结果来看，点钱线程打印完毕后将锁进行释放，其他线程才可以继续打印，线程打印的数据是分组打印，因为当前线程已经持有锁，但线程之间打印的顺序是随机的。

使用ReentranLock实现同步2

创建Myservice.java类代码如下：

public class Myservice {    private Lock lock = new ReentrantLock();    public void methodA(){        try {            lock.lock();            System.out.println("methondA begin ThreadName"+Thread.currentThread().getName()+"time = " +System.currentTimeMillis());            Thread.sleep(5000);            System.out.println("methondA end ThreadName"+Thread.currentThread().getName()+"time = " +System.currentTimeMillis());        } catch (InterruptedException e) {            // TODO Auto-generated catch block            e.printStackTrace();        }finally{            lock.unlock();        }    }    public void methodB(){        try {            lock.lock();            System.out.println("methondB begin ThreadName"+Thread.currentThread().getName()+"time = " +System.currentTimeMillis());            Thread.sleep(5000);            System.out.println("methondB end ThreadName"+Thread.currentThread().getName()+"time = " +System.currentTimeMillis());        } catch (InterruptedException e) {            // TODO Auto-generated catch block            e.printStackTrace();        }finally{            lock.unlock();        }    }}

直接上运行代码

public class Run {    public static void main(String[] args) {        Myservice myservice =new Myservice();        Myservice myservice2 =new Myservice();        ThreadA a = new ThreadA(myservice);        a.setName("A");        ThreadAA aa = new ThreadAA(myservice);        aa.setName("AA");        ThreadB b= new ThreadB(myservice);        b.setName("B");        ThreadBB bb = new ThreadBB(myservice);        bb.setName("BB");        a.start();        aa.start();        b.start();        bb.start();     }}

运行结果

这个实验说明，调用lock.lock代码的线程就持有了“对象监视器”，其他线程只有等锁被释放时再次争抢，效果和synchronized关键字一样。线程之间还是顺序执行的。