关于java多线程及线程池的一些简单用法

于 2018-08-30 09:58:30 发布
阅读量228 收藏
点赞数
分类专栏： java

该篇文章目录

　　1.使用线程池原因

　　2.Thread

　　3.线程池

　　4.线程池工厂提供的四种线程池

　　5.总结

 

 

 

 

一.使用线程池原因

参考：http://blog.youkuaiyun.com/mine_song/article/details/70948223

 

参考的文章

刚开始学习异步任务，当然是用Thread+handler进行异步任务，但是有时bug多和难以维护，我们引入线程池。

 

二.Thread

  • Thread的使用
new Thread(new Runnable(){
    @override
     public void run(){
      
     }
}).start();

 

new Thread(Runnable runnable).start();
new Thread(FutureTask<V>{Callable callable}).start(); 

　　　处理时间=T1（线程创建时间）+T2（线程处理任务时间）+T3（线程销毁时间）

  • new Thread的弊端
    • 每次new Thread新建对象性能差。
    • 线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom。
    • 缺乏更多功能，如定时执行、定期执行、线程中断。

三.线程池

　　1.狭义上的线程池

　　　　线程池是一种多线程处理的方式，处理过程中将任务加入到任务队列，然后创建线程进行执行，线程池中所有线程都是后台线程，并且默认是优先级下运。

　　　　如果当前是线程空闲状态，一有任务添加则让空闲线程执行。

　　　　如果当前所有线程都处于繁忙状态，则让任务挂起，直到直到线程池数量不再是最大值。

　　2.广义上的线程池

　　　　多线程技术主要解决处理器单元内多个线程执行的问题。可以明显减少处理器单元闲置的时间，增加处理器单元的吞吐量。

　　3.线程池的优势

    • 通过对线程进行缓存，减少对象创建、销毁的时间，性能佳。
    • 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。
    • 提供定时执行、定期执行、单线程、并发数控制等功能。

　　4.重要的几个类：

　　Java里面线程池的顶级接口是Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是ExecutorService。

ExecutorService

真正的线程池接口。

ScheduledExecutorService

能和Timer/TimerTask类似，解决那些需要任务重复执行的问题。

ThreadPoolExecutor

ExecutorService的默认实现。

ScheduledThreadPoolExecutor

继承ThreadPoolExecutor的ScheduledExecutorService接口实现，周期性任务调度的类实现。

 

　　5.使用

　　　　1.执行：

　　　　Future future = executor.submit(Runnable runnable);

　　　　Future future = executor.submit(Callable callable);,返回的future有意义

　　　　Future future = executor.execute(Runnable runnable);返回的future没有意义

　　　　2.销毁：

　　　　executor.shutdown();

    • 　　shutdown() 

      • 　　will just tell the executor service that it can't accept new tasks, but the already submitted tasks continue to run

    • 　　shutdownNow() 

      • 　　will do the same AND will try to cancel the already submitted tasks by interrupting the relevant threads. Note that if your tasks ignore the interruption, shutdownNow will behave exactly the same way as shutdown.

 

　　5.自定义线程池参数：

复制代码

/**
     * Creates a new {@code ThreadPoolExecutor} with the given initial
     * parameters and default thread factory and rejected execution handler.
     * It may be more convenient to use one of the {@link Executors} factory
     * methods instead of this general purpose constructor.
     *
     * @param corePoolSize the number of threads to keep in the pool, even
     *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
     * @param maximumPoolSize the maximum number of threads to allow in the
     *        pool
     * @param keepAliveTime when the number of threads is greater than
     *        the core, this is the maximum time that excess idle threads
     *        will wait for new tasks before terminating.
     * @param unit the time unit for the {@code keepAliveTime} argument
     * @param workQueue the queue to use for holding tasks before they are
     *        executed.  This queue will hold only the {@code Runnable}
     *        tasks submitted by the {@code execute} method.
     * @throws IllegalArgumentException if one of the following holds:<br>
     *         {@code corePoolSize < 0}<br>
     *         {@code keepAliveTime < 0}<br>
     *         {@code maximumPoolSize <= 0}<br>
     *         {@code maximumPoolSize < corePoolSize}
     * @throws NullPointerException if {@code workQueue} is null
     */
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }

