JAVA5 并发库的使用

 

一、线程池

public static void main(String[] args) {
    // 产生线程池，有3个线程，使用固定线程池创建
    //ExecutorService threadPool = Executors.newFixedThreadPool(3);
    //产生线程池，动态创建线程池的大小
    ExecutorService threadPool = Executors.newCachedThreadPool();
    //向线程池添加10个任务
    for (int i=1; i<10; i++) {
        final int task = i;
        threadPool.execute(new Runnable() {
            @Override
            public void run() {
                for (int j=0; j<10; j++) {
                    try {
                        Thread.sleep(20);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println(
                            Thread.currentThread().getName() +
                            " is  looping of " + j +
                            " for task " + task);
                }

            }
        });
    }

    //线程调度的使用
    //该功能为定时运行6秒以后运行，然后每隔2秒运行一次
    Executors.newScheduledThreadPool(3).scheduleAtFixedRate(
            new Runnable() {
                @Override
                public void run() {
                    // TODO Auto-generated method stub
                    System.out.println("bomb....");
                }
            },
            6,
            2,
            TimeUnit.SECONDS);
}

二、并发锁(lock)

Lock比传统线程模型中的synchronized方式更加面向对象。

Lock lock = new ReentrantLock();
lock.lock();
try {
........
} finally {
  lock.unlock();
}

读写锁：读锁不互斥，读锁与写锁互斥，写锁与写锁互斥

//从JAVA文档中找到的，如果数据没有读到，就解开读锁，加上写锁
class CachedData {
   Object data;
   volatile boolean cacheValid;
   ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

   void processCachedData() {
     rwl.readLock().lock();
     if (!cacheValid) {
        // Must release read lock before acquiring write lock
        rwl.readLock().unlock();
        rwl.writeLock().lock();
        // Recheck state because another thread might have acquired
        //   write lock and changed state before we did.
        if (!cacheValid) {
          data = ...
          cacheValid = true;
        }
        // Downgrade by acquiring read lock before releasing write lock
        //我的理解，写上读锁，下面的写锁降级成更新锁
        rwl.readLock().lock();
        rwl.writeLock().unlock(); // Unlock write, still hold read
     }

     use(data);
     rwl.readLock().unlock();
   }
 }

 

三、锁的条件(Condition)

Condition的功能就是在传统线程技术中的wait和notify的功能。

/**
 * 每个方法各执行分10次和5次运行
 *
 */
public class ConditionTest {

    public static void main(String[] args) {
        ExecutorService service = Executors.newSingleThreadExecutor();
        final Business2 business = new Business2();
        service.execute(new Runnable(){

            public void run() {
                for(int i=0;i<50;i++){
                    business.sub();
                }
            }

        });

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

}

class Business2{
    Lock lock = new ReentrantLock();
    //为了达到线程间通信
    Condition condition = lock.newCondition();
    boolean bShouldSub = true;
    public void sub(){
        lock.lock();
        if(!bShouldSub)
            try {
                condition.await();//线程等待
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        try
        {
            for(int i=0;i<10;i++){
                System.out.println(Thread.currentThread().getName() + " : " + i);
            }
            bShouldSub = false;
            //通知其他的线程
            condition.signal();
        }finally{
            lock.unlock();
        }
    }

    public void main(){
        lock.lock();
        if(bShouldSub)
            try {
                condition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        try
        {
            for(int i=0;i<5;i++){
                System.out.println(Thread.currentThread().getName() + " : " + i);
            }
            bShouldSub = true;
            condition.signal();
        }finally{
            lock.unlock();
        }
    }
}

另外，再来一个JDK中的例子，更加经典

//从JDK中找到的例子，还是JDK得例子经典
//本例子是一个可阻塞的队列
class BoundedBuffer {
   final Lock lock = new ReentrantLock();
   //此处用到2个Condition，是为了区别取和放操作
   final Condition notFull  = lock.newCondition();
   final Condition notEmpty = lock.newCondition();
   //队列为100
   final Object[] items = new Object[100];
   int putptr, takeptr, count;

   public void put(Object x) throws InterruptedException {
     lock.lock();
     try {
       while (count == items.length)
         notFull.await();//队列满，等待
       items[putptr] = x;
       if (++putptr == items.length)
      putptr = 0;//指针越界
       ++count;
       notEmpty.signal();
     } finally {
       lock.unlock();
     }
   }

   public Object take() throws InterruptedException {
     lock.lock();
     try {
       while (count == 0)
         notEmpty.await();//队列空
       Object x = items[takeptr];
       if (++takeptr == items.length) takeptr = 0;
       --count;
       notFull.signal();
       return x;
     } finally {
       lock.unlock();
     }
   }
 }

 

四、信号灯(Semaphore)

维护当前访问自身的线程个数，并提供同步机制。

public class SemaphoreTest {
    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        final  Semaphore sp = new Semaphore(3);//只允许3个线程的并发
        for(int i=0;i<10;i++){
            Runnable runnable = new Runnable(){
                    public void run(){
                    try {
                        sp.acquire();//是否可以让当前线程执行
                    } catch (InterruptedException e1) {
                        e1.printStackTrace();
                    }
                    System.out.println("线程" + Thread.currentThread().getName() +
                            "进入，当前已有" + (3-sp.availablePermits()) + "个并发");
                    try {
                        Thread.sleep((long)(Math.random()*10000));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程" + Thread.currentThread().getName() +
                            "即将离开");
                    sp.release();//释放信号量
                    //下面代码有时候执行不准确，因为其没有和上面的代码合成原子单元
                    System.out.println("线程" + Thread.currentThread().getName() +
                            "已离开，当前已有" + (3-sp.availablePermits()) + "个并发");
                }
            };
            service.execute(runnable);
        }
    }

}

五、其他同步工具
CyclicBarrier：需要有多个线程同时到达才向下执行

public class CyclicBarrierTest {
        //模拟旅游集合的情况
    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        final  CyclicBarrier cb = new CyclicBarrier(3);
        for(int i=0;i<3;i++){
            Runnable runnable = new Runnable(){
                    public void run(){
                    try {
                        Thread.sleep((long)(Math.random()*10000));
                        System.out.println("线程" + Thread.currentThread().getName() +
                                "即将到达集合地点1，当前已有" + cb.getNumberWaiting() + "个已经到达，正在等候");
                        cb.await();//只有3个线程都到此处，程序才会往下走

                        Thread.sleep((long)(Math.random()*10000));
                        System.out.println("线程" + Thread.currentThread().getName() +
                                "即将到达集合地点2，当前已有" + cb.getNumberWaiting() + "个已经到达，正在等候");
                        cb.await();
                        Thread.sleep((long)(Math.random()*10000));
                        System.out.println("线程" + Thread.currentThread().getName() +
                                "即将到达集合地点3，当前已有" + cb.getNumberWaiting() + "个已经到达，正在等候");
                        cb.await();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            };
            service.execute(runnable);

        }
        service.shutdown();
    }

}

CountDownLatch：犹如倒计数器，等计数器减少到0，程序向下执行

public class CountdownLatchTest {
   //模拟赛跑的情况
    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
         //计数器
        final CountDownLatch cdOrder = new CountDownLatch(1);
        final CountDownLatch cdAnswer = new CountDownLatch(3);
        for(int i=0;i<3;i++){
            Runnable runnable = new Runnable(){
                    public void run(){
                    try {
                        System.out.println("线程" + Thread.currentThread().getName() +
                                "正准备接受命令");
                        cdOrder.await();
                        System.out.println("线程" + Thread.currentThread().getName() +
                        "已接受命令");
                        Thread.sleep((long)(Math.random()*10000));
                        System.out.println("线程" + Thread.currentThread().getName() +
                                "回应命令处理结果");
                        cdAnswer.countDown();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            };
            service.execute(runnable);
        }
        //主线程
        try {
            Thread.sleep((long)(Math.random()*10000));

            System.out.println("线程" + Thread.currentThread().getName() +
                    "即将发布命令");
            //计数器减1
            cdOrder.countDown();
            System.out.println("线程" + Thread.currentThread().getName() +
            "已发送命令，正在等待结果");
            cdAnswer.await();//等待计数器为0，然后主线程往下走
            System.out.println("线程" + Thread.currentThread().getName() +
            "已收到所有响应结果");
        } catch (Exception e) {
            e.printStackTrace();
        }
        service.shutdown();

    }
}

 

Exchanger：实现线程间的数据交换

public class ExchangerTest {

    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        final Exchanger exchanger = new Exchanger();
        service.execute(new Runnable(){
            public void run() {
                try {
                    Thread.sleep((long)(Math.random()*10000));
                    String data1 = "zxx";
                    System.out.println("线程" + Thread.currentThread().getName() +
                    "正在把数据" + data1 +"换出去");
                    String data2 = (String)exchanger.exchange(data1);//交换数据
                    System.out.println("线程" + Thread.currentThread().getName() +
                    "换回的数据为" + data2);
                }catch(Exception e){

                }
            }
        });
        service.execute(new Runnable(){
            public void run() {
                try {
                    Thread.sleep((long)(Math.random()*10000));
                    String data1 = "lhm";
                    System.out.println("线程" + Thread.currentThread().getName() +
                    "正在把数据" + data1 +"换出去");
                    String data2 = (String)exchanger.exchange(data1);
                    System.out.println("线程" + Thread.currentThread().getName() +
                    "换回的数据为" + data2);
                }catch(Exception e){

                }
            }
        });
    }

}

 

六、可阻塞的队列

 

public class BlockingQueueCondition {
    //现在2个线程的交替操作
    public static void main(String[] args) {
        ExecutorService service = Executors.newSingleThreadExecutor();
        final Business3 business = new Business3();
        service.execute(new Runnable(){

            public void run() {
                for(int i=0;i<50;i++){
                    business.sub();
                }
            }

        });

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

}

class Business3{
    BlockingQueue subQueue = new ArrayBlockingQueue(1);
    BlockingQueue mainQueue = new ArrayBlockingQueue(1);
    //匿名构造方法，相当于一个构造方法
        {
        try {
            mainQueue.put(1);//让主队列满，不能put操作
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public void sub(){
        try
        {
            mainQueue.take();
            for(int i=0;i<10;i++){
                System.out.println(Thread.currentThread().getName() + " : " + i);
            }
            subQueue.put(1);
        }catch(Exception e){

        }
    }

    public void main(){

        try
        {
            subQueue.take();
            for(int i=0;i<5;i++){
                System.out.println(Thread.currentThread().getName() + " : " + i);
            }
            mainQueue.put(1);
        }catch(Exception e){
        }
    }
}

 

七、同步集合类