Java多线程常见概念

package com.aaa.threaddemo;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
/*
 * 一 线程池中的四种 任务拒绝类型！
//线程池任务满载后采取的任务拒绝的类型有哪几种？    前提是当前的任务，等于线程池中的最大数量。
 * 1.          ThreadPoolExecutor.AbortPolicy     线程池默认的拒绝策略，数量等于线程池中的最大数量，丢这个异常，和它相关的任务不执行
 * 
 * 2.         ThreadPoolExecutor.DiscardPolicy    丢弃不能执行的新加任务 不报异常  
 * 
 * 3.         ThreadPoolExecutor.CallerRunsPolicy    重试添加当前的任务， 自动重试调用execute（） 方法
 * 
 * 4.         ThreadPoolExecutor.DiscardOldestPolicy  把队列中等待最久的任务丢掉，执行新来的任务（渣男行为！）

RejectedExecutionHandler rejectHandler = new ThreadPoolExecutor.DiscardOldestPolicy();

二 什么是work queue？ 在线程池中有几种方式？ 列举一些常见的【阻塞】队列。

    就是一个队列，当线程池中的任务大于核心线程，小于最大线程池的数量时。  使用队列，将新来的任务放在里面。
    
    三种类型的阻塞队列可以选择 BlockingQueue
        无界队列
        有界队列
        同步移教
    
    1.无界队列
        存放任务的队列是没有上限的，大小无限制。 可以一直往队列中put item。
        PriorityBlockingQueue    支持优先级排序
        DelayQueue                使用优先级实现的
        LinkedTransferQueue        链表结构组成的
                
    2.有界队列
        ArrayBlockingQueue    数组组成的
        LinkedBlockingQueue    链表
        
    3. 同步移教队列        SynchronousQueue
        直接将任务交给工作线程，而不是让队列处理。
        SynchronousQueue 本身不是一个真正的队列，是线程之间的一种移交机制。
        想要将一个元素放到SynchronousQueue中，必须要有另一个线程来接收这个元素
        只有在无界限线程池或者是有拒绝策略时，才建议使用该队列。

三 Java中提供了那四种常用的线程池解析？
        Java线程池的顶级接口是executor，严格来说，他只是一个线程执行的工具
        真正的线程池接口是  executorService
        
        newCacheThreadPool    更具需要创建新线程池的线程池 ，旧的的线程可用时将重用他们。
        
        newfixedThreadPool    可重用，固定线程数， 共享的无界队列运行。
        
        newScheduledThreadPool    定期执行 在给定延迟后运行命令
        
        newSingleThreadExecutor        起死回生，在线程发生异常时，可以重新创建一个线程，代替原来的线程，继续执行。
        
四  线程池中常见的参数设置？
            corePoolSize,        //1 线程池的核心数量
            maximumPoolSize,    //2 线程池中的最大容量
            keepAliveTime,         //3 非核心线程的生存时间
            TimeUnit.SECONDS,    //4 生存时间的具体单位  分 秒 毫秒。。。。
            workQueue,             //5 采用什么样的队列方式  
            rejectedExecutionHandler    //6 线程池中的拒绝策略
 


);
 * 
 */
public class ThreadDemo {
    public static void main(String[] args) {
                         
    }
}

class ThreadTest{
    public static void main(String[] args) {
        System.out.println(CPU_COUNT);
    }
    //参数初始化？   返回可用处理器 Java虚拟机的数量  获取CPU的核心数量
    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();     //获取本电脑的CPU核心数量
    
    private static final int corePoolSize = Math.max(2, Math.min(CPU_COUNT - 1, 4));    //核心线程的数量设置
    
    private static final int maximumPoolSize = CPU_COUNT * 2 + 1;  //线程池的最大容量
    
    private static final int keepAliveTime = 30;    //非核心线程存活的时间
    
    // 核心线程已经满了，将新的任务放在队列中。  如果队列也满了，就使用非核心线程
    BlockingQueue<Runnable>  workQueue = new SynchronousQueue<>();        // 这里用的是一个 阻塞的队列
    BlockingQueue<Runnable>  woRunnables = new LinkedBlockingDeque<>();
//    BlockingQueue<Runnable>  woRunnables2  = new ArrayBlockingQueue<>();
    
    //生产线程的工厂
    ThreadFactory threadFactory = new ThreadFactory(){
            private final AtomicInteger mCount = new AtomicInteger(1);
            
            public Thread newThread(Runnable r){
                return new Thread(r, "AdvacnedAsyncTask #" + mCount.getAndIncrement());
            }        
    };
    
//    
//    // 线程池已经满了，设置拒绝的策略
//    RejectedExecutionHandler rejectedExecutionHandler = new ThreadPoolExecutor.DiscardOldestPolicy(); //会把阻塞队列中 最旧的一个丢弃掉
//    RejectedExecutionHandler rejectedExecutionHandler2 = new ThreadPoolExecutor.AbortPolicy(); // 和它相关的任务 都不执行  默认的拒绝方式
//    RejectedExecutionHandler rejectedExecutionHandler3 = new ThreadPoolExecutor.DiscardPolicy(); // 丢弃无法执行的新加任务，无异常
//    RejectedExecutionHandler rejectedExecutionHandler4 = new ThreadPoolExecutor.CallerRunsPolicy(); // 不断尝试将新任务 添加进来
    
    RejectedExecutionHandler rejectedExecutionHandler = new ThreadPoolExecutor.DiscardOldestPolicy();
    
    //线程池中的各个对象，创建线程
    ThreadPoolExecutor mExecutor = new ThreadPoolExecutor(
            corePoolSize,        //1 线程池的核心数量
            maximumPoolSize,    //2 线程池中的最大容量
            keepAliveTime,         //3 非核心线程的生存时间
            TimeUnit.SECONDS,    //4 生存时间的具体单位  分 秒 毫秒。。。。
            workQueue,             //5 采用什么样的队列方式  
            rejectedExecutionHandler    //6 线程池中的拒绝策略
    );
    

}