复制代码

　　　　参数说明如下：

    • int corePoolSize: 最小并发线程数，这里并发同时包括空闲与活动的线程，如果是0的话，空闲一段时间后所有线程将全部被销毁。
    • int maximumPoolSize: 最大线程数，当任务进来时可以扩充的线程最大值，当大于了这个值就会根据丢弃处理机制来处理
    • long keepAliveTime: 当线程数大于corePoolSize时，多余的空闲线程的最大存活时间，类似于HTTP中的Keep-alive
    • TimeUnit unit: 时间单位，一般用秒
    • BlockingQueue<Runnable> workQueue: 工作队列，先进先出，可以看出并不像Picasso那样设置优先队列。详细链接：阻塞队列详解
    • ThreadFactory threadFactory: 单个线程的工厂，可以打Log，设置Daemon(即当JVM退出时，线程自动结束)等

四.线程池工厂提供的四种线程池

1.定义

  • newCachedThreadPool

　　　　创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

  • newFixedThreadPool

　　　　 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

  • newScheduledThreadPool

　　　　创建一个定长线程池，支持定时及周期性任务执行。

  • newSingleThreadExecutor

　　　　创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

 

2.四种线程池构造函数

　　四种线程池的构造器就是在ThreadPoolExecutor的基础上进行封装的。

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }
public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

 

复制代码

/**
     * Creates a new {@code ScheduledThreadPoolExecutor} with the
     * given core pool size.
     *
     * @param corePoolSize the number of threads to keep in the pool, even
     *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
     * @throws IllegalArgumentException if {@code corePoolSize < 0}
     */
    public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE,
              DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
              new DelayedWorkQueue());
    }

复制代码

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

 

3.四种线程池的使用

　　1.newCachedThreadPool

　　　　创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

　　　　线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。

复制代码

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
final int index = i;
try {
Thread.sleep(index * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
 
cachedThreadPool.execute(new Runnable() {
 
@Override
public void run() {
System.out.println(index);
}
});
}

复制代码

　　2.newFixedThreadPool

　　　　创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

复制代码

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
final int index = i;
fixedThreadPool.execute(new Runnable() {
 
@Override
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}

复制代码

　　因为线程池大小为3，每个任务输出index后sleep 2秒，所以每两秒打印3个数字。

　　定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()。可参考PreloadDataCache。

 

　　3.newScheduledThreadPool

　　　　创建一个定长线程池，支持定时及周期性任务执行

复制代码

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
scheduledThreadPool.schedule(new Runnable() {
 
@Override
public void run() {
System.out.println("delay 3 seconds");
}
}, 3, TimeUnit.SECONDS);

复制代码

　　表示延迟3秒执行。

复制代码

scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
 
@Override
public void run() {
System.out.println("delay 1 seconds, and excute every 3 seconds");
}
}, 1, 3, TimeUnit.SECONDS);

复制代码

　　表示延迟1秒后每3秒执行一次。

 

　　4.newSingleThreadExecutor

　　　　创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

复制代码

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
final int index = i;
singleThreadExecutor.execute(new Runnable() {
 
@Override
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}

复制代码

　　结果依次输出，相当于顺序执行各个任务

 

五.总结

现行大多数GUI程序都是单线程的。Android中单线程可用于数据库操作，文件操作，应用批量安装，应用批量删除等不适合并发但可能IO阻塞性及影响UI线程响应的操作。

 不过最近有专门的Rxjava框架应对Thread+Handler的多线程管理问题。

转载于：https://www.cnblogs.com/could-deng/p/6734552.html

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值