[java多线程] - 锁机制&同步代码块&信号量

　　在美眉图片下载demo中，我们可以看到多个线程在公用一些变量，这个时候难免会发生冲突。冲突并不可怕，可怕的是当多线程的情况下，你没法控制冲突。按照我的理解在java中实现同步的方式分为三种，分别是：同步代码块机制，锁机制，信号量机制。

---

一、同步代码块

　　在java的多线程并发开发过程中，我们最常用的方式就是使用同步代码关键字(synchronized)。这种方式的使用不是特别复杂，需要注意的只是你需要明确到底同步的是那个对象，只有当同步的对象一致的情况下，才能够控制互斥的操作。一般情况下，我们会同步this或者是当前class对象。同步this对当前实例有效，同步class对当前所有class的对象有效。下面这个demo的功能是，启动十个线程，最终结果是每个线程都将共享的变量加上1.

private static final java.util.Random random = new java.util.Random(System.currentTimeMillis());

public static void main(String[] args) {
    Runnable runnable = new Runnable() {
        private int count = 0; // 资源对象

        @Override
        public void run() {
            try {
                int oldCount = count;
                Thread.sleep(random.nextInt(1000) + 10); // 处理
                count = oldCount + 1;
                System.out.println(Thread.currentThread().getName() + ", 原有资源:" + oldCount + ", 现在预期资源:" + (oldCount + 1) + ",现在实际资源:" + count);
            } catch (InterruptedException e) {
            }
        }
    };

    for (int i = 0; i < 10; i++) {
        new Thread(runnable).start();
    }
}

　　我们可以发现结果如下图所示，明显可以看出在是个线程访问一个变量的情况下，导致最终的结果不对。

　　加同步锁的代码和上述代码差不多，区别只是在获取资源和修改资源的时候进行同步块处理。

int oldCount = 0;
synchronized (this) {
    oldCount = count;
    Thread.sleep(random.nextInt(1000) + 10); // 处理
    count = oldCount + 1;
}

二、锁机制

　　在Java中的锁机制是通过java.util.concurrent.locks.Lock来实现的，这个接口主要有三个实现类，分别是ReentrantLock，ReentrantReadWriteLock.ReadLock, ReentrantReadWriteLock.WriteLock。锁机制和同步代码块相比，我们可以明显的发现使用lock机制会降低同步粒度，提高性能。特别是在一些情况下，使用lock是一种非常不错的选择，比如说在读远远高于写的状况下，使用读写锁那是一种非常不错的选择。下面直接来一个cachedemo

static class CacheDemo {
        private static final int maxSize = 100000; // 最大存储量
        private static CacheDemo demo;
        private Map<String, String> cache = new LinkedHashMap<String, String>() {
            private static final long serialVersionUID = -7259602073057254864L;

            protected boolean removeEldestEntry(Map.Entry<String, String> eldest) {
                return maxSize > this.size(); // 超过就移除
            };
        };
        private ReentrantReadWriteLock rrel = new ReentrantReadWriteLock();
        private Lock writeLock = rrel.writeLock(); // 写锁
        private Lock readLock = rrel.readLock(); // 读锁

        /**
         * 获取cache对象
         * 
         * @return
         */
        public static CacheDemo instance() {
            if (demo == null) {
                synchronized (CacheDemo.class) {
                    if (demo == null) {
                        demo = new CacheDemo();
                    }
                }
            }
            return demo;
        }

        /**
         * 添加
         * 
         * @param key
         * @param value
         */
        public void put(String key, String value) {
            this.writeLock.lock(); // 加锁
            try {
                this.cache.put(key, value);
            } finally {
                // 防止在操作过程中出现异常，使用try-finally保证解锁一定执行。
                this.writeLock.unlock(); // 解锁
            }
        }

        /**
         * 获取这个对象
         * 
         * @param key
         * @return
         */
        public String get(String key) {
            this.readLock.lock(); // 加锁
            try {
                return this.cache.get(key);
            } finally {
                this.readLock.unlock(); // 解锁
            }
        }

        /**
         * 移除key
         * 
         * @param key
         */
        public void remove(String key) {
            this.writeLock.lock();
            try {
                this.cache.remove(key);
            } finally {
                this.writeLock.unlock();
            }
        }

        /**
         * 清空
         */
        public void clean() {
            this.writeLock.lock();
            try {
                this.cache.clear();
            } finally {
                this.writeLock.unlock();
            }
        }
    }

三、信号量

　　Java中的信号量主要有三种：Semaphore、CountDownLatch和CyclicBarrier。Semaphore可以维护访问自身的线程数，从而达到控制线程同步的需求；CountDownLatch主要作用是当计数器为0的时候，所有在该对象上等待的线程获得继续执行的权利；CyclicBarrier主要作用是当所有的线程准备好后，再允许线程执行。

