1.概念
Lock比传统线程模型中的synchronized方式更加面向对象，与生活中的锁类似，锁本身也应该是一个对象。两个线程执行的代码片段要实现同步互斥的效果，它们必须用同一个Lock对象。
2.案例
package org.lkl.thread; import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock; public class LockFoo {
/**
* 两个线程打印姓名
*/ public static void main(String[] args) {
final Outputter out = new Outputter() ;
new Thread(new Runnable() { @Override
public void run() {
while(true){
try {
Thread.sleep() ;
out.print("zhangsan") ;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start(); new Thread(new Runnable() { @Override
public void run() {
while(true){
try {
Thread.sleep() ;
out.print("liaokailinliaokailinliaokailinliaokailinliaokailinliaokailin") ;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
} } class Outputter{
Lock lock = new ReentrantLock() ;
public void print(String name){
lock.lock() ; //加上锁 只有等到操作全完成以后才释放锁
try {
if(name!=null){
for(int i = ; i<name.length() ;i++){
System.out.print(name.charAt(i));
}
System.out.println();
}
}finally {
lock.unlock() ;//解锁 一般都在finally中解锁 不过程序是否有异常 最终都要解锁 否则会导致阻塞
}
}
}
3. 读写锁
读写锁：分为读锁和写锁，多个读锁不互斥，读锁与写锁互斥，这是由jvm自己控制的，你只要上好相应的锁即可。如果你的代码只读数据，可以很多人同时读，但不能同时写，那就上读锁；
如果你的代码修改数据，只能有一个人在写，且不能同时读取，那就上写锁。总之，读的时候上读锁，写的时候上写锁！
package cn.itcast.heima2; import java.util.Random;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock; public class ReadWriteLockTest {
public static void main(String[] args) {
final Queue3 q3 = new Queue3();
for(int i=;i<;i++)
{
new Thread(){
public void run(){
while(true){
q3.get();
}
} }.start(); new Thread(){
public void run(){
while(true){
q3.put(new Random().nextInt());
}
} }.start();
} }
} class Queue3{
private Object data = null;//共享数据，只能有一个线程能写该数据，但可以有多个线程同时读该数据。
ReadWriteLock rwl = new ReentrantReadWriteLock();
public void get(){
rwl.readLock().lock();
try {
System.out.println(Thread.currentThread().getName() + " be ready to read data!");
Thread.sleep((long)(Math.random()*));
System.out.println(Thread.currentThread().getName() + "have read data :" + data);
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
rwl.readLock().unlock();
}
} public void put(Object data){ rwl.writeLock().lock();
try {
System.out.println(Thread.currentThread().getName() + " be ready to write data!");
Thread.sleep((long)(Math.random()*));
this.data = data;
System.out.println(Thread.currentThread().getName() + " have write data: " + data);
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
rwl.writeLock().unlock();
} }
}
4. Condition
package org.lkl.thead.foo01; import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock; public class ConditionFoo {
/**
* 子线程先执行10次 然后主线程再执行20次 如此循环50次
*/
public static void main(String[] args) {
final Business b = new Business() ;
//子线程执行50次
for(int i = ;i<= ;i++){
final int seq = i ;
new Thread(new Runnable() { public void run() {
b.sub(seq) ;
}
}).start() ;
} //主线程执行50次
for(int i = ;i<= ;i++){
b.main(i) ;
} } } class Business{
boolean isSub = true ; Lock lock = new ReentrantLock() ;
Condition condition = lock.newCondition() ;
//子线程执行10次
public void sub(int j ){ //加lock以后不需要synchronized
lock.lock() ;
try {
while(!isSub){
try {
condition.await() ;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
for(int i = ;i<= ;i++){
System.out.println("sub thread execute times " + i + " loop of "+ j);
} isSub = false ;
condition.signalAll() ;
} finally {
lock.unlock() ;
} } //主线程执行20次
public void main(int j ){
lock.lock() ;
try {
while(isSub){
try {
condition.await() ;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
for(int i = ;i<= ;i++){
System.out.println("main thread execute times " + i + " loop of "+ j);
} isSub = true ;
// condition.signal() ;
condition.signalAll() ;
}finally {
lock.unlock() ;
}
}
}
5. 通过condition实现三个线程之间的通信
package cn.itcast.heima2; import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock; public class ThreeConditionCommunication { /**
* @param args
*/
public static void main(String[] args) { final Business business = new Business();
new Thread(
new Runnable() { @Override
public void run() { for(int i=;i<=;i++){
business.sub2(i);
} }
}
).start(); new Thread(
new Runnable() { @Override
public void run() { for(int i=;i<=;i++){
business.sub3(i);
} }
}
).start(); for(int i=;i<=;i++){
business.main(i);
} } static class Business {
Lock lock = new ReentrantLock();
Condition condition1 = lock.newCondition();
Condition condition2 = lock.newCondition();
Condition condition3 = lock.newCondition();
private int shouldSub = ;
public void sub2(int i){
lock.lock();
try{
while(shouldSub != ){
try {
condition2.await();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
for(int j=;j<=;j++){
System.out.println("sub2 thread sequence of " + j + ",loop of " + i);
}
shouldSub = ;
condition3.signal();
}finally{
lock.unlock();
}
} public void sub3(int i){
lock.lock();
try{
while(shouldSub != ){
try {
condition3.await();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
for(int j=;j<=;j++){
System.out.println("sub3 thread sequence of " + j + ",loop of " + i);
}
shouldSub = ;
condition1.signal();
}finally{
lock.unlock();
}
} public void main(int i){
lock.lock();
try{
while(shouldSub != ){
try {
condition1.await();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
for(int j=;j<=;j++){
System.out.println("main thread sequence of " + j + ",loop of " + i);
}
shouldSub = ;
condition2.signal();
}finally{
lock.unlock();
}
} }
}