java并发编程之线程池的使用

最新推荐文章于 2024-07-09 22:12:05 发布

luwfls

最新推荐文章于 2024-07-09 22:12:05 发布

阅读量782

点赞数

文章标签： java 并发线程池

本文链接：https://blog.csdn.net/luwfls/article/details/70412704

版权

线程池的解耦和性

线程池的执行策略（与使用什么样的线程池的实现有关）
- 是否有返回值
- 工作线程的数量
- 是否设置超时时间
- 是否定时或者有计划的执行
线程池将任务的提交和任务的执行策略解耦和
但是对于某些种类的线程，线程池自带的执行策略是不能满足任务需求的
- 任务之间相互存在依赖关系，可能因为等待为某个线程死锁。
- 对响应时间敏感的任务
- 使用ThreadLocal的任务，使用线程池的场景下，不应该使用 ThreadLocal在线程之间相互传递值。

线程饥饿死锁

除非线程池足够大，否则在线程池满负载的情况下，正在执行的线程等待任务队列的中任务，将造成饥饿死锁。如下例：

package net.jcip.examples;

import java.util.concurrent.*;

/**
 * ThreadDeadlock
 * <p/>
 * Task that deadlocks in a single-threaded Executor
 *
 * @author Brian Goetz and Tim Peierls
 */
public class ThreadDeadlock {
    ExecutorService exec = Executors.newSingleThreadExecutor();

    public class LoadFileTask implements Callable<String> {
        private final String fileName;

        public LoadFileTask(String fileName) {
            this.fileName = fileName;
        }

        public String call() throws Exception {
            // Here's where we would actually read the file
            return "";
        }
    }

    public class RenderPageTask implements Callable<String> {
        public String call() throws Exception {
            Future<String> header, footer;
            header = exec.submit(new LoadFileTask("header.html"));
            footer = exec.submit(new LoadFileTask("footer.html"));
            String page = renderBody();
            // Will deadlock -- task waiting for result of subtask
            return header.get() + page + footer.get();
        }

        private String renderBody() {
            // Here's where we would actually render the page
            return "";
        }
    }
}

耗时长的任务

指定可以接受的等待时间，并在超时之后，将其放在任务队列合适位置进行重试，这样尽量避免，那些耗时短的任务被阻塞。
Thread.join();
BlockingQueue.put()
CountDownLatch.await()
Selector.select()

设置线程池大小

线程池的大小取决于任务的特性和机器的性能
对于密集计算型的任务，即不需要等待某种资源例如IO，数据库连接等阻塞资源的任务，理想状态下，线程池大小应该为 CPU数量+1。
线程池大小也取决于资源池的大小。

配置ThreadPoolExecutor

自定义线程池

对于Executors的工厂方法创建的线程池不满足业务需求的时候，可以自定义线程池。

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, 
    TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler)

线程的创建与销毁

线程数量与任务队列的动态调整详细请参见线程池的简单认识

管理任务队列

对于线程池来不及处理的任务，将会被存储到线程池内部的一个Queue<Runnable>中。
基本的任务排队方法
- 无界队列
- 有界队列
- 同步移交队列（Synchronous Handoff）参见BlockingQueue# SynchronousQueue，newCachedThreadPool动态线程池采用的该队列。
- 优先级队列PriorityQueue
  - 内部存储的任务实现Comparable接口。
SynchronousQueue并不是一个真正的队列，它不存储任务，它的工作过程为，每当有一个任务提交到线程池的时候，必须已经有一个线程来接受这个任务，他只是负责将该任务从生产者手中直接交付给消费者，这意味着活跃的线程必须足够多，即线程池必须足够大。如果没有可用的线程，且当前线程池中线程的数量小于最大值，则新建一个线程，如果当前数量超过最大值，则执行任务拒绝策略。

newFixedThreadPool和newSingleThreadExecutor 采用的是无界任务队列LinkedBlockingQueue，任务队列将无限制增长，会拖垮系统。
有界任务队列需要与线程池的饱和策略共同使用，以保证任务队列满了之后，对新任务的处理。

饱和策略拒绝策略

RejectedExecutionHandler 线程池工作队列饱和策略
- AbortPolicy 默认的策略，触发时，会抛出未检查的RejectedExecutionException。
- DiscardPolicy 偷偷的抛弃新提交的任务，不抛出异常。
- DiscardOldest 抛弃任务队列中最旧的任务
- Caller-Runs 将任务会退到调用者。
使用信号量来控制任务的提交速率

package net.jcip.examples;

import java.util.concurrent.*;

import net.jcip.annotations.*;

/**
 * BoundedExecutor
 * <p/>
 * Using a Semaphore to throttle task submission
 *
 * @author Brian Goetz and Tim Peierls
 */
@ThreadSafe
public class BoundedExecutor {
    private final Executor exec;
    private final Semaphore semaphore;

    public BoundedExecutor(Executor exec, int bound) {
        this.exec = exec;
        this.semaphore = new Semaphore(bound);
    }

    public void submitTask(final Runnable command)
            throws InterruptedException {
        semaphore.acquire();
        try {
            exec.execute(new Runnable() {
                public void run() {
                    try {
                        command.run();
                    } finally {
                        semaphore.release();
                    }
                }
            });
        } catch (RejectedExecutionException e) {
            semaphore.release();
        }
    }
}

