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关键字一样。线程之间还是顺序执行的。