Java 多线程Lock接口

Java 多线程Lock接口

​ 在并发编程中，我们可以通过使用关键字synchronized来实现同步访问。从Jdk1. 5之后，在java.util.concurrent.locks包下提供了另外一种方式来实现同步访问，那就是Lock。有那么问题来了，既然都可以通过synchronized来实现同步访问了，那么为什么还需要提供Lock？

synchronized的缺陷：

​ 一个代码块被synchronized修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只会有两种情况：

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

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

​ 关于synchronized同步机制，考虑一下下面这两种情况：

• 某个已经获得锁的线程由于要等待IO或者其他原因（比如调用sleep方法）被阻塞了，但是又没有释放锁，其他想要获取锁的线程便只能一直阻塞，直到获得锁的线程释放锁了才能进入到同步代码块。

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

• 当有多个线程读写文件时，读操作和写操作会发生冲突现象，写操作和写操作会发生冲突现象，但是读操作和读操作不会发生冲突现象。如果多个线程都只是进行读操作，当一个线程在进行读操作时，其他线程只能等待无法进行读操作。

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

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

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

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

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

使用Lock接口，以及其中的lock()方法和unlock()方法替代同步

import java.util.concurrent.locks.*; 
//描述资源。属性：商品名称和编号，  行为：对商品名称赋值，获取商品。
class Resource
{
	private String name;
	private int count = 1;
	private boolean flag = false;
	//创建锁对象
	Lock lock = new ReentrantLock();
	//对外提供设置商品的方法
	public  void set(String name)
	{
		//获取锁
		lock.lock();
		try{
			if(flag)
			{
				try{this.wait();}catch(InterruptedException e){}
			}
			//给成员变量赋值并加上编号。
			this.name = name + count;
			//编号自增。
			count++;
			//打印生产了哪个商品。
			System.out.println(Thread.currentThread().getName()+".....生产者...."+this.name);
			//将标记改为true。
			flag = true;
			//唤醒消费者。
			this.notify();
			}
		finally//由于锁的动作一定要释放，所以使用try-finally组合
		{
			//释放锁
			lock.unlock();
		}
	}
	public  void get()
	{
		//获取锁
		lock.lock();
		try{
			if(!flag)
			{
				try{this.wait();}catch(InterruptedException e){}
			}
			System.out.println(Thread.currentThread().getName()+".....消费者...."+this.name);
			//将标记改为false。
			flag = false;
			//唤醒生产者。
			this.notify();
		}
		finally//由于锁的动作一定要释放，所以使用try-finally组合
		{
			//释放锁
			lock.unlock();
		}
	}
}

在JDK1.5之前使用同步代码块，获取锁的释放锁都是隐式，改为JDK1.5Lock之后，锁的获取和释放都改为显示的。更人性化。其他代码仍然没有变。

Condition接口

上述代码虽然把锁换成了显示的锁，可是使用的等待和唤醒还是Object中的wait和notify，这就会导致锁和等待唤醒机制处于两个对象上，而我们想要的应该那个锁下的线程等待和唤醒，也就是等待和唤醒和锁有一定的关联关系。

已经将旧锁替换成新锁，那么锁上的监视器方法(wait，notify，notifyAll)也应该替换成新锁的监视器方法。

需要Condition对象的出现其实就是替代了Object中的监视器方法。

import java.util.concurrent.locks.*; 
//描述资源。属性：商品名称和编号，  行为：对商品名称赋值，获取商品。
class Resource
{
	private String name;
	private int count = 1;
	private boolean flag = false;
	//创建锁对象
	Lock lock = new ReentrantLock();
	//获取监视器对象，其实就是让锁和监视器关联起来
	Condition con = lock.newCondition();
	//对外提供设置商品的方法
	public  void set(String name)
	{
		//获取锁
		lock.lock();
		try{
			while(flag)
			{
				try{con.await();}catch(InterruptedException e){}
			}
			//给成员变量赋值并加上编号。
			this.name = name + count;
			//编号自增。
			count++;
			//打印生产了哪个商品。
			System.out.println(Thread.currentThread().getName()+".....生产者...."+this.name);
			//将标记改为true。
			flag = true;
			//唤醒消费者。
			con.signalAll();
			}
		finally//由于锁的动作一定要释放，所以使用try-finally组合
		{
			//释放锁
			lock.unlock();
		}
	}
	public  void get()
	{
		//获取锁
		lock.lock();
		try{
			while(!flag)
			{
				try{con.await();}catch(InterruptedException e){}
			}
			System.out.println(Thread.currentThread().getName()+".....消费者...."+this.name);
			//将标记改为false。
			flag = false;
			//唤醒生产者。
			con.signalAll();
		}
		finally//由于锁的动作一定要释放，所以使用try-finally组合
		{
			//释放锁
			lock.unlock();
		}
	}
}

将所有的监视器方法替换成了Condition。功能和之前的老程序的功能一样，仅仅是用新的对象。改了写法而已。但是问题依旧；效率还是低。

上述程序低效的原因是本方可能唤醒的是本方，而我们希望本方可以唤醒对方中的一个。

老程序中可以通过两个锁嵌套完成，但是容易引发死锁。新程序中，就可以解决这个问题，只用一个锁，在JDK1.5之后可以在一个锁上加上多个监视器对象。

class Resource
{
    private String name;
    private int count = 1;
    private boolean flag = false;
    //定义一个锁对象。
    private final Lock lock = new ReentrantLock();
    //获取锁上的Condition对象。为了解决本方唤醒对方的问题。可以一个锁创建两个监视器对象。
    private Condition produce = lock.newCondition();//负责生产。
    private Condition consume = lock.newCondition();//负责消费。
    //对外提供设置商品的方法
    public  void set(String name)
    {
        //获取锁
        lock.lock();
        try{
            while(flag)
            {
                try{produce.await();}catch(InterruptedException e){}
            }
            //给成员变量赋值并加上编号。
            this.name = name + count;
            //编号自增。
            count++;
            //打印生产了哪个商品。
            System.out.println(Thread.currentThread().getName()+".....生产者...."+this.name);
            //将标记改为true。
            flag = true;
            //唤醒消费者。
            consume.signalAll();
        }
        finally//由于锁的动作一定要释放，所以使用try-finally组合
        {
            //释放锁
            lock.unlock();
        }
    }
    public  void get()
    {
        //获取锁
        lock.lock();
        try{
            while(!flag)
            {
                try{consume.await();}catch(InterruptedException e){}
            }
            System.out.println(Thread.currentThread().getName()+".....消费者...."+this.name);
            //将标记改为false。
            flag = false;
            //唤醒生产者。
            produce.signalAll();
        }
        finally//由于锁的动作一定要释放，所以使用try-finally组合
        {
            //释放锁
            lock.unlock();
        }
    }
}