java 线程Thread 技术--1.5Lock 与condition 演示生产者与消费模式

在jdk 1.5 后，Java 引入了lock 锁来替代synchronized ，在使用中，lock锁的使用更加灵活，提供了灵活的 api ，不像传统的synchronized ，一旦进入synchronized中，方法是无法打断的，也就是说有时候会陷入漫长的等待当中；以及进行公平锁的创建（synchronized 说非公平的锁）；

一，使用规范：

lock.lock();

        try {

            //doSomeThing

        }

        finally {

            lock.unlock();

        }

就相当于:

synchronized mehod () {

}

二,创建锁对象

ReentrantLock lock =new ReentrantLock();等价于 ReentrantLock lock =new ReentrantLock(false); 创建非公平锁

ReentrantLock lock =new ReentrantLock(true); 创建公平锁

三，公平锁与非公平锁的区别（以公平锁和非公平锁两种方式以多线程方式运行）

class ReenLock implements Runnable{

    //创建公平锁

    ReentrantLock lock =new ReentrantLock(true);

    //创建非公平锁

    //ReentrantLock lock =new ReentrantLock();

    @Override

    public void run() {

            while(true) {

                try {

                lock.lock();

                Thread.sleep(1000);

                System.out.println(Thread.currentThread().getName()+"拿到了锁");

                }

                catch(Exception e) {

                    e.getStackTrace();

                }

                finally {

                lock.unlock();

                }

            }

    }

}

公平锁运行结果：

Thread-0拿到了锁

Thread-1拿到了锁

Thread-0拿到了锁

Thread-1拿到了锁

Thread-0拿到了锁

非公平锁运行结果：

Thread-0拿到了锁

Thread-0拿到了锁

Thread-0拿到了锁

Thread-0拿到了锁

Thread-0拿到了锁

Thread-0拿到了锁

结论：

1.公平锁保证了线程的运行顺序，按照先进线程的原则，每一次执行都要进行判断

2.非公平锁执行是无序的，但效率是最高了，synchronized 也是非公平锁，也是推荐使用的

四，tryLock() 使用；

trylock() :尝试去获得锁，返回boolean, ≈在指定的时间内，如果它没有被其他线程占有且没有被打断，则获得这把锁；

我们可以在没有获得这把锁的时候，去执行程序其他的逻辑；

class TryLock implements Runnable{

    //创建非公平锁

    ReentrantLock lock =new ReentrantLock();

    @Override

    public void run() {

                boolean tryLock =false;

                try {

                    //尝试获取锁，如果能得到锁，则立即返回true

                tryLock=lock.tryLock(5, TimeUnit.SECONDS);

                if(tryLock) {

                Thread.sleep(10000);

                System.out.println(Thread.currentThread().getName()+"拿到了锁");

                    }

                    else {
　　　　　　　　　　　　　　　　//没有拿到锁

                        System.out.println("号外：有个人长时间占这锁");

                    }

                }

                catch(Exception e) {

                    e.getStackTrace();

                }

                finally {
　　　　　　　　//必须进行判断，以防拿不到锁去释放会报错

                if(tryLock) {lock.unlock();};

                }

    }

}

五, 要说lock 锁代替了synchronized ，那么condition 代替了object 中 wait notify notifyAll 等方法；

演示使用lock 和condition 进行生产者与消费者的演示

/**

 * use jdk1.5 的reentranLock 与condition 进行provider and consumer

 * lock 锁代替了synchronized

 * @author iscys

 *

 */

public class LockAndConditionProviderAndConsumer {

public static void main(String[] args) {

    NewLock samp =new NewLock();

        PrividerNewHandler provider =new PrividerNewHandler(samp);

        ConsumerNewHandler consumer =new ConsumerNewHandler(samp);

        new Thread(provider).start();

        new Thread(provider).start();

        new Thread(consumer).start();

        new Thread(consumer).start();

        new Thread(consumer).start();

        new Thread(consumer).start();

    }

}

class  PrividerNewHandler implements Runnable{

    private NewLock newl;

    PrividerNewHandler(NewLock newl){

        this.newl=newl;

    }

    @Override

    public void run() {

        try {

            while(true)

                newl.provider();

        } catch (Exception e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

    }

}

class  ConsumerNewHandler implements Runnable{

    private NewLock newl;

    ConsumerNewHandler(NewLock newl){

        this.newl=newl;

    }

    @Override

    public void run() {

        try {

            while(true)

                newl.consumer();

        } catch (Exception e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

    }

}

class NewLock{

    private int max =10;

    private int init=0;

    ReentrantLock lock =new ReentrantLock();

    Condition p =lock.newCondition();

    Condition c=lock.newCondition();

    void provider(){

        lock.lock();

        try {

            while(init>=max) {

                p.await();

            }

            Thread.sleep(100);

            init++;

            System.out.println(Thread.currentThread().getName()+"生产到了"+init);

            c.signalAll();

        }

        catch(Exception e) {}

        finally {lock.unlock();}

    } 

    void consumer(){

        lock.lock();

        try {

            while(init==0) {

                c.await();

            }

            Thread.sleep(100);

            init--;

            System.err.println(Thread.currentThread().getName()+"消费到了"+init);

            p.signalAll();

        }

        catch(Exception e) {}

        finally {lock.unlock();}

    }

}

巴特西

java 线程Thread 技术--1.5Lock 与condition 演示生产者与消费模式

最新文章

热门文章