java 集合初始化

ArrayList
1.ArrayList构造一个默认初始容量为10的空列表。
2.自动容量1.5倍。

3.单线程中才使用而在多线程中可以选择Vector。

 

ArrayList和LinkedList的大致区别： 

1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。 
2.对于随机访问get，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。 
3.对于在列表中间新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动 数据。 

HashMap
1.线程不安全
2.默认初始容量16，必须为2的幂
3.加载因子默认0.75
4.多线程中使用ConcurrentHashMap

BlockingQueue 阻塞队列
在多线程领域：所谓阻塞，在某些情况下会挂起线程（即阻塞），一旦条件满足，被挂起的线程又会自动被唤醒
BlockingQueue的核心方法：

1)offer(anObject):表示如果可能的话,将anObject加到BlockingQueue里,即如果BlockingQueue可以容纳,则返回true,否则返回false.

3)poll(time):取走BlockingQueue里排在首位的对象,若不能立即取出,则可以等time参数规定的时间,取不到时返回null

 

2)put(anObject):把anObject加到BlockingQueue里,如果BlockQueue没有空间,则调用此方法的线程被阻断直到BlockingQueue里面有空间再继续

 

4)take():取走BlockingQueue里排在首位的对象,若BlockingQueue为空,阻断进入等待状态直到Blocking有新的对象被加入为止

 

作为开发者，我们需要注意的是，如果构造一个LinkedBlockingQueue对象，而没有指定其容量大小，LinkedBlockingQueue会默认一个类似无限大小的容量（Integer.MAX_VALUE），这样的话，如果生产者的速度一旦大于消费者的速度，也许还没有等到队列满阻塞产生，系统内存就有可能已被消耗殆尽了。

 

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.LinkedBlockingQueue;

 

/**

 * @author jackyuj

 */

public class BlockingQueueTest {

 

    public static void main(String[] args) throws InterruptedException {

        // 声明一个容量为10的缓存队列

        BlockingQueue<String> queue = new LinkedBlockingQueue<String>(10);

 

        Producer producer1 = new Producer(queue);

        Producer producer2 = new Producer(queue);

        Producer producer3 = new Producer(queue);

        Consumer consumer = new Consumer(queue);

 

        // 借助Executors

        ExecutorService service = Executors.newCachedThreadPool();

        // 启动线程

        service.execute(producer1);

        service.execute(producer2);

        service.execute(producer3);

        service.execute(consumer);

 

        // 执行10s

        Thread.sleep(10 * 1000);

        producer1.stop();

        producer2.stop();

        producer3.stop();

 

        Thread.sleep(2000);

        // 退出Executor

        service.shutdown();

    }

}

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94

import java.util.Random; import java.util.concurrent.BlockingQueue; import java.util.concurrent.TimeUnit;   /**  * 消费者线程  *  * @author jackyuj  */ public class Consumer implements Runnable {       public Consumer(BlockingQueue<String> queue) {         this.queue = queue;     }       public void run() {         System.out.println("启动消费者线程！");         Random r = new Random();         boolean isRunning = true;         try {             while (isRunning) {                 System.out.println("正从队列获取数据...");                 String data = queue.poll(2, TimeUnit.SECONDS);                 if (null != data) {                     System.out.println("拿到数据：" + data);                     System.out.println("正在消费数据：" + data);                     Thread.sleep(r.nextInt(DEFAULT_RANGE_FOR_SLEEP));                 } else {                     // 超过2s还没数据，认为所有生产线程都已经退出，自动退出消费线程。                     isRunning = false;                 }             }         } catch (InterruptedException e) {             e.printStackTrace();             Thread.currentThread().interrupt();         } finally {             System.out.println("退出消费者线程！");         }     }       private BlockingQueue<String> queue;     private static final int      DEFAULT_RANGE_FOR_SLEEP = 1000; }   import java.util.Random; import java.util.concurrent.BlockingQueue; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger;   /**  * 生产者线程  *  * @author jackyuj  */ public class Producer implements Runnable {       public Producer(BlockingQueue queue) {         this.queue = queue;     }       public void run() {         String data = null;         Random r = new Random();           System.out.println("启动生产者线程！");         try {             while (isRunning) {                 System.out.println("正在生产数据...");                 Thread.sleep(r.nextInt(DEFAULT_RANGE_FOR_SLEEP));                   data = "data:" + count.incrementAndGet();                 System.out.println("将数据：" + data + "放入队列...");                 if (!queue.offer(data, 2, TimeUnit.SECONDS)) {                     System.out.println("放入数据失败：" + data);                 }             }         } catch (InterruptedException e) {             e.printStackTrace();             Thread.currentThread().interrupt();         } finally {             System.out.println("退出生产者线程！");         }     }       public void stop() {         isRunning = false;     }       private volatile boolean      isRunning               = true;     private BlockingQueue queue;     private static AtomicInteger  count                   = new AtomicInteger();     private static final int      DEFAULT_RANGE_FOR_SLEEP = 1000;