多线程相关类的学习

JAVA5 中锁的概念

java中有三种锁的实现，分别是

ReentrantLock 普通锁

ReentrantReadWriteLock 读写锁

其中读锁和写锁互斥，写锁和写锁互斥，读锁和读锁可以并发。

public class LockTest {
Lock lock = new ReentrantLock();
ReadWriteLock rwlock = new ReentrantReadWriteLock();
// 读取时候上读锁，写的时候上写锁

public void read() {
rwlock.readLock().lock();
// 读取数据的代码，多个读锁不互斥

//
rwlock.readLock().unlock();
}

public void write(int i) {
rwlock.writeLock().lock();
// 修改数据是上写锁，写锁之间互斥，写锁和读锁互斥。
rwlock.writeLock().unlock();

}

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



java里的信号量的概念: Seamphore类的实用案例

　　public static void main(String[] args) {
　　　　　　　　　　ExecutorService service = Executors.newCachedThreadPool();
　　　　　　　　　　//final Semaphore sp = new Semaphore(3);
　　　　　　　　　　final Semphore sp =new Semaphore(3);

　　　　　　　　　　　　for(int i=0;i<10;i++){
　　　　　　　　　　　　　　Runnable runnable = new Runnable(){
　　　　　　　　　　　　　　　　public void run(){
　　　　　　　　　　　　try {
　　　　　　　　　　　　　　sp.acquire();

　　　　　　　　　　　　　　　　} catch (InterruptedException e1) {
　　　　　　　　　　　　　　　　e1.printStackTrace();
　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　System.out.println("线程" + Thread.currentThread().getName() +
　　　　　　　　　　　　　　"进入，当前已有" + (3-sp.availablePermits()) + "个并发");
　　　　　　　　　　　　　　try {
　　　　　　　　　　　　　　　　　　Thread.sleep((long)(Math.random()*10000));
　　　　　　　　　　　　　　　　　　　} catch (InterruptedException e) {
　　　　　　　　　　　　　　　　e.printStackTrace();
　　　　　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　System.out.println("线程" + Thread.currentThread().getName() +
　　　　　　　　　　　　　　　　"即将离开");
　　　　　　　　　　　　　　　　sp.release();
//下面代码有时候执行不准确，因为其没有和上面的代码合成原子单元
　　　　　　　　　　System.out.println("线程" + Thread.currentThread().getName() +
　　　　　　　　　　　　"已离开，当前已有" + (3-sp.availablePermits()) + "个并发");
　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　};
　　　　　　　　　　　　service.execute(runnable);
　　　　　　　　　　　　　　}
　　　　　　　　　　　　}

//jdk 官方案例

一个计数信号量。从概念上讲，信号量维护了一个许可集。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore 只对可用许可的号码进行计数，并采取相应的行动。

Semaphore 通常用于限制可以访问某些资源（物理或逻辑的）的线程数目。例如，下面的类使用信号量控制对内容池的访问：

 class Pool {
   private static final int MAX_AVAILABLE = 100;
   private final Semaphore available = new Semaphore(MAX_AVAILABLE, true);

   public Object getItem() throws InterruptedException {
     available.acquire();
     return getNextAvailableItem();
   }

   public void putItem(Object x) {
     if (markAsUnused(x))
       available.release();
   }

   // Not a particularly efficient data structure; just for demo

   protected Object[] items = ... whatever kinds of items being managed
   protected boolean[] used = new boolean[MAX_AVAILABLE];

   protected synchronized Object getNextAvailableItem() {
     for (int i = 0; i < MAX_AVAILABLE; ++i) {
       if (!used[i]) {
          used[i] = true;
          return items[i];
       }
     }
     return null; // not reached
   }

   protected synchronized boolean markAsUnused(Object item) {
     for (int i = 0; i < MAX_AVAILABLE; ++i) {
       if (item == items[i]) {
          if (used[i]) {
            used[i] = false;
            return true;
          } else
            return false;
       }
     }
     return false;
   }

 }

获得一项前，每个线程必须从信号量获取许可，从而保证可以使用该项。该线程结束后，将项返回到池中并将许可返回到该信号量，从而允许其他线程获取该项。注意，调用 acquire() 时无法保持同步锁，因为这会阻止将项返回到池中。信号量封装所需的同步，以限制对池的访问，这同维持该池本身一致性所需的同步是分开的。

将信号量初始化为 1，使得它在使用时最多只有一个可用的许可，从而可用作一个相互排斥的锁。这通常也称为二进制信号量，因为它只能有两种状态：一个可用的许可，或零个可用的许可。按此方式使用时，二进制信号量具有某种属性（与很多 Lock 实现不同），即可以由线程释放“锁”，而不是由所有者（因为信号量没有所有权的概念）。在某些专门的上下文（如死锁恢复）中这会很有用。

此类的构造方法可选地接受一个公平参数。当设置为 false 时，此类不对线程获取许可的顺序做任何保证。特别地，闯入是允许的，也就是说可以在已经等待的线程前为调用 acquire() 的线程分配一个许可，从逻辑上说，就是新线程将自己置于等待线程队列的头部。当公平设置为 true 时，信号量保证对于任何调用获取方法的线程而言，都按照处理它们调用这些方法的顺序（即先进先出；FIFO）来选择线程、获得许可。注意，FIFO 排序必然应用到这些方法内的指定内部执行点。所以，可能某个线程先于另一个线程调用了 acquire，但是却在该线程之后到达排序点，并且从方法返回时也类似。还要注意，非同步的 tryAcquire 方法不使用公平设置，而是使用任意可用的许可。

通常，应该将用于控制资源访问的信号量初始化为公平的，以确保所有线程都可访问资源。为其他的种类的同步控制使用信号量时，非公平排序的吞吐量优势通常要比公平考虑更为重要。

此类还提供便捷的方法来同时 acquire 和释放多个许可。小心，在未将公平设置为 true 时使用这些方法会增加不确定延期的风险。

CyclicBarrier 类的实用：

ExecutorService service = Executors.newCachedThreadPool();
final CyclicBarrier cb = new CyclicBarrier(3);

for(int i=0;i<3;i++){
Runnable runnable = new Runnable(){
public void run(){
try {
Thread.sleep((long)(Math.random()*10000));
System.out.println("线程" + Thread.currentThread().getName() +
"即将到达集合地点1，当前已有" + (cb.getNumberWaiting()+1) + "个已经到达，" + (cb.getNumberWaiting()==2?"都到齐了，继续走啊":"正在等候"));
cb.await();

Thread.sleep((long)(Math.random()*10000));
System.out.println("线程" + Thread.currentThread().getName() +
"即将到达集合地点2，当前已有" + (cb.getNumberWaiting()+1) + "个已经到达，" + (cb.getNumberWaiting()==2?"都到齐了，继续走啊":"正在等候"));
cb.await();
Thread.sleep((long)(Math.random()*10000));
System.out.println("线程" + Thread.currentThread().getName() +
"即将到达集合地点3，当前已有" + (cb.getNumberWaiting() + 1) + "个已经到达，" + (cb.getNumberWaiting()==2?"都到齐了，继续走啊":"正在等候"));
cb.await();
} catch (Exception e) {
e.printStackTrace();
}
}
};
service.execute(runnable);
}
service.shutdown();
}
}

posted @ 2017-05-23 13:29 暗夜飞羽睿阅读(103) 评论(0) 收藏举报

刷新页面返回顶部

R.Z

code a better life

多线程相关类的学习

ReentrantLock 普通锁

ReentrantReadWriteLock 读写锁

公告