/**
 * {@link Semaphore}
 * 可以维护当前访问自身的线程数，并提供同步机制，使用Semahore可以控制同时访问资源的线程个数，例如：实现一个地下停车库。<br/>
 * 单个信号变量semphore对象可以实现互斥锁的功能，并且可以是其中一个线程获得锁，另外一个线程释放锁，那么可应用于死锁恢复的一些场所。
 * 
 * @author jsliuming
 * 
 */
public class SemaphoreDemo {
    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        try {
            final Semaphore semaphore = new Semaphore(3); // 3个同步变量
            for (int i = 0; i < 10; i++) {
                Runnable runnable = new Runnable() {

                    @Override
                    public void run() {
                        String name = Thread.currentThread().getName();
                        try {
                            System.out.println("线程[" + name + "]开始获取资源....");
                            semaphore.acquire(); // 请求资源，有阻塞效果
                            System.out.println("线程[" + name + "]需要的资源获取到.");
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }

                        long time = (long) (Math.random() * 2000);
                        System.out.println("线程[" + name + "]已经进入，当前有:" + (3 - semaphore.availablePermits()) + "个线程运行.准备停留:" + time);

                        try {
                            Thread.sleep(time);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        } finally {
                            semaphore.release(); // 放回
                        }
                        System.out.println("线程[" + name + "]运行完成!");
                    }
                };
                service.execute(runnable);
            }
        } finally {
            service.shutdown();
        }

    }
}

/**
 * {@link CountDownLatch}
 * 倒计时计时器，调用对象的countDown方法将计时器数减少一，那么直到0的时候，就会让所有等待的线程开始运行。
 * 
 * @author jsliuming
 * 
 */
public class CountDownLatchDemo {
    static final Random random = new Random(System.currentTimeMillis());

    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        final CountDownLatch cdOrder = new CountDownLatch(1);
        int n = 3;
        final CountDownLatch cdAnswer = new CountDownLatch(n);
        for (int i = 0; i < n; i++) {
            Runnable runnable = new Runnable() {

                @Override
                public void run() {
                    String name = Thread.currentThread().getName();
                    try {
                        System.out.println("线程[" + name + "]准备接受命令");
                        cdOrder.await();
                        long t1 = Math.abs(random.nextLong()) % 20000;
                        System.out.println("线程[" + name + "]已经接受到命令,处理时间需要" + t1);
                        Thread.sleep(t1);
                        System.out.println("线程[" + name + "]回应命令处理结束");
                        cdAnswer.countDown();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            };

            service.execute(runnable);
        }

        try {
            Thread.sleep(Math.abs(random.nextLong()) % 3000);
            String name = Thread.currentThread().getName();
            System.out.println("线程[" + name + "]即将发布命令");
            cdOrder.countDown();
            System.out.println("线程[" + name + "]已发布命令，等待结果响应");
            cdAnswer.await();
            System.out.println("线程[" + name + "]收到所有的响应结果");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            service.shutdown();
        }
    }
}

/**
 * {@link CyclicBarrier}表示请大家等待，等所有集合都准备好了，那么就开始运行，这个过程可以循环。<br/>
 * 比如：公司部门的周末准备一起出去游玩，先等到所有的人到达汽车才开始启动车辆到目的地去，到后自由玩，然后到1点在一起吃饭。
 * 
 * @author jsliuming
 * 
 */
public class CyclicBarrierDemo {
    final static Random random = new Random(System.currentTimeMillis());

    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        int n = 3;
        final CyclicBarrier barrier = new CyclicBarrier(n); // 总共十个人
        for (int i = 0; i < n; i++) {
            Runnable runnable = new Runnable() {

                @Override
                public void run() {
                    try {
                        String name = Thread.currentThread().getName();
                        long t1 = Math.abs(random.nextLong()) % 2000;
                        System.out.println("线程[" + name + "] " + t1 + " 后到达集合地点1，现在已经有" + (barrier.getNumberWaiting()) + "人到达!");
                        Thread.sleep(t1);
                        System.out.println("线程[" + name + "]已经到达集合地点1，现在已经有" + (barrier.getNumberWaiting() + 1) + "人到达!");
                        barrier.await(); // 等待

                        System.out.println("线程[" + name + "]在车上...自由活动....");

                        t1 = Math.abs(random.nextLong()) % 2000;
                        System.out.println("线程[" + name + "] " + t1 + " 后到达集合地点2，现在已经有" + (barrier.getNumberWaiting()) + "人到达!");
                        Thread.sleep(t1);
                        System.out.println("线程[" + name + "]已经到达集合地点2，现在已经有" + (barrier.getNumberWaiting()) + "人到达!");
                        barrier.await(); // 等待
                        System.out.println("线程[" + name + "]觉得是美好的一天.");
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            };

            service.execute(runnable);
        }
        service.shutdown();
    }
}