多线程高级部分学习记录

线程池部分（全是重点，这里只做记录总结，真的底层和特性请移步看别的博客）：

面向对象的方式创建线程池对象

使用工具类快速创建线程池对象:
    Executors
    
静态方法:
    static ExecutorService newFixedThreadPool(int nThreads)  : 指定最大线程数的线程池对象创建
    static ExecutorService newCachedThreadPool()  : 不指定最大线程数的线程池对象创建(最多有int最大值那么多线程对象)
        
ExecutorService : 线程池对象的父接口
     Future<?> submit(Runnable task) : 往线程池中提交一个没有结果的线程任务
     Future<T> submit(Runnable task, T result)  : 往线程池中提交一个自定义结果的线程任务
     Future<T> submit(Callable<T> task) : 往线程池中提交一个带有结果的线程任务
     
使用步骤:
    1. Executors工具类调用静态方法获取线程池对象
    2. 使用ExecutorService对象调用提交方法并传入线程任务

//创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。示例代码如下：
ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 100; i++) {
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"执行了");
                }
            });
        }
        executorService.shutdown();

 

 👆证明了灵活回收再利用。

ExecutorService executorService1 = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 100; i++) {
            executorService1.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"执行了");
                }
            });
        }

代码设定最大线程数量为10，实际执行确实最高线程名为10。

通过面向过程的方式创建线程池对象：

线程池对象的类名 : ThreadPoolExecutor

如何创建线程池对象:
	ThreadPoolExecutor(int corePoolSize, //核心线程数 -> 正式员工
                       int maximumPoolSize, //最大线程池 -> 总员工
                       long keepAliveTime, //临时线程存活时间数
                       TimeUnit unit, //临时线程存活时间单位
                       BlockingQueue<Runnable> workQueue,//阻塞队列 -> 店外排队的人(可服务) 
                       ThreadFactory threadFactory, //线程工厂 -> 人才市场
                       RejectedExecutionHandler handler) //等待拒绝策略 -> 阻塞队列外服务不了的顾客
        
参数的注意事项:
	1. corePoolSize <= maximumPoolSize -> 核心线程数 <= 总线程数
	2. keepAliveTime : 不能小于0
	3. TimeUnit : 不能为null
	4. 阻塞队列不能为null
	5. ThreadFactory 不能为null
	6. RejectedExecutionHandler : 不能为null

记得没错的话是core线程常驻，也就是一直都在，而因为需要的线程数量超过了corePoolSize的数量就会创建临时线程，临时线程在空闲时间达到KeepAliveTime后会被回收！个人理解的过程：先是核心线程来完成任务，核心线程不够了就创建临时线程，临时线程还不够了就进任务队列等待，等待的都满了那就要用到等待拒绝策略了。再看具体策略决定后续操作。

BlockingQueue<E>

BlockingQueue<E> : 阻塞队列的根节点

ArrayBlockingQueue<E> : 具体使用的阻塞队列的类

ArrayBlockingQueue<E> : Collection 接口的子实现类 肯定具备Collection接口中的增删改查和遍历方法

构造方法:
	ArrayBlockingQueue(int capacity): 创建队列时指定队列的长度

特殊方法:
	void put(E e):往队列的尾部添加元素,如果队列已满则等待
	 E take()  :移除队列头部的元素,如果队列没有元素则等待

public class ArrayBlockingQueueDemo {
    public static void main(String[] args) throws InterruptedException {
        ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<String>(3);

        queue.put("张三丰");
        queue.put("张翠山");
        queue.put("张无忌");
        //queue.put("赵敏");

        System.out.println("queue = " + queue);

        //取出元素 (移除队列的头)
        System.out.println("queue.take() = " + queue.take());
        System.out.println("queue.take() = " + queue.take());
        System.out.println("queue = " + queue);
        System.out.println("queue.take() = " + queue.take());
        System.out.println("queue.take() = " + queue.take());
        System.out.println("======================");
    }
}

这里如果继续queue.put("赵敏");会无限等待，它在等着移除一个元素。但这里并没有移除操作。

ThreadFactory

ThreadFactory threadFactory  : 线程工厂 -> 线程池获取线程对象的地方

Executors 工具类中有静态方法:
	static ThreadFactory defaultThreadFactory()  	

RejectedExecutionHandler

RejectedExecutionHandler handler : 任务等待拒绝策略 -> 不在阻塞队列中的线程任务

