多线程并发阻塞队列

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
/**
 *测试多线程操作共享数据（互斥）
 */
publicclass BlockingQueueTest {
   publicstaticvoid main(String[] args) {
      final BlockingQueue queue = new ArrayBlockingQueue(3);
      for(inti=0;i<2;i++){
        new Thread(){
           publicvoid run(){
              while(true){
                 try {
                    Thread.sleep((long)(Math.random()*1000));
                    System.out.println(Thread.currentThread().getName() + "准备放数据!");                
                    queue.put(1);
                    System.out.println(Thread.currentThread().getName() + "已经放了数据，" +                   
                            "队列目前有" + queue.size() + "个数据");
                 } catch (InterruptedException e) {
                    e.printStackTrace();
                 }
              }
           }
        }.start();
      }
     
      new Thread(){
        publicvoid run(){
           while(true){
              try {
                 //将此处的睡眠时间分别改为100和1000，观察运行结果
                 Thread.sleep(1000);
                 System.out.println(Thread.currentThread().getName() + "准备取数据!");
                 queue.take();
                 System.out.println(Thread.currentThread().getName() + "已经取走数据，" +                  
                      "队列目前有" + queue.size() + "个数据");             
              } catch (InterruptedException e) {
                 e.printStackTrace();
              }
           }
        }
       
      }.start();      
   }
}


2.多线程间通信
 可以与condition相同的功能，通过队列的阻塞功能来实现多线程间通信）



import java.util.Collections;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
importjava.util.concurrent.atomic.AtomicInteger;
publicclass BlockingQueueCommunication {
   publicstaticvoid main(String[] args) {
      final Business business = new Business();
      new Thread(
           new Runnable() {
              publicvoid run(){
                 for(inti=1;i<=50;i++){
                    business.sub(i);
                 }
              }
           }
      ).start();
      for(inti=1;i<=50;i++){
        business.main(i);
      }
   }
    static class Business {
        BlockingQueue<Integer> queue1 = new ArrayBlockingQueue<Integer>(1);
        BlockingQueue<Integer> queue2 = new ArrayBlockingQueue<Integer>(1);
        {
          Collections.synchronizedMap(null);
          try{
             System.out.println("xxxxxdfsdsafdsa");
             queue2.put(1);
            }catch(InterruptedException e){
             e.printStackTrace();
            }
        }

        public  void sub(inti){
          try {
             queue1.put(1);
           } catch (InterruptedException e) {
              e.printStackTrace();
           }
           for(intj=1;j<=10;j++){
              System.out.println("sub thread sequece of " + j + ",loop of " + i);
           }
           try {
             queue2.take();
           } catch (InterruptedException e) {
             
              e.printStackTrace();
           }
        }
        public  void main(inti){
          try {
             queue2.put(1);
           } catch (InterruptedException e1) {
              e1.printStackTrace();
           }
           for(intj=1;j<=100;j++){
              System.out.println("main thread sequece of " + j + ",loop of " + i);
           }
           try {
             queue1.take();
           } catch (InterruptedException e) {
              e.printStackTrace();
           }
        }
     }
}