线程高级应用-心得5-java5线程并发库中Lock和Condition实现线程同步通讯

1.Lock相关知识介绍

   好比我同时种了几块地的麦子，然后就等待收割。收割时，则是哪块先熟了，先收割哪块。

   下面举一个面试题的例子来引出Lock缓存读写锁的案例，一个load（）和get（）方法返回值为空时的情况；load（）的返回值是一个代理对象，而get（）却是一个实实在在的对象；所以当返回对象为空是，get（）返回null，load（）返回一个异常对象；具体分析如下：

 一个读写锁的缓存库案例；用上面那道面试题分析则很好理解：

  线程阻塞问题：运用多个Condition对象解决

2. Lock接口锁的使用

Lock与synchronized最大区别就是：前者更面向对象；Lock要求程序员手动释放锁，synchronized自动释放

package com.java5.thread.newSkill;

//concurrent就是java5新增的线程并发库包
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Lock接口锁的使用
 *   Lock与synchronized最大区别就是：前者更面向对象；
 *   Lock要求程序员手动释放锁，synchronized自动释放。
 */
public class LockTest {

    public static void main(String[] args) {
        new LockTest().init();

    }

    // 该方法的作用是：外部类的静态方法不能实例化内部类对象；所以不能直接在外部类的main实例化，要创建一个中介的普通方法
    private void init() {
        final Outputer outputer = new Outputer();
        // 线程1
        new Thread(new Runnable() {

            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    outputer.output("yangkai");
                }
            }
        }).start();
        // 线程2
        new Thread(new Runnable() {

            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    outputer.output("123456");
                }
            }
        }).start();
    }

    static class Outputer {
        Lock lock = new ReentrantLock();

        public void output(String name) {
            //上锁
            lock.lock();
            try {
                for (int i = 0; i < name.length(); i++) {
                    // 读取字符串内一个一个的字符
                    System.out.print(name.charAt(i));
                }
                System.out.println();
            } finally {
                //释放锁；
                /*这里放到finally里的原因是：万一上锁的这个方法中有异常发生;
                 * 那就不执行释放锁代码了，也就是成死锁了；好比你上厕所晕里面了；
                 * 后面的人等啊等的永远进不去似的
                 */
                lock.unlock();
            }
        }

    }

    /*
     * 如果不使用线程锁Lock会出现以下情况： yangkai 123456 yangkai 1y2a3n4g5k6 ai
     */
}
3、读写锁的案例
package com.java5.thread.newSkill;

import java.util.Random;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 读写锁的案例
 */
public class ReadWriteLockTest {

    public static void main(String[] args) {

        final Queues queues = new Queues();
        for ( int i = 0; i < 10; i++) {
            final int j = i;
            new Thread() {
                public void run() {
                    //此处打标记A，下面注释会提到
                    /*if(j<10)*/ while(true){
                        queues.get();
                    }
                }
            }.start();
            new Thread() {
                public void run() {
                    /*if(j<10)*/while(true) {
                        queues.put(new Random().nextInt(10000));
                    }
                }
            }.start();
        }
    }
}

class Queues {
    // 共享数据;只能有一个线程能写改数据，但能有多个线程同时读数据
    private Object data = null;
    /*这里如果这么写：
     *   ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
          上面的标记A处，如果用while(true)会一直写不读，但是如果不用while死循环则可以正确执行，
          比如用if(i<10);目前还没找到原因，希望大牛们看到后指点迷津;
         个人猜测：没有用面向接口编程，上锁后，死循环中的内容会无穷之的执行，执行不完不会开锁
    */
    ReadWriteLock rwl = new ReentrantReadWriteLock();

    // 读的方法，用的是读锁readLock()
    public void get() {
        rwl.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()
                    + " be ready to read data！");
            Thread.sleep((long) Math.random() * 1000);
            System.out.println(Thread.currentThread().getName()
                    + " have read data:" + data);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            rwl.readLock().unlock();
        }
    }

    // 写的方法；用到写的锁：writeLock()
    public void put(Object data) {
        rwl.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()
                    + " be ready to write data！");
            Thread.sleep((long) Math.random() * 1000);
            this.data = data;
            System.out.println(Thread.currentThread().getName()
                    + " have write data:" + data);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            rwl.writeLock().unlock();
        }
    }
}
4. 缓存系统的模拟编写;读写锁的实际应用价值
package com.java5.thread.newSkill;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class CacheDemo {

    /**
     * 缓存系统的模拟编写;读写锁的实际应用价值
     */
    private Map<String, Object> cache = new HashMap<String, Object>();

    public static void main(String[] args) {

    }

    private ReadWriteLock rwl = new ReentrantReadWriteLock();

    public Object getData(String key) {
        //如果客户一来读取value数据，则在客户一进去后上一把读锁；防止其他客户再次进行读，产生并发问题
        rwl.readLock().lock();
        Object value = null;
        try {
            value = cache.get(key);
            if (value == null) {
                //如果如果读到的值为空则释放读锁，打开写锁，准备给value赋值
                rwl.readLock().unlock();
                rwl.writeLock().lock();
                try {
                    //如果打开写锁还为空，则给value赋值aaa
                    if (value == null) {
                        value = "aaa";  //实际失去queryDB()
                    }
                } finally {
                    //使用完写锁后关掉
                    rwl.writeLock().unlock();
                }
                //释放写锁后，再次打开读锁，供客户读取value的数据
                rwl.readLock().lock();
            }
        } finally {
            //最后客户一读完后释放掉读锁
            rwl.readLock().unlock();
        }
        return value;
    }
}
5.新技术condition案例分析；代替wait（）和notify（）方法
package com.java5.thread.newSkill;

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

