Java并发编程从入门到精通

详述：
 线程阀是一种线程与线程之间相互制约和交互的机制；
 作用：http://wsmajunfeng.iteye.com/blog/1629354
阻塞队列BlockingQueue；
数组阻塞队列ArrayBlockingQueue；
链表阻塞队列LinkedBlockingQueue；
优先级阻塞队列PriorityBlockingQueue；
延时队列DelayQueue；
同步队列SynchronousQueue；
链表双向阻塞队列LinkedBlockingDeque；
链表传输队列LinkedTransferQueue；
同步计数器CountDownLatch；
抽象队列化同步器AbstractQueuedSynchroizer；
同步计数器Semaphore；
同步计数器CyclicBarrier；

/**
 * ArrayBlockingQueue的简单用法
 */
package thread04;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class ArrayBlockingQueueTest01
{
    public static void main(String[] args) throws InterruptedException
    {
        // 新建一个等待队列
        final BlockingQueue<String> bq = new ArrayBlockingQueue<String>(16);
        
        for(int i=0;i<16;i++)
        {
            String log = (i+1) + " --> ";
            bq.put(log);
        }
        
        // 新建四个线程
        for(int i=0;i<4;i++)
        {
            new Thread(new Runnable()
            {
                @Override
                public void run()
                {
                    while(true)
                    {
                        try
                        {
                            String log = bq.take();
                            parseLog(log);
                        } 
                        catch (InterruptedException e)
                        {
                            e.printStackTrace();
                        }
                    }
                }
            }).start();
        }
    }
    
    public static void parseLog(String log)
    {
        System.out.println(log + System.currentTimeMillis());
        
        try
        {
            Thread.sleep(1000);
        } 
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
}

/**
 * LinkedBlockingQueue的简单用法
 */
package thread04;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class LinkedBlockingQueueTest01
{
    public static void main(String[] args)
    {
        final BlockingQueue<String> bq = new LinkedBlockingQueue<String>(16);
        
        for(int i=0;i<16;i++)
        {
            String log = (i+1) + " --> ";
            try
            {
                bq.put(log);
            } 
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
        
        for(int i=0;i<4;i++)
        {
            new Thread(new Runnable()
            {
                @Override
                public void run()
                {
                    while(true)
                    {
                        try
                        {
                            String log = bq.take();
                            parseLog(log);
                        } 
                        catch (InterruptedException e)
                        {
                            e.printStackTrace();
                        }
                    }
                }
                
            }).start();
        }
    }
    
    public static void parseLog(String log)
    {
        System.out.println(log + System.currentTimeMillis());
        
        try
        {
            Thread.sleep(1000);
        } 
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
}

/**
 * DelayQueue的简单用法
 */
package thread04;

import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

public class DelayQueueTest01
{
    public static void main(String[] args)
    {
        // 新建一个等待队列
        final DelayQueue<Student> dq = new DelayQueue<Student>();
        
        for(int i=0;i<5;i++)
        {
            Student student = new Student("学生"+i, Math.round((Math.random()*10+i)));
            dq.put(student);  // 将数据存到队列里面
        }
        
        // 获取但不移除此队列的头部；如果此队列为空，则返回null
        System.out.println("dq.peek()：" + dq.peek().getName());
        
        // 获取并移除此队列的头部，在可从此队列获得到期延迟的元素，获得到达指定的等待时间之前一直等待（如有必要）
        // poll(long timeout, TimeUnit unit)
    }
}

class Student implements Delayed  // 必须实现Delayed接口
{
    private String name;
    private long submitTime;  // 交卷时间
    private long workTime;  // 考试时间
    
    public String getName()
    {
        return this.name + "交卷，用时" + workTime;
    }
    
    public Student(String name, long submitTime)
    {
        this.name = name;
        this.workTime = submitTime;
        this.submitTime = TimeUnit.NANOSECONDS.convert(submitTime, TimeUnit.MILLISECONDS) + System.nanoTime();
        System.out.println(this.name + "交卷，用时" + workTime);
    }
    
    @Override
    // 必须实现compareTo()方法
    public int compareTo(Delayed o)
    {
        // 比较的方法
        Student that = (Student) o;
        return submitTime > that.submitTime ? 1 : (submitTime < that.submitTime ? -1 : 0);
    }

    @Override
    // 必须实现getDelay()方法
    public long getDelay(TimeUnit unit)
    {
        // 返回一个延时时间
        return unit.convert(submitTime - System.nanoTime(), unit.NANOSECONDS);
    }
    
}

/*
每次运行结果都不一样，我们获得永远是队列里面的第一个元素
*/

/**
 * SynchronousQueue的简单用法
 */
package thread04;

import java.util.concurrent.Semaphore;
import java.util.concurrent.SynchronousQueue;

public class SynchronousQueueTest01
{
    public static void main(String[] args)
    {
        System.out.println("begin:" + System.currentTimeMillis() / 1000);
        
        final SynchronousQueue<String> sq = new SynchronousQueue<String>();
        final Semaphore sem = new Semaphore(1);
        
        /*
        // 放在不同的地方，结果是不一样的
        for(int i=0;i<10;i++)
        {
            String input = i + "";
            try
            {
                sq.put(input);
            } 
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
        */
        
        for(int i=0;i<10;i++)
        {
            new Thread(new Runnable()
            {
                @Override
                public void run()
                {
                    try
                    {
                        sem.acquire();
                        
                        String input = sq.take();
                        String output = TestDo.doSome(input);
                        System.out.println(Thread.currentThread().getName() + ":" + output);
                        
                        sem.release();
                    } 
                    catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                    
                }
            }).start();
        }
        
        /*for(int i=0;i<10;i++)
        {
            String input = i + "";
            try
            {
                sq.put(input);
            } 
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }*/
        
    }
    
}

class TestDo
{
    public static String doSome(String input)
    {
        try
        {
            Thread.sleep(1000);
        } 
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        
        String output = input + ":" + System.currentTimeMillis();
        
        return output;
    }
}

/**
 * LinkedTransferQueue的简单使用
 */
package thread04;

import java.util.Random;
import java.util.concurrent.LinkedTransferQueue;
import java.util.concurrent.TimeUnit;

public class LinkedTransferQueueTest01
{
    public static void main(String[] args)
    {
        LinkedTransferQueue<String> queue = new LinkedTransferQueue<String>();
        
        Producer p = new Producer(queue);
        Thread producer = new Thread(p);
        // 设为守护进程，使得线程执行结束后程序自动结束
        producer.setDaemon(true);
        producer.start();
        
        for(int i=0;i<10;i++)
        {
            Consumer c = new Consumer(queue);
            Thread consumer = new Thread(c);
            consumer.setDaemon(true);
            consumer.start();
            
            try
            {
                // 消费者进程休眠1秒，以便生产者获得CPU，从而生产产品
                Thread.sleep(1000);
            } 
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
    }
}

class Consumer implements Runnable
{
    private LinkedTransferQueue<String> queue;
    
    public Consumer(LinkedTransferQueue<String> queue)
    {
        this.queue = queue;
    }
    
    @Override
    public void run()
    {
        try
        {
            System.out.println(" Consumer " + Thread.currentThread().getName() + " " + queue.take());
        } 
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
}

class Producer implements Runnable
{
    private LinkedTransferQueue<String> queue;
    
    public Producer(LinkedTransferQueue<String> queue)
    {
        this.queue = queue;
    }
    
    private String produce()
    {
        return " your lucky number " + (new Random().nextInt(1000));
    }
    
    @Override
    public void run()
    {
        try
        {
            while(true)
            {
                if(queue.hasWaitingConsumer())
                {
                    queue.transfer(produce());
                }
                
                TimeUnit.SECONDS.sleep(1);
            }
        } 
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}

同步计数器CountDownLatch：
 详解：
  在完成一组正在其他线程中执行的操作之前，允许一个或多个线程一直等待；
  用给定的计数初始化CountDownLatch；由于调用了countDown()方法，所以在当前计数到达0之前，awiait()方法会一直受阻塞（哪个线程中调用了await()方法，哪个线程就被阻塞，一直等待）；之后（当前计数到达0），会释放所有等待的线程，await的所有后续调用（线程调用await()方法后续的一些操作）都将立即返回；这种现象只出现一次，因为计数无法被重置；
 主要方法：
  CountDownLatch(int count) ：构造一个用给定计数初始化的CountDownLatch实例对象；
  void await()：使当前线程在锁存器倒计数至0之前一直等待，除非线程被中断；
  boolean await(long timeout, TimeUnit unit) ：使当前线程在锁存器倒计数至0之前一直等待，除非线程被中断或超出了指定的等待时间；
  void countDown()：递减锁存器的计数，如果计数到达0，则释放所有等待的线程；
  long getCount()：返回当前计数；
 应用场景：
  在一些应用场合中，需要等待某个条件到达要求后才能做后面的事情；同时当线程都完成后也会触发事件，以便进行后面的操作；

/**
 * CountDownLatch的简单使用
 */
package thread04;

import java.util.concurrent.CountDownLatch;

public class CountDownLatchTest01
{
    private static CountDownLatch latch = new CountDownLatch(3);
    
    public static void main(String[] args)
    {
        Worker worker1 = new Worker("张三 程序员1", latch);
        Worker worker2 = new Worker("李四  程序员2", latch);
        Worker worker3 = new Worker("王五  程序员3", latch);
        
        Thread t1 = new Thread(worker1);
        Thread t2 = new Thread(worker2);
        Thread t3 = new Thread(worker3);
        
        t1.start();
        t2.start();
        t3.start();
        
        try
        {
            latch.await();
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        
        System.out.println("Main is end!");
    }
}

class Worker implements Runnable
{
    private String workerName;
    private CountDownLatch latch;
    
    public Worker(String workerName, CountDownLatch latch)
    {
        this.workerName = workerName;
        this.latch = latch;
    }
    
    @Override
    public void run()
    {
        try
        {
            System.out.println("Worker " + workerName + " is begin!");
            Thread.sleep(1000L);
            System.out.println("Worker " + workerName + " is end!");
            
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        latch.countDown();
    }
}

信号量Semaphore：
 详解：
  通过对信号量的不同操作，可以分别实现进程间的互斥与同步；
  Semaphore可以控制某个资源被同时访问的任务数（维护了一个许可集合），它通过acquire()获取一个许可，release()释放一个许可；如果被同时访问的任务数已满，则其他acquire的任务进入等待状态，直到有一个任务被release掉，它才能得到许可；
 使用场景：
  排队场景，资源有限的房间，资源有限的群等等，常见的实际应用场景包括线程池、连接池等；

/**
 * Semaphore的简单使用
 */
package thread04;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.ReentrantLock;

public class SemaphoreTest01
{
    public static void main(String[] args)
    {
        ExecutorService es = Executors.newCachedThreadPool();
        
        final Semaphore sh = new Semaphore(5);
        
        ReentrantLock rl = new ReentrantLock();
        
        for(int i=0;i<10;i++)
        {
            final int num = i;
            
            Runnable run = new Runnable()
            {
                @Override
                public void run()
                {
                    // rl.lock();
                    try
                    {
                        sh.acquire();
                        System.out.println("线程 " + Thread.currentThread().getName() + " 获得许可：" + num);
                        for(int i=0;i<999999;i++);
                        sh.release();
                        System.out.println("线程 " + Thread.currentThread().getName() + "释放许可：" + num);
                        System.out.println("当前允许进入的任务个数： " + sh.availablePermits());
                    }
                    catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                    finally
                    {
                        // rl.unlock();
                    }
                }
            };
            es.execute(run);
        }
        
        es.shutdown();
    }
}

障碍器CyclicBarrier：
 详解：
  又叫同步计数器；
 使用场景：
  你希望创建一组任务，它们并发地执行工作，另外的一个任务在这一组任务并发执行结束前一直阻塞等待，直到该组任务全部执行结束，这个任务才得以执行；

/**
 * CyclicBarrier的简单使用
 */
package thread04;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierTest01
{
    public static void main(String[] args)
    {
        // 创建CyclicBarrier对象，并设置执行完一组5个线程的并发任务后，再执行MainTask任务 
        CyclicBarrier cb = new CyclicBarrier(5, new MainTask());
        
        SubTask sb1 = new SubTask("A", cb);
        SubTask sb2 = new SubTask("B", cb);
        SubTask sb3 = new SubTask("C", cb);
        SubTask sb4 = new SubTask("D", cb);
        SubTask sb5 = new SubTask("E", cb);
        
        new Thread(sb1).start();
        new Thread(sb2).start();
        new Thread(sb3).start();
        new Thread(sb4).start();
        new Thread(sb5).start();
        
    }
}

/**
 * 最后要执行的任务
 * @author Administrator
 *
 */
class MainTask implements Runnable
{
    @Override
    public void run()
    {
        System.out.println("前面的并发任务全部执行完毕后，开始执行最后任务...");
    }
}

/**
 * 一组并发任务
 * @author Administrator
 *
 */
class SubTask implements Runnable
{
    private String name;
    private CyclicBarrier cb;
    
    public SubTask(String name, CyclicBarrier cb)
    {
        this.name = name;
        this.cb = cb;
    }
    
    @Override
    public void run()
    {
        System.out.println("并发任务 " + name + " 开始执行...");
        for(int i=0;i<999999;i++);
        System.out.println("并发任务 " + name + " 执行完毕，通知障碍器...");
        
        try
        {
            // 每执行完一项任务就通知障碍器
            cb.await();
        }
        catch (InterruptedException | BrokenBarrierException e)
        {
            e.printStackTrace();
        }
    }

    public String getName()
    {
        return name;
    }
    public void setName(String name)
    {
        this.name = name;
    }
    public CyclicBarrier getCb()
    {
        return cb;
    }
    public void setCb(CyclicBarrier cb)
    {
        this.cb = cb;
    }
}