RejectedExecutionHandler : 是ThreadPoolEexcutor类中的静态内部类的父接口
	static class ThreadPoolExecutor.AbortPolicy 
	static class ThreadPoolExecutor.CallerRunsPolicy 
	static class ThreadPoolExecutor.DiscardOldestPolicy 
	static class ThreadPoolExecutor.DiscardPolicy  
	//静态成员内部类对象的创建
	Outer.Inner inner = new Outer.Inner();

如何获取此类的对象 : 
	new ThreadPoolExecutor.AbortPolicy() : 拒绝阻塞队列外的所有等待任务,并报错!! -> 默认方式,推荐方式
    new ThreadPoolExecutor.DiscardPolicy() : 拒绝阻塞队列外的所有等待任务,不报错 -> 不推荐
    new ThreadPoolExecutor.DiscardOldestPolicy() : 把阻塞队列外等待最久的任务添加到阻塞队列中,并"随机"移除阻塞队列中的某个任务 
    new ThreadPoolExecutor.CallerRunsPolicy() :拒绝阻塞队列外的所有等待任务,但是交付给其他线程完成

验证拒绝策略的代码：

//threadPool 线程池 一共能处理多少个线程任务 : 总线程数+等待队列的容量
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2,//核心
                3,//总
                20, //时间
                TimeUnit.SECONDS,//时间单位
                new ArrayBlockingQueue<Runnable>(1),//排队的人
                Executors.defaultThreadFactory(),//线程工厂
                new ThreadPoolExecutor.CallerRunsPolicy());//拒绝策略, 把不能服务的线程任务交付给其他线程对象完成

        for (int i = 1; i <= 5; i++) {
            final int y = i;
            threadPool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + " :World " + y);
                }
            });
        }

        //关闭线程池
        threadPool.shutdown();

线程安全问题：

volatile关键字

案例:
//事物描述类
class Money {
    public static int money = 100000;
    //此变量被标记为不稳定的变量, 线程优先去内存中寻找值
    //public static volatile int money = 100000;
}

//线程1: 小红
class MyThread1 extends  Thread {
    @Override
    public void run() {
        while(Money.money == 100000){

        }

        System.out.println("结婚基金已经不是十万了");
    }
}

//线程2: 小刚
class MyThread2 extends Thread {
    @Override
    public void run() {
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Money.money = 90000;
    }
}

volatile 关键字 : 不稳定的,易变的
	被其修饰的变量,会强制要求线程对象去内存中找真实值,而不是去线程栈中找临时变量值!!
    
解决方案1 : 在Money变量前面加volatile关键字 
解决方案2 : 上锁,同步操作!
    上锁的特点: 一个线程操作共享数据的时候,不让其他的线程对象去使用. 线程对象就会有足够的时间去内存中找共享数据的真实值;(优先去内存中找)

public class VolatileDemo {
    public static void main(String[] args) {
        //创建线程对象
        MyThread1 小红 = new MyThread1();
        MyThread2 小刚 = new MyThread2();

        小红.start();
        小刚.start();
    }
}
class Money {
    //新new的锁对象
    public static Object lock = new Object();
    //共享数据
    public static int money = 100000;
}

//小红
class MyThread1 extends  Thread {
    @Override
    public void run() {
        while(true){
            //上锁: 线程访问共享数据的时候优先访问内存中的共享数据而不是临时变量区
            synchronized (Money.lock){
                if(Money.money != 100000){
                    System.out.println("结婚基金已经不是十万了");
                    break;
                }
            }
        }
    }
}

//小刚
class MyThread2 extends Thread {
    @Override
    public void run() {
        synchronized (Money.lock) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
			//原子性操作
            Money.money = 90000;
        }
    }
}

 在这上面都还是运行了很多次。。。

原子性和非原子性！！！！！重中之重

原子性操作 : 不可以分割的操作 -> 原子性操作
	//一句代码要么不做,要做就一定是做完的
	例如 : 赋值操作  int a = 10;

非原子性操作 : 可以分割的操作
	//一句代码可能需要多个步骤完成,每个步骤之间有"时间"间隔
	例如: 自增自减 a++; -> 1. a + 1 2. a = a+1;
	例如: 拓展的赋值运算符 a += 10; 1. a + 10 2. a = a + 10;

volatile 解决不了非原子性操作的线程安全问题! --> volatile只能解决原子性操作的线程安全问题

volatile关键字不能解决非原子性操作的安全问题！！！！