/**
 * 面试题： 子线程循环10次，接着主线程循环100次，接着又回到子线程循环10次， 接着再回到主线程又循环100次，如此循环50次，代码如下：
 * 
 * 思路： 编写一个业务类，是为了不把自己绕进去，体现代码的的高聚类特性和代码的健壮性，
 * 即共同数据（比如这里的同步锁）或共同算法的若干个方法都可以提到同一个类中编写
 * 
 * 注意：wait()和notify（）必须在synchronized关键字内使用；
 * 因为this.watit()中用到的this是synchronized（）括号内的
 * 内容；如果不使用synchronized直接就用wait（）会包状态不对的错误
 */
public class ConditionCommunication {

    public static void main(String[] args) {
        final Business business = new Business();
        new Thread(new Runnable() {

            @Override
            public void run() {
                for (int i = 1; i <= 50; i++) {
                    business.sub(i);
                }
            }
        }).start();

        for (int i = 1; i <= 50; i++) {
            business.main(i);
        }

    }
}

// 编写一个有子方法（用来调用子线程）和主方法（调用主线程）的业务类

class Business {
    private boolean bShouldSub = true;
    Lock lock = new ReentrantLock();
    // condition必须基于lock锁之上的
    Condition condition = lock.newCondition();

    public void sub(int i) {
        try {
            lock.lock();
            while (!bShouldSub) {
                try {
                    // this.wait();
                    /*
                     * condition使用的是await（）注意与wait（）的区别；
                     * 因为condition也是Object对象所以也可以调用wait()方法，所以千万别调错了
                     */
                    condition.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            for (int j = 1; j <= 10; j++) {
                System.out.println("sub thread sequence of  " + j
                        + " ,loop of  " + i);
            }
            bShouldSub = false;
            // this.notify();
            condition.signal();
        } finally {
            lock.unlock();
        }
    }

    public void main(int i) {
        /*
         * 这里最好用while，但是跟if的效果一样，只是前者代码更健壮， while可以防止线程自己唤醒自己，即通常所说的伪唤醒；
         * 相当于一个人做梦不是被别人叫醒而是自己做噩梦突然惊醒； 这时用while可以防止这种情况发生
         */
        try {
            lock.lock();
            while (bShouldSub) {
                try {
                    // this.wait();
                    condition.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            for (int j = 1; j <= 100; j++) {
                System.out.println("main thread sequence of  " + j
                        + " ,loop of  " + i);
            }
            bShouldSub = true;
            // this.notify();
            condition.signal();
        } finally {
            lock.unlock();
        }
    }
}
6. 多个Condition的应用场景；以下是三个condition通讯的代码：
package com.java5.thread.newSkill;

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

/**
 * 多个Condition的应用场景
 * 以下是三个condition通讯的代码：
 */
public class ThreeConditionCommunication {

    public static void main(String[] args) {
        final Business business = new Business();
        //线程2，老二线程
        new Thread(new Runnable() {

            @Override
            public void run() {
                for (int i = 1; i <= 50; i++) {
                    business.sub(i);
                }
            }
        }).start();
        
        //线程3，老三线程
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                for (int i = 1; i <= 50; i++) {
                    business.sub2(i);
                }
            }
        }).start();

        //主线程1，老大线程
        for (int i = 1; i <= 50; i++) {
            business.main(i);
        }

    }
    
    /*编写一个有子方法（用来调用子线程）和主方法（调用主线程）的业务类
     * 这个项目下虽然有两个Business类；但是在不同包下所以不影响； 如果在同一包下，那么就要改名或者将其弄成内部类，如果又想要把他当外部类使用，
     * 那么将其弄成static 静态的就可以了
     */
    static class Business {
        private int shouldSub = 1;
        Lock lock = new ReentrantLock();

        Condition condition1 = lock.newCondition();
        Condition condition2 = lock.newCondition();
        Condition condition3 = lock.newCondition();

        public void sub(int i) {
            try {
                lock.lock();
                while (shouldSub != 2) {
                    try {                    
                        condition2.await();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                for (int j = 1; j <= 10; j++) {
                    System.out.println("sub thread sequence of  " + j
                            + " ,loop of  " + i);
                }
                shouldSub = 3;
                condition3.signal();
            } finally {
                lock.unlock();
            }
        }
        public void sub2(int i) {
            try {
                lock.lock();
                while (shouldSub != 3) {
                    try {                    
                        condition3.await();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                for (int j = 1; j <= 10; j++) {
                    System.out.println("sub2 thread sequence of  " + j
                            + " ,loop of  " + i);
                }
                shouldSub = 1;
                condition1.signal();
            } finally {
                lock.unlock();
            }
        }

        public void main(int i) {
            try {
                lock.lock();
                while (shouldSub != 1) {
                    try {;
                        condition1.await();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                for (int j = 1; j <= 100; j++) {
                    System.out.println("main thread sequence of  " + j
                            + " ,loop of  " + i);
                }
                shouldSub = 2;
                condition2.signal();
            } finally {
                lock.unlock();
            }
        }
    }
}