JDK并发包之同步控制

一、重入锁

重入锁使用java.util.concurrent.locks.ReentrantLock来实现。示例代码如下：

public class TryReentrantLock implements Runnable{

static ReentrantLock lock=new ReentrantLock();
static int i=0;
    @Override
public void run() {
for(int j=0;j<10000;j++){
            lock.lock();
try{
                i++;
            }finally {
                lock.unlock();
            }

//重入锁可以反复进入，当然这种进入仅限于一个线程！因此可以如下：
/*lock.lock(); 
            lock.lock();
            try{
                i++;
            }finally {
                lock.unlock();
                lock.unlock();
            }*/
        }
    }

public static void main(String[] args) throws InterruptedException {
        TryReentrantLock l=new TryReentrantLock();
        Thread t1=new Thread(l);
        Thread t2=new Thread(l);
        t1.start(); t2.start();
        t1.join(); t2.join();
        System.out.println(i);
    }
}

对于synchronized来说，如果一个线程在等待锁，那么结果只有两种情况，要么它获得这把锁继续执行，要么继续等待锁。而对于使用重入锁的线程来说则不同，线程在等待锁的过程中，程序可以根据需要取消对锁的请求。

public class IntLock implements Runnable{
public static ReentrantLock lock1=new ReentrantLock();
public static ReentrantLock lock2=new ReentrantLock();
int state;

/*控制加锁顺序，便于产生死锁。*/
public IntLock(int state){
this.state=state;
    }
    @Override
public void run() {
try{
if(state==1){
                lock1.lockInterruptibly(); //设置可中断的锁
try{
                    Thread.sleep(500); //便于产生死锁
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                lock2.lockInterruptibly();
            }else{
                lock2.lockInterruptibly();
try{
                    Thread.sleep(500);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                lock1.lockInterruptibly();
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
if(lock1.isHeldByCurrentThread()) lock1.unlock();
if(lock2.isHeldByCurrentThread()) lock2.unlock();
            System.out.println(Thread.currentThread().getName()+" :quit!");
        }
    }

public static void main(String[] args) throws InterruptedException {
        IntLock intLock1=new IntLock(1);
        IntLock intLock2=new IntLock(2);
        Thread t1=new Thread(intLock1);
        t1.setName("t1");
        Thread t2=new Thread(intLock2);
        t2.setName("t2");
        t1.start(); t2.start();
        Thread.sleep(1000);
        t2.interrupt();
    }
}

使用tryLock()进行限时等待。

public class TimeLock implements Runnable{
public static ReentrantLock lock=new ReentrantLock();
    @Override
public void run() {
try{
if(lock.tryLock(5, TimeUnit.SECONDS)){
//注意返回布尔值.如果使用无参数的tryLock方法，
// 当锁被占用时，线程会不等待，并返回false。
                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){
        TimeLock timeLock=new TimeLock();
        Thread t1=new Thread(timeLock);
        Thread t2=new Thread(timeLock);
        t1.start();
        t2.start();

    }
}

公平锁：

大多数情况下，锁的申请都是不公平，随机的。而公平锁，讲究“先来后到”！因此公平锁的一大特点是不会产生饥饿。重入锁允许我们对其公平性进行设置：

public ReentrantLock(boolean fair); //true表示公平锁

公平锁缺点：性能相对低下。

二、重入锁的好基友Condition

Condition的做用类似于wait()和notify（）只不过Condition和ReentrantLock配合。

Condition接口的基本方法：

void await() throws InterruptedException //释放当前线程持有的锁，进入等待状态，当其他线程使用signal或signalAll()方法时继续执行。当线程被中断时会跳出等待。

void awaitUninterruptibly();与await()方法相似，当中断时不会跳出等待。

void signal();
void signalAll();

用法示例：

public class ReentrantCondition implements Runnable{
static ReentrantLock lock=new ReentrantLock();
static Condition condition=lock.newCondition();

    @Override
public void run() {
try{
            lock.lock();
            System.out.println(Thread.currentThread().getName()+" is running fast!");
            condition.await();
            System.out.println(Thread.currentThread().getName()+" is going no.");
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

public static void main(String[] args) throws InterruptedException {
        ReentrantCondition rc=new ReentrantCondition();
        Thread t=new Thread(rc,"King of Lock");
        t.start();

        Thread.sleep(2000);
        lock.lock(); //调用signal前先要获得锁
        condition.signal();
        lock.unlock(); //调用singal后要释放锁，以让给被唤醒的线程。
    }
}

三、允许多个线程同时访问：信号量（Semaphore）

Semaphore可以指定多个线程同时访问一个资源。

public Semaphore(int permits); //permits指定同时能有几个线程访问同一资源。
public Semaphore(int permits,boolean fair) //fair指定是否采用公平锁

Semaphore主要的逻辑方法有：

public void acquire()  //尝试获得一个准入许可，若无法获得，则线程会等待，直到有线程释放了一个许可，或者当前线程被中断
public void acquireUninterruptibly() //不响应中断
public void release() //释放一个许可

四、ReadWriteLock读写锁

读写锁允许多个线程同时读。

Java并发程序设计（四）JDK并发包之同步控制

五、CountDownLatch倒计时器

通常用来控制线程等待，可以让某个线程等待直到倒计时结束，再开始执行。

public CountDownLatch(int count) //count为需要完成几个线程上的任务，CountDownLatch上的线程才能继续执行。

示例代码：

public class CountDownLatchDemo implements Runnable{
static final CountDownLatch latch=new CountDownLatch(10); //需要完成10个线程的任务，
// CountDownLatch上的线程才能继续执行
static final CountDownLatchDemo demo=new CountDownLatchDemo();

    @Override
public void run() {
try{
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName()+" :mission completed!");
            latch.countDown();//通知CountDownLatch一个任务已经完成。
        }catch (Exception e){
            e.printStackTrace();
        }
    }

public static void main(String[] args) throws InterruptedException {
        ExecutorService ex= Executors.newFixedThreadPool(10);
for(int i=0;i<10;i++){
            ex.submit(demo);
        }

        latch.await(); //设置要等待其他线程完成的那个线程
        System.out.println("Killed them all!");
        ex.shutdown();
    }
}

六、循环栅栏：CyclicBarrier

与CountDownLatch类似CyclicBarrier也是用来阻止线程继续执行，让线程进入等待状态。但此计数器可以反复使用。

public CyclicBarrier(int parties,Runnable barrierAction) //barrierAction为计数完成后要执行的动作