java 多线程随笔（二）

继续上一篇文章，synchronized 的功能扩展，重入锁。

1. ReenterLock 重入锁
   为什么叫重入锁呢？因为锁是可以反复进入的，针对一个线程来说的
   与synchronized 比较写一下
   第一 ReenterLock 需要手动释放锁，synchronized 不需要
   第二 中断响应 对于synchronized 如果一个线程在等待，只有继续执行或等待，但是重入锁可以等待时，进行中断。
   reentrantLock.lockInterruptibly();//获得锁,优先中断
   第三 限时等待锁
   tryLock有二个参数 第一个是等待时长 第二个是单位
   例子 tryLock等待5秒 Thread获取锁6秒，所以例子请求锁失败。

mport java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

public class TryLockTest implements Runnable{
    private static ReentrantLock lock=new ReentrantLock();
    @Override
    public void run() {
        try {
            if(lock.tryLock(5, TimeUnit.SECONDS)) {
                Thread.sleep(6000);
            }else {
                System.out.println("get lock failed");
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if(lock.isHeldByCurrentThread()){
                lock.unlock();
            }
        }
    }
    public static void main(String args[]){
        TryLockTest test=new TryLockTest();
        Thread thread1=new Thread(test);
        Thread thread2=new Thread(test);
        thread1.start();
        thread2.start();
    }
}

第四 公平锁 例子

import java.util.concurrent.locks.ReentrantLock;


/**o
 1. 重入锁 与synchronized
 */
public class RelockTest implements Runnable{

    private static ReentrantLock reentrantLock=new ReentrantLock(true);//公平锁
    @Override
    public void run() {
        while (true) {
            try {
            reentrantLock.lockInterruptibly();//获得锁,优先中断
                //reentrantLock.lock();
                System.out.println(Thread.currentThread().getId()+"获得锁");
            } catch (InterruptedException e) {

            } finally {
                reentrantLock.unlock();
            }
        }
    }
    public static void main(String args[]){
        RelockTest relockTest= new RelockTest();
        Thread thread1=new Thread(relockTest, "tr1");
        Thread thread2=new Thread(relockTest, "tr2");
        thread1.start();
        thread2.start();
    }
}

就是两个线程可以公平的获取线程
2. Condition 条件

signal
void signal()唤醒一个等待线程。
如果所有的线程都在等待此条件，则选择其中的一个唤醒。在从 await 返回之前，该线程必须重新获取锁定。
上个例子:

作为一个示例，假定有一个绑定的缓冲区，它支持 put 和 take 方法。如果试图在空的缓冲区上执行 take 操作，则在某一个项变得可用之前，线程将一直阻塞；如果试图在满的缓冲区上执行 put 操作，则在有空间变得可用之前，线程将一直阻塞。我们喜欢在单独的等待 set 中保存 put 线程和 take 线程，这样就可以在缓冲区中的项或空间变得可用时利用最佳规划，一次只通知一个线程。可以使用两个 Condition 实例来做到这一点。

 class BoundedBuffer {
   final Lock lock = new ReentrantLock();
   final Condition notFull  = lock.newCondition(); 
   final Condition notEmpty = lock.newCondition(); 

   final Object[] items = new Object[100];
   int putptr, takeptr, count;

   public void put(Object x) throws InterruptedException {
     lock.lock();
     try {
       while (count == items.length) 
         notFull.await();
       items[putptr] = x; 
       if (++putptr == items.length) putptr = 0;
       ++count;
       notEmpty.signal();
     } finally {
       lock.unlock();
     }
   }

   public Object take() throws InterruptedException {
     lock.lock();
     try {
       while (count == 0) 
         notEmpty.await();
       Object x = items[takeptr]; 
       if (++takeptr == items.length) takeptr = 0;
       --count;
       notFull.signal();
       return x;
     } finally {
       lock.unlock();
     }
   } 
 }

（ArrayBlockingQueue 类提供了这项功能，因此没有理由去实现这个示例类。）
3. 信号量 指定多个线程访问一个资源