黑马程序员——JAVA笔记——LOCK

------- android培训、java培训、期待与您交流！ ----------

JDK1.5 中提供了多线程升级解决方案。

将同步Synchronized替换成显示Lock操作。

将Object中的wait，notify，notifyAll，替换成了Condition对象。

该对象可以通过Lock锁进行获取。

通过Lock lock=new ReentrantLock();获取锁对象。

用lock()和unlock()方法得到锁和释放锁。

lock和unlock中间就是同步区域，也就是说每次只能有一个线程进行操作。

class Outputter1 {    
    private Lock lock = new ReentrantLock();// 锁对象     
  
    public void output(String name) {           
        lock.lock();      // 得到锁     
  
        try {    
            for(int i = 0; i < name.length(); i++) {    
                System.out.print(name.charAt(i));    
            }    
        } finally {    
            lock.unlock();// 释放锁     
        }    
    }    
}

对于读写操作，lock中有一个ReadWriterLock用于处理读写操作的同步。

通过ReadWriteLock rw = new ReentrantReadWriteLock();获取读写锁。

通过rw.writeLock().lock();和rw.readLock().lock();得到锁。

再分别通过rw.writeLock().unlock();和w.readLock().unlock();释放锁。

以此来保证读写线程互不干扰。

Condition可以替代传统的线程间通信，用await()替换wait()，用signal()替换notify()，用signalAll()替换notifyAll()。

Condition是绑定在Lock上的所以要创建Condition对象要先创建Lock对象。

Condition cond=lock.newCondition();

Condition可以为多个线程间建立不同的Condition。

例：生产者消费者

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class Demo
{
	public static void main(String[] args)
	{
		Resource res=new Resource();
		Producer p=new Producer(res);
		Consumer c=new Consumer(res);
		Thread t1=new Thread(p);
		Thread t2=new Thread(p);
		Thread t3=new Thread(c);
		Thread t4=new Thread(c);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
		
	}
}

class Resource
{
	private String name;
	private int count=1;
	private  boolean flag=false;
	private Lock lock=new ReentrantLock();
//	private Condition con=lock.newCondition();
	private Condition cond_pro=lock.newCondition();
	private Condition cond_con=lock.newCondition();
	
	public void set(String name)throws InterruptedException
	{
		lock.lock();
		try
		{
			while(flag)
				cond_pro.await();
			this.name=name+"---"+count++;
			System.out.println(Thread.currentThread().getName()+"生产者"+this.name);
			flag=true;
			cond_con.signalAll();
		}
		finally
		{
			lock.unlock();
		}
	}
	
	public void out() throws InterruptedException
	{
		lock.lock();
		try{
			while(!flag)
				cond_con.await();
			System.out.println(Thread.currentThread().getName()+"消费者"+name);
			flag=false;
			cond_pro.signalAll();
		}
		finally
		{
			lock.unlock();
		}
	}
}

class Producer implements Runnable
{
	private Resource res;
	Producer(Resource res)
	{
		this.res=res;
	}
	
	public void run()
	{
		while(true)
		{
			try {
				res.set("+商品+");
			} catch (InterruptedException e) {

			}
		}
	}
}

class Consumer implements Runnable
{
	private Resource res;
	Consumer(Resource res)
	{
		this.res=res;
	}
	
	public void run()
	{
		while(true)
		{
			try {
				res.out();
			} catch (InterruptedException e) {

			}
		}
	}
}