线程工厂

为每一个线程增加用户特性、增加日志功能。
自定义线程工厂

package net.jcip.examples;

import java.util.concurrent.*;

/**
 * MyThreadFactory
 * <p/>
 * Custom thread factory
 *
 * @author Brian Goetz and Tim Peierls
 */
public class MyThreadFactory implements ThreadFactory {
    private final String poolName;

    public MyThreadFactory(String poolName) {
        this.poolName = poolName;
    }

    public Thread newThread(Runnable runnable) {
        return new MyAppThread(runnable, poolName);
    }
}

自定义线程基类

package net.jcip.examples;

import java.util.concurrent.atomic.*;
import java.util.logging.*;

/**
 * MyAppThread
 * <p/>
 * Custom thread base class
 *
 * @author Brian Goetz and Tim Peierls
 */
public class MyAppThread extends Thread {
    public static final String DEFAULT_NAME = "MyAppThread";
    private static volatile boolean debugLifecycle = false;
    private static final AtomicInteger created = new AtomicInteger();
    private static final AtomicInteger alive = new AtomicInteger();
    private static final Logger log = Logger.getAnonymousLogger();

    public MyAppThread(Runnable r) {
        this(r, DEFAULT_NAME);
    }

    public MyAppThread(Runnable runnable, String name) {
        super(runnable, name + "-" + created.incrementAndGet());
        setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
            public void uncaughtException(Thread t,
                                          Throwable e) {
                log.log(Level.SEVERE,
                        "UNCAUGHT in thread " + t.getName(), e);
            }
        });
    }

    public void run() {
        // Copy debug flag to ensure consistent value throughout.
        boolean debug = debugLifecycle;
        if (debug) log.log(Level.FINE, "Created " + getName());
        try {
            alive.incrementAndGet();
            super.run();
        } finally {
            alive.decrementAndGet();
            if (debug) log.log(Level.FINE, "Exiting " + getName());
        }
    }

    public static int getThreadsCreated() {
        return created.get();
    }

    public static int getThreadsAlive() {
        return alive.get();
    }

    public static boolean getDebug() {
        return debugLifecycle;
    }

    public static void setDebug(boolean b) {
        debugLifecycle = b;
    }
}

修改已经创建的线程池

除newSingleThreadExecutor以外的工厂方法创建的线程池，将其强制转换为ThreadPoolExecutor，通过线程池的Setter函数可以修改线程池的属性。
- 基本大小
- 对打大小
- 线程存活时间
- 线程工厂
- 拒绝策略
进制修改的线程池
- Executors中包含一个unconfigurableExecutorService工厂方法，将现有的线程池包装为ExecutorService，从而隐藏其Setter方法。

扩展ThreadPoolExecutor

继承ThreadPoolExecutor
重写 beforeExecute
重写afterExecute
重写 terminated

package net.jcip.examples;

import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
import java.util.logging.*;

/**
 * TimingThreadPool
 * <p/>
 * Thread pool extended with logging and timing
 *
 * @author Brian Goetz and Tim Peierls
 */
public class TimingThreadPool extends ThreadPoolExecutor {

    public TimingThreadPool() {
        super(1, 1, 0L, TimeUnit.SECONDS, null);
    }

    private final ThreadLocal<Long> startTime = new ThreadLocal<Long>();
    private final Logger log = Logger.getLogger("TimingThreadPool");
    private final AtomicLong numTasks = new AtomicLong();
    private final AtomicLong totalTime = new AtomicLong();

    protected void beforeExecute(Thread t, Runnable r) {
        super.beforeExecute(t, r);
        log.fine(String.format("Thread %s: start %s", t, r));
        startTime.set(System.nanoTime());
    }

    protected void afterExecute(Runnable r, Throwable t) {
        try {
            long endTime = System.nanoTime();
            long taskTime = endTime - startTime.get();
            numTasks.incrementAndGet();
            totalTime.addAndGet(taskTime);
            log.fine(String.format("Thread %s: end %s, time=%dns",
                    t, r, taskTime));
        } finally {
            super.afterExecute(r, t);
        }
    }

    protected void terminated() {
        try {
            log.info(String.format("Terminated: avg time=%dns",
                    totalTime.get() / numTasks.get()));
        } finally {
            super.terminated();
        }
    }
}

递归算法的并行化

如果每一层的递归并不依赖与下一层的递归结果，则可以将串行的递归转化成并行的递归。
即并不是一层一层的执行，而是将每一层的递归同时并行的执行。
- 例如网络爬虫，需要先将需要爬取的网页地址组织成树状的结构，然后遍历这棵存有所有任务的树，为每一个节点开启一个任务去爬取页面内容。
应用
- 搬箱子问题
- HiQ问题
- 四色方柱问题

luwfls

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java并发编程之线程池的使用

线程池的解耦和性线程池的执行策略（与使用什么样的线程池的实现有关）是否有返回值工作线程的数量是否设置超时时间是否定时或者有计划的执行线程池将任务的提交和任务的执行策略解耦和但是对于某些种类的线程，线程池自带的执行策略是不能满足任务需求的任务之间相互存在依赖关系，可能因为等待为某个线程死锁。对响应时间敏感的任务使用ThreadLocal的任务，使用线程池的场景下，不应该使用 T
复制链接

扫一扫