2013.11.06 ——— java线程之信号量&ReentrantLock

2013.11.06 ——— java线程之信号量&ReentrantLock
参考： http://ifeve.com/java-synchronousqueue/

1、信号量

参考： http://blog.163.com/xiaopengyan_109/blog/static/1498321732010666331610/

信号量的值表示资源的可用数量.在使用资源时,要先从该信号量上获取一个使用许可.成功获取许可之后,资源可用数量减1.在持有许可期,使用者可以对获取资源进行操作.完成对资源的使用之后,需要在信号量上释放一个许可,资源可用数加1,允许其他使用者获取资源.当资源可用数为0的时候,需要获取资源的线程以阻塞的方式来等待资源变为可用,或者过段时间之后再检查资源是否变为可用.
说白了，Semaphore是一个计数器，在计数器不为0的时候对线程就放行，一旦达到0，那么所有请求资源的新线程都会被阻塞，包括增加请求到许可的线程，也就是说Semaphore不是可重入的。每一次请求一个许可都会导致计数器减少1，同样每次释放一个许可都会导致计数器增加1，一旦达到了0，新的许可请求线程将被挂起。

import java.util.concurrent.Semaphore;


public class TestSemaphore2 {
    public static void main(String[] args) {
        final Kfc kfc = new Kfc();
        new Thread(){
            public void run() {
                while(true){
                    kfc.eat();
                }
            }
        }.start();
        new Thread(){
            public void run() {
                while(true){
                    kfc.cook();
                }
            }
        }.start();
    }
}

class Kfc{
    private Semaphore s1 = new Semaphore(0);
    private Semaphore s2 = new Semaphore(1);
    private Semaphore s3 = new Semaphore(0);
    private int i = 0;
    public void eat(){
        try {
            s1.acquire();
            System.out.println("eat: " + --i);
            Thread.sleep(1000);
            s2.release();
            s3.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public void cook(){
        try {
            s2.acquire();
            System.out.println("cook: " + ++i);
            Thread.sleep(1000);
            s1.release();
            s3.acquire();
            
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

这个例子说的而是任务A执行 执行任务B 一次循环

参考： http://blog.csdn.net/java2000_net/article/details/3997449

import java.util.concurrent.Semaphore;


public class TestSemaphore2 {
    public static void main(String[] args) {
        final Kfc kfc = new Kfc();
        for(int i=0;i<10;i++){
            new Thread("eat" + i){
                public void run() {
                    while(true){
                        kfc.eat();
                    }
                }
            }.start();
        }
        for(int i=0;i<10;i++){
            new Thread("cook" + i){
                public void run() {
                    while(true){
                        kfc.cook();
                    }
                }
            }.start();
        }
    }
}

class Kfc{
    private Semaphore s1 = new Semaphore(1);//核心锁 只有一个线程执行具体的任务
    private Semaphore s2 = new Semaphore(10);//非满锁  令牌没了 就说明满了
    private Semaphore s3 = new Semaphore(0);//非空锁  不为0 就说明不为空
    private int i = 0;
    public void eat(){
        try {
            s3.acquire();//是否为空
            s1.acquire();//核心锁
            System.out.println(Thread.currentThread().getName() + ": " + --i);
            Thread.sleep(1000);
            s1.release();//退出核心锁
            s2.release();//肯定不满了
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public void cook(){
        try {
            s2.acquire();//是否满了
            s1.acquire();//核心锁   一直到“退出核心锁”只允许一个线程执行下面的代码 
            System.out.println(Thread.currentThread().getName() + ": " + ++i);
            Thread.sleep(1000);
            s1.release();//退出核心锁
            s3.release();//肯定不空
            
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

这个是消费者生产者模式

2、ReentrantLock
参考： http://blog.csdn.net/vernonzheng/article/details/8288251

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


public class TestLock {
    public static void main(String[] args) {
        final Kfc2 kfc = new Kfc2();
        for(int i=0;i<10;i++){
            new Thread("eat" + i){
                public void run() {
                    while(true){
                        kfc.eat();
                    }
                }
            }.start();
        }
        for(int i=0;i<10;i++){
            new Thread("cook" + i){
                public void run() {
                    while(true){
                        kfc.cook();
                    }
                }
            }.start();
        }
    }
}

class Kfc2{
    private final Lock lock = new ReentrantLock();  
    private Condition notFull = lock.newCondition();  
    private Condition notEmpty = lock.newCondition();  
    private int i = 0;
    public void eat(){
        try {
            Thread.sleep(1000);
            lock.lock();
            while(i<=0){
                notEmpty.await();//空了
            }
            System.out.println(Thread.currentThread().getName() + ": " + --i);
            Thread.sleep(1000);
            notFull.signalAll();//已经不满了
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally{
            lock.unlock();
        }
    }
    public void cook(){
        try {
            Thread.sleep(1000);
            lock.lock();
            while(i>=10){
                notFull.await();//满了
            }
            System.out.println(Thread.currentThread().getName() + ": " + ++i);
            Thread.sleep(1000);
            notEmpty.signalAll();//已经不空了
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally{
            lock.unlock();
        }
    }
}