线程高级篇-Lock锁和Condition条件
参考：Java并发编程实战P252
浅谈Synchronized:
synchronized是Java的一个关键字,也就是Java语言内置的特性,如果一个代码块被synchronized修饰了,当一个线程获取了对应的锁,执行代码块时,其他线程
便只能一直等待,等待获取锁的线程释放锁,而获取锁的线程释放锁会有三种情况:
1).获取锁的线程执行完该代码块,然后线程释放对锁的占有;
2).线程执行发生异常,此时JVM会让线程自动释放锁;
3).调用wait方法,在等待的时候立即释放锁,方便其他的线程使用锁.
Lock的特性:
1).Lock不是Java语言内置的;
2).synchronized是在JVM层面上实现的,如果代码执行出现异常,JVM会自动释放锁,但是Lock不行,要保证锁一定会被释放,就必须将unLock放到finally{}中(手动释放);
3).在资源竞争不是很激烈的情况下,Synchronized的性能要优于ReetarntLock,但是在很激烈的情况下,synchronized的性能会下降几十倍;
4).ReentrantLock增加了锁:
// 无条件的锁;
a. void lock();
//可中断的锁;
b. void lockInterruptibly throws InterruptedException;
//解释:使用ReentrantLock如果获取了锁立即返回,
//如果没有获取锁,当前线程处于休眠状态,直到获得锁或者当前线程可以被别的线程中断去做其他的事情;
//但是如果是synchronized的话,如果没有获取到锁,则会一直等待下去;
//如果获取了锁立即返回true,如果别的线程正持有,立即返回false,不会等待;
c. boolean tryLock();
//如果获取了锁立即返回true,如果别的线程正持有锁,会等待参数给的时间,
//在等待的过程中,如果获取锁,则返回true,如果等待超时,返回false;
d. boolean tryLock(long timeout,TimeUnit unit);
Condition的特性:
1.Condition中的await()方法相当于Object的wait()方法，Condition中的signal()方法相当于Object的notify()方法，Condition中的signalAll()相当于Object的notifyAll()方法。不同的是，Object中的这些方法是和同步锁捆绑使用的；而Condition是需要与互斥锁/共享锁捆绑使用的。
2.Condition它更强大的地方在于：能够更加精细的控制多线程的休眠与唤醒。对于同一个锁，我们可以创建多个Condition，在不同的情况下使用不同的Condition。
例如，假如多线程读/写同一个缓冲区：当向缓冲区中写入数据之后，唤醒"读线程"；当从缓冲区读出数据之后，唤醒"写线程"；并且当缓冲区满的时候，"写线程"需要等待；当缓冲区为空时，"读线程"需要等待。
如果采用Object类中的wait(), notify(), notifyAll()实现该缓冲区，当向缓冲区写入数据之后需要唤醒"读线程"时，不可能通过notify()或notifyAll()明确的指定唤醒"读线程"，而只能通过notifyAll唤醒所有线程(但是notifyAll无法区分唤醒的线程是读线程，还是写线程)。 但是，通过Condition，就能明确的指定唤醒读线程。
实例代码
Task
package ThreadSource.LockCondition;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
//显式的Condition对象 : 当使用显式的Lock和Condition时，也必须满足锁，条件谓词和条件变量之间的三元关系
//内置的条件队列，Object中的wait、notify、notifyAll方法构成了内部条件队列的API 内置锁Synchronized
public class Task
{
private final Lock lock = new ReentrantLock();
//两个条件谓词 非满 非空
//add数据
private final Condition addCondition = lock.newCondition();
//读取数据
private final Condition subCondition = lock.newCondition();
private static int num = 0;
private List<String> lists = new LinkedList<>();
public void put()
{
lock.lock();
try
{
//阻塞直到非满
//当集合已满,则"添加"线程等待
while (lists.size() == 10)
{
//写线程等待
addCondition.await();
}
num++;
lists.add("add boy" + num);
System.out.println("ADD：The lists size is " + lists.size());
System.out.println("The Current Thread is " + Thread.currentThread().getName());
System.out.println("******************************");
//唤醒
this.subCondition.signal();
} catch (InterruptedException e)
{
e.printStackTrace();
} finally
{
lock.unlock();
}
}
public void take()
{
lock.lock();
try
{
//阻塞直到非空
//当集合为空时,"减少"线程等待
while (lists.size() == 0)
{
//当缓冲区为空时，"读线程"需要等待。
subCondition.await();
}
String str = lists.get(0);
lists.remove(0);
System.out.println("SUB：The Boy is [" + str + "]");
System.out.println("The current thread is " + Thread.currentThread().getName());
System.out.println("************************");
num--;
addCondition.signal();
} catch (InterruptedException e)
{
e.printStackTrace();
} finally
{
lock.unlock();
}
}
}
AddThread
package ThreadSource.LockCondition;
public class AddThread implements Runnable
{
private Task task;
public AddThread(Task task)
{
this.task = task;
}
@Override
public void run()
{
task.put();
}
}
SubThread
package ThreadSource.LockCondition;
public class SubThread implements Runnable
{
private Task task;
public SubThread(Task task)
{
this.task = task;
}
@Override
public void run()
{
task.take();
}
}
TestLock
package ThreadSource.LockCondition;
public class TestLock
{
public static void main(String[] args)
{
Task task = new Task();
Thread t1 = new Thread(new Runnable()
{
@Override
public void run()
{
task.put();
}
});
Thread t3 = new Thread(new AddThread(task));
Thread t7 = new Thread(new AddThread(task));
Thread t8 = new Thread(new AddThread(task));
Thread t2 = new Thread(new SubThread(task));
Thread t4 = new Thread(new SubThread(task));
Thread t5 = new Thread(new SubThread(task));
Thread t6 = new Thread(new SubThread(task));
t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
t6.start();
t7.start();
t8.start();
}
}
