线程池

华为面试题

先看一道华为面试题要求第一个线程从1-26，第二个线程从a-z 然后两个线程同时执行，交替输出。

我们先用LockSupport ，启了两个线程 t1 t2 先让t1输出一个（1）然后叫醒t2 此时t2第一句就是让自己阻塞防止和t1第一句打印混乱，t1叫醒t2之后 t2紧接着打印这里也就是A 最后叫醒t1 就这样来来回回阻塞叫醒 26次 1-26就打印完了。

package com.mianshi;

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.locks.LockSupport;

public class LockSupport_A_z1_26test1 {
    static Thread t1=null,t2=null;
    public static void main(String[] args) throws Exception {
//        char[] aI="1234567".toCharArray();
//        char[] aC="ABCDEFG.toCharArray();
        List aI= Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9,10);
        List aC = Arrays.asList('A', 'B', 'C', 'D', 'E', 'F', 'G','H','I','J');

        t1=new Thread(()->{
            for (Object c:aI){
                System.out.println(c);
                LockSupport.unpark(t2);//叫醒t2
                LockSupport.park();//t1 自己阻塞
            }
        },"t1");
        t2=new Thread(()->{
            for (Object c:aC){
                LockSupport.park();//t2上来先自己阻塞
                System.out.println(c);
                LockSupport.unpark(t1);//叫醒T1
            }
        },"t2");

        t1.start();
        t2.start();
    }
}

高并发理论-线程池

Callable

package com.xianchengchi;

import java.sql.CallableStatement;
import java.util.concurrent.*;

public class Callable_test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<String> c= new Callable() {
            @Override
            public Object call() throws Exception {
                return "Hello Callable";
            }
        };
        ExecutorService service= Executors.newCachedThreadPool();
        Future<String> future=service.submit(c);//异步

        System.out.println(future.get());
        service.shutdown();
    }
}

这里我们扩展两个概念同步和异步

同步：把任务交给线程池之后等待线程池执行完之后返回值主线程才能继续

异步：把任务交给线程池之后主线程该干啥干啥不受影响

线程池的七个参数

1.corePoolSize核心线程数：最开始的时候有这个线程里面是有一定的核心线程数的。

2.maxximumPoolSize最大线程数：线程数不够了，能扩展到啊最大线程数是多少。

3.KeepAliveTime生存时间：意思是这个线程有很长时间没干活了请你把它归还给操作系统。

4.TimeUnit.SECONDS生存时间的单位：毫秒还是纳秒还是秒自己去定义。

5.任务队列：就是上节课讲的BlockingQueue，各种各样的BlockingQueue你读可以往里面扔，我们这用的是ArrayBlockingQueue，参数最多可以装四个任务。

6.线程工厂：defaultThreadFactory

7.拒绝策略：指的是线程池忙，而且任务队列满的时候我们要执行各种拒绝策略，jdk默认提供了4种拒绝策略，也可以自己定义。

Abort:抛异常
Discard：扔到；不抛出异常
DiscardOldest：扔掉排队时间最长的
CallerRuns：调用者处理结果