线程通信的练习

在集合框架中，最高级别的抽象一共有两个：Collection，Map

Collection一共有三个常用字接口：List Set Qieue

队列的入队与出队

add    入队，当队列满了会抛异常

offer  入队，当队列满了会返回false

put  入队。当队列为空线程会进入阻塞状态（只有在类型为BlockingQueue是才会使用，Queue无法使用）

remove    出队，当队列为空是会抛出异常

poll  吹对，当队列为空是会返回null

take 出队，当队列为空时，进入阻塞状态（只有在类型为BloingQueue时才会使用。Queue无法使用）

peek    不出队，只取出队列中的第一个元素

、

public class QueuePractice {
    public static void main(String[] args) {
        // Queue对象的创建
        // 创建一个先入先出的队列
        // Queue<String> queue = new LinkedList<>();

        // 创建一个容量为3的队列
        Queue<String> queue = new ArrayBlockingQueue<>(2);

        // 入队
        // 不管是add，还是offer，添加失败，返回都是false
        // 当队列满了，再添加，会抛异常
        //queue.add("one");
        //queue.add("two");
        //queue.add("three");

        // 当队列满了，再添加，不抛异常，而是添加失败
        //queue.offer("1");
        //queue.offer("2");
        //queue.offer("3");

        // 出队
        // 把队列最开头的元素取出，但是不出列
        //String peek = queue.peek();

        // 把队列最开头的元素取出，并且出列
        // 当队列为空，会抛异常
        String remove = queue.remove();

        // 当队列为空，取出null，不会抛异常
        //String poll = queue.poll();

        System.out.println(queue);
        //System.out.println(peek);
        //System.out.println(poll);
        System.out.println(remove);
    }

}

高级多线程

线程池

概述

在系统中，通过new关键字，创建出的线程对象(Thread对象，而不是Runnable对象)，创建好了之后，只能启动一次

通过new关键字，创建出的线程对象，每个大约占用内存1MB左右，假设内存指定2GB大小，那么只能创建2048个线程。极易造成内存溢出

虽然JVM有自带的垃圾回收机制，但是频繁地创建与销毁线程，也是会耗费系统资源的

池化机制是提前将一定数量的资源准备好，进而去使用，当使用结束之后，不会销毁此资源，而是将此资源重新标志为未使用，就可以为其他的使用资源的线程去使用

池化机制是为了重复使用某些系统资源而引入的一种技术

API

• Executors.newFixedThreadPool(线程数量)

  创建一个线程池对象

• threadPool.submit(runnable)

  通过线程池，调度线程任务

• threadPool.shutdown()

  标记线程池不再继续使用了 再次往内部放入线程任务，会抛异常 等待线程池内部的所有线程任务，执行结束，线程池才会关闭掉

• threadPool.shutdownNow()

  立即销毁线程池 进而会销毁线程池内部正在执行的所有任务

  常见的线程池有哪些

• FixedThreadPool

• CachedThreadPool

• ScheduledThreadPool

• 带返回值的线程任务

• Callabl接口，因为Runna接口没有返回值，所以必须要用有返回值的Callab，此类型的返回值为object类需要搭配Future类型
• Future 未来的 即一个线程任务在执行一段时间才会在将来出现结果
• 所以在使用线程池的时候可以为submit准备一个Callble对象，但在subimt之后不会产生任何堵塞
• 假如submit方法 填入的是Callable类型的对象，会返回一个Future类型的值
• 这个对象不会产生阻塞，但在调用这个对象的get方法是，会产生阻塞    

• public class BlockingQueuePractice {
      public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
    ExecutorService threadpool=Executors.newFixedThreadPool(5);
          Callable<String> callable = new Callable<String>() {
              @Override
              public String call() throws Exception {
                  StringBuilder stu=new StringBuilder();
                  Thread.sleep(500);
                  stu.append("one");
                  System.out.println("第一次输入");
                  Thread.sleep(500);
                  stu.append("two");
                  System.out.println("第二次输入");
                  return stu.toString();
              }
          };
          Future<String>futureTask=threadpool.submit(callable);
          String futureResult=futureTask.get(2,TimeUnit.DAYS);
          System.out.println(futureResult);
          threadpool.shutdown();
      }
  
  
  }