线程创建的几种方式
-
new Thread(()->{}).start(); 通过lambda表达式重写了run()方法。
Thread是一个类，需要继承，因为java不可以多重继承，没那么灵活。
public static void main(String[] args) { new Thread(() -> { System.out.println("Thread方式创建线程"); },"Thread方式").start(); } -
实现Runnable接口，重写run方法
Runnable是一个接口，只需要实现，因为java不可以多重继承，接口可以让代码更灵活。
public static void main(String[] args) { //创建线程执行目标类对象--MyRunnable里面重写了run方法了 Runnable run = new MyRunnable();//MyRunnable是我们实现了Runnable接口的对象 //将Runnable接口的子类对象作为参数传递给Thread类的构造函数 Thread thread = new Thread(run); //开启线程 thread.start(); } -
实现Callable接口，重写call方法
Callable可以有返回值。
class MyThread2 implements Callable{ @Override public Object call() throws Exception { return 200; } } public static void main(String[] args) throws Exception{ //Callable接口创建线程 FutureTask futureTask = new FutureTask(new MyThread2()); //lambda表达式简化 FutureTask futureTask1 = new FutureTask(() -> { return 1024; }); new Thread(futureTask1, "BB").start(); System.out.println(futureTask1.get());//获取返回值 } -
通过线程池ThreadPool获取线程
public static void main(String[] args) { //创建一池 N 线程 ExecutorService threadPool = Executors.newFixedThreadPool(3); //创建一池 1 线程 ExecutorService threadPool1 = Executors.newSingleThreadExecutor(); //创建一池 可扩容 线程 ExecutorService threadPool2 = Executors.newCachedThreadPool(); try{ for (int i = 1; i <= 20; i++) { threadPool.execute(()->{ System.out.println(Thread.currentThread().getName() + " threadPool正在执行"); }); } for (int i = 1; i <= 20; i++) { threadPool1.execute(()->{ System.out.println(Thread.currentThread().getName() + " threadPool1正在执行"); }); } for (int i = 1; i <= 20; i++) { threadPool2.execute(()->{ System.out.println(Thread.currentThread().getName() + " treadPool2正在执行"); }); } }catch (Exception e){ e.printStackTrace(); }finally { threadPool.shutdown(); } }-
创建一池 N 线程 Executors.newFixedThreadPool(n);
源码
public static ExecutorService newFixedThreadPool(int nThreads) { return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()); }-
创建一池 1 线程 Executors.newSingleThreadExecutor();
源码
public static ExecutorService newSingleThreadExecutor() { return new FinalizableDelegatedExecutorService (new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>())); }-
创建一池 可扩容 线程 Executors.newCachedThreadPool();
源码
public static ExecutorService newCachedThreadPool() { return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>()); }- 自定义线程池
public class ThreadPoolExecutorTool { private static ExecutorService threadPool = new ThreadPoolExecutor( 2, //corePoolSize 核心线程数 5, //maximunPoolSize 线程池最大线程数 2L, //keepAliveTime 空闲线程的存活时间 TimeUnit.SECONDS, //keepAliveTime的时间单位 new ArrayBlockingQueue<>(3), //阻塞队列的值 Executors.defaultThreadFactory(), //线程创建的工厂 new ThreadPoolExecutor.AbortPolicy()//线程池的拒绝策略 ); public static void main(String[] args) { threadPool.execute(()->{ System.out.println("自定义线程池"); }); } } -
线程池
public class ThreadPoolExecutorTool {
private static ExecutorService threadPool = new ThreadPoolExecutor(
2, //corePoolSize 核心线程数
5, //maximunPoolSize 线程池最大线程数
2L, //keepAliveTime 空闲线程的存活时间
TimeUnit.SECONDS, //keepAliveTime的时间单位
new ArrayBlockingQueue<>(3), //阻塞队列的值
Executors.defaultThreadFactory(), //线程创建的工厂
new ThreadPoolExecutor.AbortPolicy()//线程池的拒绝策略
);
}
线程池的七个核心参数
-
corePoolSize : 线程池中会维护一个最小的线程数量，即使这些线程处理空闲状态，他们也不会被销毁，除非设置了allowCoreThreadTimeOut。这里的最小线程数量即是corePoolSize。任务提交到线程池后，首先会检查当前线程数是否达到了corePoolSize，如果没有达到的话，则会创建一个新线程来处理这个任务。
-
maximunPoolSize : 当前线程数达到corePoolSize后，**如果继续有任务被提交到线程池，会将任务缓存到工作队列（后面会介绍）中。如果队列也已满，则会去创建一个新线程来出来这个处理。**线程池不会无限制的去创建新线程，它会有一个最大线程数量的限制，这个数量即由maximunPoolSize指定。
-
keepAliveTime : 一个线程如果处于空闲状态，并且当前的线程数量大于corePoolSize，那么在指定时间后，这个空闲线程会被销毁，这里的指定时间由keepAliveTime来设定。
-
unit : 空闲线程存活时间单位
-
workQueue : 新任务被提交后，会先进入到此工作队列中，任务调度时再从队列中取出任务
JDK中提供了四种工作队列：
①ArrayBlockingQueue
基于数组的有界阻塞队列，按FIFO排序。新任务进来后，会放到该队列的队尾，有界的数组可以防止资源耗尽问题。当线程池中线程数量达到corePoolSize后，再有新任务进来，则会将任务放入该队列的队尾，等待被调度。如果队列已经是满的，则创建一个新线程，如果线程数量已经达到maxPoolSize，则会执行拒绝策略。
②LinkedBlockingQuene
基于链表的无界阻塞队列（其实最大容量为Interger.MAX），按照FIFO排序。由于该队列的近似无界性，当线程池中线程数量达到corePoolSize后，再有新任务进来，会一直存入该队列，而基本不会去创建新线程直到maxPoolSize（很难达到Interger.MAX这个数），因此使用该工作队列时，参数maxPoolSize其实是不起作用的。
③SynchronousQuene
一个不缓存任务的阻塞队列，生产者放入一个任务必须等到消费者取出这个任务。也就是说新任务进来时，不会缓存，而是直接被调度执行该任务，如果没有可用线程，则创建新线程，如果线程数量达到maxPoolSize，则执行拒绝策略。
④PriorityBlockingQueue
具有优先级的无界阻塞队列，优先级通过参数Comparator实现。
-
threadFactory : 创建一个新线程时使用的工厂，可以用来设定线程名、是否为daemon线程等等
-
handler : 拒绝策略
①CallerRunsPolicy
该策略下，在调用者线程中直接执行被拒绝任务的run方法，除非线程池已经shutdown，则直接抛弃任务。
②AbortPolicy
该策略下，直接丢弃任务，并抛出RejectedExecutionException异常。
③DiscardPolicy
该策略下，直接丢弃任务，什么都不做。
④DiscardOldestPolicy
该策略下，抛弃进入队列最早的那个任务，然后尝试把这次拒绝的任务放入队列
使用线程池的好处
- 降低资源消耗：线程池可以重复利用线程，避免线程的频繁创建和销毁。创建和销毁线程需要消耗系统资源（如内存），而线程池可以减少这种开销，从而降低了系统的资源消耗，提高了系统的性能和效率。
- 提高响应速度：线程池可以并发执行多个任务，对任务进行排队和调度。当有任务到来时，线程池中的线程可以立即启动执行，而不需要等待新线程的创建和启动过程。这样可以减少任务的等待时间，提高系统的响应速度。
- 控制最大并发数：通过线程池的大小参数，可以控制系统中允许的最大并发线程数量。如果任务数量超过线程池的容量，多余的任务会被放入任务队列中等待执行，从而避免了系统过载，保护了系统的稳定性。
448
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
