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