kjfcpua

基于生产-消费者模式的任务异步线程池设计与实现

昨天上来看看，看到有个童鞋发了篇关于线程池的实现的帖子，也引来了不少讨论。呵呵，初步看了下，那个线程池的设计与实现还是比较初级，并且存在的问题还是蛮多的。刚好，前两者，为一个项目设计实现了一个基于生产-消费者模式的任务异步处理组件，中间用到了线程池，发上来，供一些童鞋学习参考下。

有些童鞋可能会说，在JDK1.5后就带了ExecutorService这样的线程池，干嘛还自己实现啊？这里，我就先简单说一下背景情况和设计的思路先。

1. JDK的ExecutorService中的线程池只是提供了一些基础的实现，进入线程池的任务一般有两种行为：阻塞或者激活新的线程，前者是对于 fixedThreadPool而言，而后者是对于cachedTreadPool。而项目需要的是一个具有伸缩性的。这里包括两个方面，一个是伸缩性的工作线程池（可以根据情况对线程池进行自我调节），二是伸缩性的任务队列（具有固定的大小，多余的任务会被暂时转储，而队列空闲至一个阈值时，从恢复转储的任务）。Commons-pool其实实现了第一个需求，但是它在设计上是存在一些问题，并不太适合用于线程池的管理（改篇可以再行讨论）。

2. 对于任务队列好，对于工作线程好，一个具有良好设计组件的前提是还有这么几个需求的：它自身是可以被Audit，也就是它的性能，实际工作质量是可以被检查和评估的；它的行为是可以被扩展的；它必须是健壮的并且可控的。所以，除了生产-消费者的线程池外，还必须有一些管理线程，它们必须能够良好地反馈和控制线程池；其次对于整个组件的活动必须定义一套事件以及事件监听机制，其目标一是能做到组件状态的自省，二是能提供客户端的扩展（比如实现动态任务链等）。

好了，谈了背景，先简单减少一下组件中几个主要角色的构成吧（因为整个组件约有60个类，所以不可能全部说明和贴出来）：

1. WorkEngine: 除了继承Switchable这一一个控制开关外，它包括三个主要组成部分和三个扩展部分。

三个组成部分也就是组件的核心：任务队列、工作线程代理、任务结果处理队列。

三个扩展部分分别是：配置、持久化接口以及控制钩子接口。

Java代码

public interface Switchable {
void cancelWork() ;
String getId() ;
boolean isStartForWork() ;
void startWork() ;
void stopWork() ;
}
public interface WorkEngine extends Switchable {
void addControlHook(Switchable hook) ;
WorkConfiguration getConfiguration() ;
Persistence getPersistence() ;
TaskReportQueue getReportQueue() ;
TaskQueue getTaskQueue() ;
WorkerBroker getWorkerBroker() ;
}

public interface Switchable {

    void cancelWork() ;

    String getId() ;

    boolean isStartForWork() ;

    void startWork() ;

    void stopWork() ;
}

public interface WorkEngine extends Switchable {

    void addControlHook(Switchable hook) ;

    WorkConfiguration getConfiguration() ;

    Persistence getPersistence() ;

    TaskReportQueue getReportQueue() ;

    TaskQueue getTaskQueue() ;

    WorkerBroker getWorkerBroker() ;

}

2. 下面对三个主要的部件接口简单说明下：

首先是任务队列TaskQueue,相对于传统的队列，增加了事件监听器和任务优先级重处理。

Java代码

public interface TaskQueue extends Iterable {
void addEventListener(TaskEventListener listener) ;
/**
* add a new task to tail of queue
* @param task
*/
void addTask(Task task) ;
/**
* check whether existing task in queue.
* @return
*/
boolean existTask() ;
/**
* sort tasks in queue according to priority
*/
void sequence() ;
/**
* remove the task at the head of queue
*/
Task removeTask() ;
/**
* remove the indicated task in queue
* @param task
*/
void removeTask(Task task) ;
int size() ;
int capacity() ;
}

public interface TaskQueue extends Iterable {

    void addEventListener(TaskEventListener listener) ;

    /**
     * add a new task to tail of queue
     * @param task
     */
    void addTask(Task task) ;

    /**
     * check whether existing task in queue.
     * @return
     */
    boolean existTask() ;

    /**
     * sort tasks in queue according to priority
     */
    void sequence() ;

    /**
     * remove the task at the head of queue
     */
    Task removeTask() ;

    /**
     * remove the indicated task in queue
     * @param task
     */
    void removeTask(Task task) ;

    int size() ;

    int capacity() ;

}

其次是工作线程代理（有个不错的名字：包工头）以及工作线程接口（也就是工人）：

Java代码

public interface WorkerBroker {
void fireWorker();
void fireWorker(Worker worker);
int getIdleWorkers();
int getWorkingWorkers();
int getMaxWorkers();
boolean hireWorker(Worker worker);
Worker require(boolean overdue);
boolean returnBack(Worker worker);
void setWorkerFactory(WorkerFactory factory) ;
void addEventListener(WorkerEventListener listener) ;
}
public interface Worker extends Switchable {
boolean isAvailable();
boolean isStartForWork() ;
void setTaskEventNotifier(TaskEventNotifier notifier);
void setWorkerEventNotifier(WorkerEventNotifier notifier);
void work(Task task);
int getNumOfExecutedTasks() ;
}

public interface WorkerBroker {

    void fireWorker();

    void fireWorker(Worker worker);

    int getIdleWorkers();

    int getWorkingWorkers();

    int getMaxWorkers();

    boolean hireWorker(Worker worker);

    Worker require(boolean overdue);

    boolean returnBack(Worker worker);

    void setWorkerFactory(WorkerFactory factory) ;

    void addEventListener(WorkerEventListener listener) ;
}

public interface Worker extends Switchable {

    boolean isAvailable();

    boolean isStartForWork() ;

    void setTaskEventNotifier(TaskEventNotifier notifier);

    void setWorkerEventNotifier(WorkerEventNotifier notifier);

    void work(Task task);

    int getNumOfExecutedTasks() ;
}

最后是任务报告队列，用于处理每个异步任务执行结果的报告

Java代码

public interface TaskReportQueue extends Iterable {
void submitReport(TaskExecutionReport report) ;
int capacity();
int size() ;
}

public interface TaskReportQueue extends Iterable {

    void submitReport(TaskExecutionReport report) ;

    int capacity();

    int size() ;
}

3. 最后贴出组件配置的接口，这样大家也清晰有哪些是可配置的

Java代码

public interface WorkConfiguration {
/**
* when the size of task queue is less than a specific threshold
* engine will activate task from persistence.
* the default threshold is getTaskQueueCapacity * 0.8.
* if return value is 0, will consider to use default setting.
* @return
*/
int getActivateThreshold() ;
/**
*
* @return map key is group name, value is collection of task category
*/
Map> getTaskGroupInformation() ;
Mapextends TaskContextConverter>>> getDefinedConverters() ;
/**
* the intial size of worker queue
* @return
*/
int getInitNumberofWorkers();
/**
* get the interval to check whether existing persistented tasks.
* the unit is second.
* The default value is 300.
* @return
*/
int getIntervalToCheckPersistence() ;
/**
* the waitting time to require a worker from broker.
* @return
*/
int getLatencyTimeForWorker();
/**
* get apache common logging instance.
* @return
*/
Log getLog();
/**
* the size of worker queue
* @return
*/
int getMaxNumberofWorkers();
/**
* when found a exception (not user thrown), max retry times.
* @return
*/
int getMaxRetryTimesWhenError() ;
/**
* the number of result processor thread
* @return
*/
int getNumberofResultProcessors();
/**
* 0 is unlimited, 1 is single thread, positive is a fixed thread pool, negative is illegal
* @return
*/
int getNumberofServiceThreads() ;
Classextends Persistence> getPersistenceClass();
/**
* the task will promote the priority after a specific time elapsed.
* the time unit is second.
* @return specific time
*/
int getPriorityAdjustmentThreshold() ;
/**
* the size of task result queue
* @return
*/
int getResultQueueCapacity();
Listextends TaskEventListener>> getTaskEventListeners();
Map>> getTaskCategoryInformation();
/**
* the overdue setting of executing a task
* the time unit is second
* @return
*/
int getTaskOverdue();
/**
* the size of task queue
* @return
*/
int getTaskQueueCapacity();
Listextends WorkerEventListener>> getWorkerEventListeners();
/**
* whether the system can automatically support the time based priority adjustment of task .
* @return
*/
boolean supportPriorityAdjustment() ;
/**
* when worker queue is emtpy, whether to use backup worker.
* @return
*/
boolean useBackupWorker();
}

public interface WorkConfiguration {

    /**
     * when the size of task queue is less than a specific threshold
     * engine will activate task from persistence.
     * the default threshold is getTaskQueueCapacity * 0.8.
     * if return value is 0, will consider to use default setting.
     * @return
     */
    int getActivateThreshold() ;

    /**
     *
     * @return map key is group name, value is collection of task category
     */
    Map> getTaskGroupInformation() ;

    Map>> getDefinedConverters() ;

    /**
     * the intial size of worker queue
     * @return
     */
    int getInitNumberofWorkers();

    /**
     * get the interval to check whether existing persistented tasks.
     * the unit is second.
     * The default value is 300.
     * @return
     */
    int getIntervalToCheckPersistence() ;

    /**
     * the waitting time to require a worker from broker.
     * @return
     */
    int getLatencyTimeForWorker();

    /**
     * get apache common logging instance.
     * @return
     */
    Log getLog();

    /**
     * the size of worker queue
     * @return
     */
    int getMaxNumberofWorkers();

    /**
     * when found a exception (not user thrown), max retry times.
     * @return
     */
    int getMaxRetryTimesWhenError() ;

    /**
     * the number of result processor thread
     * @return
     */
    int getNumberofResultProcessors();

    /**
     * 0 is unlimited, 1 is single thread, positive is a fixed thread pool, negative is illegal
     * @return
     */
    int getNumberofServiceThreads() ;

    Class getPersistenceClass();

    /**
     * the task will promote the priority after a specific time elapsed.
     * the time unit is second.
     * @return specific time
     */
    int getPriorityAdjustmentThreshold() ;

    /**
     * the size of task result queue
     * @return
     */
    int getResultQueueCapacity();

    List> getTaskEventListeners();

    Map>> getTaskCategoryInformation();
    /**
     * the overdue setting of executing a task
     * the time unit is second
     * @return
     */
    int getTaskOverdue();

    /**
     * the size of task queue
     * @return
     */
    int getTaskQueueCapacity();


    List> getWorkerEventListeners();

    /**
     * whether the system can automatically support the time based priority adjustment of task .
     * @return
     */
    boolean supportPriorityAdjustment() ;

    /**
     * when worker queue is emtpy, whether to use backup worker.
     * @return
     */
    boolean useBackupWorker();

}

好了，列出上面几个重要的接口，下面也就是大家最关心的实现了。在实现是基于JDK1.5，所以用到了Queue, Atomic等。

首先是TaskQueueImpl

Java代码

public final class TaskQueueImpl extends ControlSwitcher implements TaskQueue, TaskEventNotifier, WorkerBrokerAware {
/*
* *
* @uml.property name="broker"
* @uml.associationEnd
*/
private WorkerBroker broker;
private int capacity ;
/*
* *
* @uml.property name="chain"
* @uml.associationEnd
*/
private TaskEventListenerChain chain = new TaskEventListenerChain();
private Log logger ;
private BlockingQueue queue;
private int threshold ;
private long lastCheckTime ;
private long intervalToCheck ;
private AtomicBoolean existPersistentTask = new AtomicBoolean( false );
public TaskQueueImpl() {
super ();
}
void activateTasks( int size) {
if (!existPersistentTask.get()) {
if (lastCheckTime <= 0L || System.currentTimeMillis() - lastCheckTime <= intervalToCheck) {
return ;
}
}
logger.info("the queue is available, expect to activate [" +size+ "] tasks." );
lastCheckTime = System.currentTimeMillis() ;
Collection tasks = getEngine().getPersistence().activate(size);
logger.info("actual activated " +tasks.size()+ " tasks." );
for (Task task : tasks) {
putInQueue(task);
}
if (tasks.size() < size) {
existPersistentTask.set(false );
}
}
public void addEventListener(TaskEventListener listener) {
chain.addListener(listener);
}
public void addTask(Task task) {
if (queue.size() > capacity) {
passivateTask(task);
return ;
}
putInQueue(task);
}
private void cancelTask(Task task) {
task.setState(TaskState.OUT_OF_QUEUE);
chain.onEvent(task, TaskEvent.CANCEL);
}
public boolean existTask() {
return queue.size() > 0 ;
}
@Override
public Runnable getManagementThread( final WorkConfiguration config) {
final TaskEventNotifier notifier = this ;
final WorkerBroker broker = this .broker ;
final Log logger = this .logger ;
final BlockingQueue queue = this .queue ;
final int capacity = this .capacity ;
final int threshold = this .threshold ;
return new Runnable() {
public void run() {
while (isStartForWork()) {
Worker worker = broker.require(true );
if (worker == null ) {
logger.warn("can not require any worker in specific time." );
worker = broker.require(false );
}
if (logger.isDebugEnabled()) {
logger.info("required a worker[id=" +worker.getId()+ "]." );
}
Task task = null ;
try {
if (queue.size() <= threshold) {
activateTasks(capacity - threshold);
}
task = queue.take();
} catch (InterruptedException e) {
logger.warn("The task queue is interrupted, engine is still start for work[" + isStartForWork()
+ "]." );
}
if (task == null ) {
logger.warn("no found any task in queue in specific time, will return back worker." );
broker.returnBack(worker);
continue ;
}
task.setOutQueueTime(DateFormatter.now());
try {
if (!worker.isStartForWork()) {
if (logger.isDebugEnabled()) {
logger.info("start worker[id=" +worker.getId()+ "]" );
}
worker.startWork() ;
}
worker.setTaskEventNotifier(notifier);
worker.work(task);
} catch (Throwable th) {
logger.warn("found exception when the worker[id=" +worker.getId()+ "] start to work." ,th);
broker.returnBack(worker);
}
}
}
};
}
public Iterator iterator() {
Task[] ts =queue.toArray(new Task[queue.size()]);
return Arrays.asList(ts).iterator() ;
}
public void notifyTaskEvent(Task task, TaskEvent event) {
if (event == TaskEvent.FAIL) {
int max = getConfiguration().getMaxRetryTimesWhenError();
int current = task.getRetriedTimes();
if (max > current) {
task.setRetriedTimes(current+1 );
addTask(task);
} else {
logger.warn("the task " + task + " has retried " + current + " times, will be skipped." );
}
}
chain.onEvent(task, event);
}
private void passivateTask(Task task) {
getEngine().getPersistence().passivate(task);
existPersistentTask.set(true ) ;
task.setState(TaskState.OUT_OF_QUEUE);
chain.onEvent(task, TaskEvent.PERSISTENT);
}
public void postInitial() {
capacity = getConfiguration().getTaskQueueCapacity();
threshold = getConfiguration().getActivateThreshold();
if (threshold <= 0 || threshold >= capacity) {
Double dou = Double.valueOf(capacity * 0.8 );
threshold = dou.intValue() ;
}
queue = new PriorityBlockingQueue(capacity,
new PriorityBasedComparator());
chain.setService(getEngine().getExecutorService());
logger = getConfiguration().getLog() ;
intervalToCheck = getConfiguration().getIntervalToCheckPersistence() * 1000 ;
}
void putInQueue(Task task) {
task.setInQueueTime(DateFormatter.now());
if (queue.offer(task)) {
task.setState(TaskState.WAITING);
chain.onEvent(task, TaskEvent.IN_QUEUE);
} else {
logger.warn("fail to put task " + task + " in queue." );
}
}
public Task removeTask() {
Task task = queue.poll();
if (task != null ) {
task.setOutQueueTime(DateFormatter.nowDate());
cancelTask(task);
} else {
if (logger.isDebugEnabled()) {
logger.info("no task in queue." );
}
}
return task ;
}
public void removeTask(Task task) {
if (queue.remove(task)) {
task.setOutQueueTime(DateFormatter.nowDate());
cancelTask(task);
} else {
logger.warn("remove task from queue failed." );
}
}
/*
* *
* @param broker
* @uml.property name="broker"
*/
public void setBroker(WorkerBroker broker) {
this .broker = broker;
}
public int capacity() {
return capacity;
}
public int size() {
return queue.size();
}
}

public final class TaskQueueImpl extends ControlSwitcher implements TaskQueue, TaskEventNotifier, WorkerBrokerAware {
    /*
     * *
     * @uml.property name="broker"
     * @uml.associationEnd
     */
    private WorkerBroker broker;

    private int capacity ;

    /*
     * *
     * @uml.property name="chain"
     * @uml.associationEnd
     */
    private TaskEventListenerChain chain = new TaskEventListenerChain();

    private Log logger ;

    private BlockingQueue queue;

    private int threshold ;

    private long lastCheckTime ;

    private long intervalToCheck ;

    private AtomicBoolean existPersistentTask = new AtomicBoolean(false);

    public TaskQueueImpl() {
        super();
    }

    void activateTasks(int size) {
        if (!existPersistentTask.get()) {
            if (lastCheckTime <= 0L || System.currentTimeMillis() - lastCheckTime <= intervalToCheck) {
                return ;
            }
        }
        logger.info("the queue is available, expect to activate ["+size+"] tasks.");
        lastCheckTime = System.currentTimeMillis() ;
        Collection tasks = getEngine().getPersistence().activate(size);
        logger.info("actual activated "+tasks.size()+" tasks.");
        for (Task task : tasks) {
            putInQueue(task);
        }
        if (tasks.size() < size) {
            existPersistentTask.set(false);
        }
    }

    public void addEventListener(TaskEventListener listener) {
        chain.addListener(listener);
    }


    public void addTask(Task task) {
        if (queue.size() > capacity) {
            passivateTask(task);
            return;
        }
        putInQueue(task);
    }

    private void cancelTask(Task task) {
        task.setState(TaskState.OUT_OF_QUEUE);
        chain.onEvent(task, TaskEvent.CANCEL);
    }

    public boolean existTask() {
        return queue.size() > 0;
    }

    @Override
    public Runnable getManagementThread(final WorkConfiguration config) {
        final TaskEventNotifier notifier = this ;
        final WorkerBroker broker = this.broker ;
        final Log logger = this.logger ;
        final BlockingQueue queue = this.queue ;
        final int capacity = this.capacity ;
        final int threshold = this.threshold ;
        return new Runnable() {
            public void run() {
                while (isStartForWork()) {
                    Worker worker = broker.require(true);
                    if (worker == null) {
                        logger.warn("can not require any worker in specific time.");
                        worker = broker.require(false);
                    }
                    if (logger.isDebugEnabled()) {
                        logger.info("required a worker[id="+worker.getId()+"].");
                    }
                    Task task = null ;
                    try {
                        if (queue.size() <= threshold) {
                            activateTasks(capacity - threshold);
                        }
                        task = queue.take();
                    } catch (InterruptedException e) {
                        logger.warn("The task queue is interrupted, engine is still start for work[" + isStartForWork()
                                        + "].");
                    }
                    if (task == null) {
                        logger.warn("no found any task in queue in specific time, will return back worker.");
                        broker.returnBack(worker);
                        continue ;
                    }

                    task.setOutQueueTime(DateFormatter.now());
                    try {
                        if (!worker.isStartForWork()) {
                            if (logger.isDebugEnabled()) {
                                logger.info("start worker[id="+worker.getId()+"]");
                            }
                            worker.startWork() ;
                        }
                        worker.setTaskEventNotifier(notifier);
                        worker.work(task);
                    } catch (Throwable th) {
                        logger.warn("found exception when the worker[id="+worker.getId()+"] start to work.",th);
                        broker.returnBack(worker);
                    }
                }
            }
        };
    }

    public Iterator iterator() {
        Task[] ts =queue.toArray(new Task[queue.size()]);
        return Arrays.asList(ts).iterator() ;
    }

    public void notifyTaskEvent(Task task, TaskEvent event) {
        if (event == TaskEvent.FAIL) {
            int max = getConfiguration().getMaxRetryTimesWhenError();
            int current = task.getRetriedTimes();
            if (max > current) {
                task.setRetriedTimes(current+1);
                addTask(task);
            } else {
                logger.warn("the task " + task + " has retried " + current + " times, will be skipped.");
            }
        }
        chain.onEvent(task, event);
    }

    private void passivateTask(Task task) {
        getEngine().getPersistence().passivate(task);
        existPersistentTask.set(true) ;
        task.setState(TaskState.OUT_OF_QUEUE);
        chain.onEvent(task, TaskEvent.PERSISTENT);
    }

    public void postInitial() {
        capacity = getConfiguration().getTaskQueueCapacity();
        threshold = getConfiguration().getActivateThreshold();
        if (threshold <= 0 || threshold >= capacity) {
            Double dou = Double.valueOf(capacity * 0.8);
            threshold = dou.intValue() ;
        }

        queue = new PriorityBlockingQueue(capacity,
                                                new PriorityBasedComparator());
        chain.setService(getEngine().getExecutorService());
        logger = getConfiguration().getLog() ;
        intervalToCheck = getConfiguration().getIntervalToCheckPersistence() * 1000 ;
    }

    void putInQueue(Task task) {
        task.setInQueueTime(DateFormatter.now());
        if (queue.offer(task)) {
            task.setState(TaskState.WAITING);
            chain.onEvent(task, TaskEvent.IN_QUEUE);
        } else {
            logger.warn("fail to put task " + task + " in queue.");
        }

    }

    public Task removeTask() {
        Task task = queue.poll();
        if (task != null) {
            task.setOutQueueTime(DateFormatter.nowDate());
            cancelTask(task);
        } else {
            if (logger.isDebugEnabled()) {
                logger.info("no task in queue.");
            }
        }
        return task ;
    }

    public void removeTask(Task task) {
        if (queue.remove(task)) {
            task.setOutQueueTime(DateFormatter.nowDate());
            cancelTask(task);
        } else {
            logger.warn("remove task from queue failed.");
        }
    }

    /*
     * *
     * @param broker
     * @uml.property name="broker"
     */
    public void setBroker(WorkerBroker broker) {
        this.broker = broker;
    }

    public int capacity() {
        return capacity;
    }

    public int size() {
        return queue.size();
    }


}

接下来是AbstractWorker 和WorkerBrokerImpl

Java代码

public abstract class AbstractWorker extends ControlSwitcher implements Worker, WorkerBrokerAware {
private Log logger ;
/*
* *
* @uml.property name="taskEventNotifier"
* @uml.associationEnd
*/
private TaskEventNotifier taskEventNotifier ;
/*
* *
* @uml.property name="workerEventNotifier"
* @uml.associationEnd
*/
private WorkerEventNotifier workerEventNotifier ;
/*
* *
* @uml.property name="broker"
* @uml.associationEnd
*/
private WorkerBroker broker ;
private final AtomicBoolean available = new AtomicBoolean( true ) ;
private final AtomicInteger executedTasks = new AtomicInteger( 0 );
protected void doWork(Task task) {
available.set(false ) ;
task.setExecuteTime(DateFormatter.now());
TaskExecutionReport report = new TaskExecutionReport(task);
TaskProcessDescriptor desc = getEngine().getTaskCategoryInformation(task.getCategory());
long start = System.currentTimeMillis();
try {
if (desc == null ) {
throw new IllegalArgumentException( "the task category[" +task.getCategory()+ "] doesn't register." );
}
TaskEventNotifier ten = getTaskEventNotifier();
TaskValidator validator = desc.getValidator();
if (validator != null ) {
ValidationResult vr = validator.validate(task);
if (!vr.isValid()) {
InvalidTaskResult defaultResult = new InvalidTaskResult(task, vr) ;
report.setResult(defaultResult);
getLogger().warn("the task" + task + " is invalid, caused by " +vr.getMessage());
if (ten != null ) {
ten.notifyTaskEvent(task, TaskEvent.INVALID);
}
getEngine().getReportQueue().submitReport(report);
return ;
}
}
report.setExecuteTime(new Date(start));
TaskResult result = desc.getExecutor().execute(task);
report.setResult(result);
report.setCost(System.currentTimeMillis() - start);
if (ten != null ) {
if (report.getCost() > getConfiguration().getTaskOverdue() * 1000 ) {
ten.notifyTaskEvent(task, TaskEvent.OVERDUE);
} else {
ten.notifyTaskEvent(task, TaskEvent.FINISH);
}
}
getEngine().getReportQueue().submitReport(report);
} catch (Throwable exp) {
handleException(report, exp);
} finally {
executedTasks.addAndGet(1 );
available.set(true );
}
}
private void handleException(TaskExecutionReport report, Throwable exp) {
Task task = report.getTask() ;
TaskEventNotifier ten = getTaskEventNotifier();
UnexpectedTaskResult defaultResult = new UnexpectedTaskResult(task);
defaultResult.setException(exp);
report.setResult(defaultResult);
getLogger().error("found exception when executing task " + task, exp);
if (ten != null ) {
getTaskEventNotifier().notifyTaskEvent(task, TaskEvent.FAIL);
}
}
/*
* *
* @return
* @uml.property name="logger"
*/
public Log getLogger() {
return logger ;
}
/*
* *
* @return
* @uml.property name="taskEventNotifier"
*/
TaskEventNotifier getTaskEventNotifier() {
return taskEventNotifier;
}
/*
* *
* @return
* @uml.property name="workerEventNotifier"
*/
WorkerEventNotifier getWorkerEventNotifier() {
return workerEventNotifier;
}
public void postInitial() {
logger = getConfiguration().getLog() ;
}
/*
* *
* @param notifier
* @uml.property name="taskEventNotifier"
*/
public void setTaskEventNotifier(TaskEventNotifier notifier) {
this .taskEventNotifier = notifier ;
}
/*
* *
* @param notifier
* @uml.property name="workerEventNotifier"
*/
public void setWorkerEventNotifier(WorkerEventNotifier notifier) {
this .workerEventNotifier = notifier ;
}
public boolean isAvailable() {
return available.get();
}
/*
* *
* @return
* @uml.property name="broker"
*/
public WorkerBroker getBroker() {
return broker;
}
/*
* *
* @param broker
* @uml.property name="broker"
*/
public void setBroker(WorkerBroker broker) {
this .broker = broker;
}
public int getNumOfExecutedTasks() {
return executedTasks.get();
}
@Override
public synchronized void startWork() {
super .startWork();
executedTasks.set(0 );
}
}

public abstract class AbstractWorker extends ControlSwitcher implements Worker, WorkerBrokerAware {

    private Log logger ;

    /*
     * *
     * @uml.property name="taskEventNotifier"
     * @uml.associationEnd
     */
    private TaskEventNotifier taskEventNotifier ;

    /*
     * *
     * @uml.property name="workerEventNotifier"
     * @uml.associationEnd
     */
    private WorkerEventNotifier workerEventNotifier ;

    /*
     * *
     * @uml.property name="broker"
     * @uml.associationEnd
     */
    private WorkerBroker broker ;

    private final AtomicBoolean available = new AtomicBoolean(true) ;

    private final AtomicInteger executedTasks = new AtomicInteger(0);

    protected void doWork(Task task) {
        available.set(false) ;
        task.setExecuteTime(DateFormatter.now());
        TaskExecutionReport report = new TaskExecutionReport(task);
        TaskProcessDescriptor desc = getEngine().getTaskCategoryInformation(task.getCategory());
        long start = System.currentTimeMillis();

        try {
            if (desc == null) {
                throw new IllegalArgumentException("the task category["+task.getCategory()+"] doesn't register.");
            }
            TaskEventNotifier ten = getTaskEventNotifier();
            TaskValidator validator = desc.getValidator();
            if (validator != null) {
                ValidationResult vr = validator.validate(task);
                if (!vr.isValid()) {
                    InvalidTaskResult defaultResult = new InvalidTaskResult(task, vr) ;
                    report.setResult(defaultResult);
                    getLogger().warn("the task" + task + " is invalid, caused by "+vr.getMessage());
                    if (ten != null) {
                        ten.notifyTaskEvent(task, TaskEvent.INVALID);
                    }
                    getEngine().getReportQueue().submitReport(report);
                    return ;
                }
            }
            report.setExecuteTime(new Date(start));
            TaskResult result = desc.getExecutor().execute(task);
            report.setResult(result);
            report.setCost(System.currentTimeMillis() - start);

            if (ten != null) {
                if (report.getCost() > getConfiguration().getTaskOverdue() * 1000) {
                    ten.notifyTaskEvent(task, TaskEvent.OVERDUE);
                } else {
                    ten.notifyTaskEvent(task, TaskEvent.FINISH);
                }
            }
            getEngine().getReportQueue().submitReport(report);
        } catch (Throwable exp) {
            handleException(report, exp);
        } finally {
            executedTasks.addAndGet(1);
            available.set(true);
        }
    }


    private void handleException(TaskExecutionReport report, Throwable exp) {
        Task task = report.getTask() ;
        TaskEventNotifier ten = getTaskEventNotifier();
        UnexpectedTaskResult defaultResult = new UnexpectedTaskResult(task);
        defaultResult.setException(exp);
        report.setResult(defaultResult);
        getLogger().error("found exception when executing task " + task, exp);
        if (ten != null) {
            getTaskEventNotifier().notifyTaskEvent(task, TaskEvent.FAIL);
        }
    }

    /*
     * *
     * @return
     * @uml.property name="logger"
     */
    public Log getLogger() {
        return logger ;
    }

    /*
     * *
     * @return
     * @uml.property name="taskEventNotifier"
     */
    TaskEventNotifier getTaskEventNotifier() {
        return taskEventNotifier;
    }

    /*
     * *
     * @return
     * @uml.property name="workerEventNotifier"
     */
    WorkerEventNotifier getWorkerEventNotifier() {
        return workerEventNotifier;
    }

    public void postInitial() {
        logger = getConfiguration().getLog() ;
    }

    /*
     * *
     * @param notifier
     * @uml.property name="taskEventNotifier"
     */
    public void setTaskEventNotifier(TaskEventNotifier notifier) {
        this.taskEventNotifier = notifier ;
    }

    /*
     * *
     * @param notifier
     * @uml.property name="workerEventNotifier"
     */
    public void setWorkerEventNotifier(WorkerEventNotifier notifier) {
        this.workerEventNotifier = notifier ;
    }

    public boolean isAvailable() {
        return available.get();
    }

    /*
     * *
     * @return
     * @uml.property name="broker"
     */
    public WorkerBroker getBroker() {
        return broker;
    }

    /*
     * *
     * @param broker
     * @uml.property name="broker"
     */
    public void setBroker(WorkerBroker broker) {
        this.broker = broker;
    }

    public int getNumOfExecutedTasks() {
        return executedTasks.get();
    }

    @Override
    public synchronized void startWork() {
        super.startWork();
        executedTasks.set(0);
    }

}

Java代码

public class WorkerBrokerImpl extends ControlSwitcher implements WorkerBroker, WorkerEventNotifier {
private AtomicReference agent = new AtomicReference();
/*
* *
* @uml.property name="chain"
* @uml.associationEnd
*/
private WorkerEventListenerChain chain = new WorkerEventListenerChain();
/*
* *
* @uml.property name="factory"
* @uml.associationEnd
*/
private WorkerFactory factory;
private AtomicReference firstAssign = new AtomicReference(0L);
private Log logger ;
private BlockingQueue queue;
private Semaphore sema ;
private BlockingQueue workingQueue ;
public WorkerBrokerImpl() {
super ();
}
public void addEventListener(WorkerEventListener listener) {
chain.addListener(listener);
}
/*
*
* @see com.oocllogistics.comp.workengine.worker.WorkerBroker#fireWorker()
*/
public void fireWorker() {
int balance = queue.size() ;
int using = sema.getQueueLength();
int initWorkers = getConfiguration().getInitNumberofWorkers();
if (balance + using > initWorkers && using < initWorkers) {
int fireSize = balance + using - initWorkers ;
for ( int i = 0 ; i < fireSize; i++) {
Worker worker = queue.poll();
if (worker == null ) {
break ;
}
if (logger.isDebugEnabled()) {
logger.info("fire a worker[id=" +worker.getId()+ "] from queue." );
}
if (worker.isStartForWork()) {
logger.info("stop work of worker[id=" +worker.getId()+ "]." );
worker.stopWork();
}
chain.onEvent(worker, WorkerEvent.FIRE);
}
}
}
public void fireWorker(Worker worker) {
if (worker == null ) {
return ;
}
queue.remove(worker);
removeFromWorkingQueue(worker);
if (logger.isDebugEnabled()) {
logger.info("fire a worker[id=" +worker.getId()+ "] from queue." );
}
if (worker.isStartForWork()) {
logger.info("stop work of worker[id=" +worker.getId()+ "]." );
worker.stopWork();
}
chain.onEvent(worker, WorkerEvent.FIRE);
}
/*
*
* @see com.oocllogistics.comp.workengine.worker.WorkerBroker#getIdleWorkers()
*/
public int getIdleWorkers() {
return queue.size();
}
@Override
public Runnable getManagementThread( final WorkConfiguration config) {
final long max = config.getTaskOverdue() * 1000 ;
final int initial = getConfiguration().getInitNumberofWorkers() ;
final AtomicReference firstAssign = this .firstAssign ;
final BlockingQueue workingQueue = this .workingQueue ;
final Log logger = this .logger ;
final WorkerEventListenerChain chain = this .chain ;
return new Runnable() {
public void run() {
long lastFlag = System.currentTimeMillis() ;
while (isStartForWork()) {
try {
long current = System.currentTimeMillis() ;
if (current - lastFlag > max && getIdleWorkers() > initial) {
fireWorker();
lastFlag = System.currentTimeMillis() ;
}
long startTime = firstAssign.get() ;
while (startTime == 0L) {
Thread.sleep(max);
startTime = firstAssign.get() ;
}
final long interval = current - firstAssign.get();
if (interval >= max) {
WorkerTracker tracker = workingQueue.poll();
if (tracker != null ) {
Worker worker = tracker.getWorker();
logger.warn("the worker[" +worker.getId()+ "] is overdue, remove from working queue." );
removeFromWorkingQueue(worker);
chain.onEvent(worker, WorkerEvent.OVERDUE);
}
}
if (max > interval) {
Thread.sleep(max - interval);
}
} catch (InterruptedException e) {
String msg = "the worker broker is interrupted, " +
"engine is still start for work[" + isStartForWork() + "]." ;
logger.warn(msg);
}
}
}
};
}
/*
*
* @see com.oocllogistics.comp.workengine.worker.WorkerBroker#getMaxWorkers()
*/
public int getMaxWorkers() {
return getConfiguration().getMaxNumberofWorkers() ;
}
/*
* @see
* com.oocllogistics.comp.workengine.worker.WorkerBroker#hireWorker(com.oocllogistics.comp.workengine.worker.Worker)
*/
public boolean hireWorker(Worker worker) {
if (worker == null || !worker.isAvailable() || worker.isStartForWork()) {
return false ;
}
if (worker instanceof StandardWorker) {
logger.info("hire a new worker[id=" +worker.getId()+ "] into queue." );
return returnBack(worker);
}
if (worker instanceof SpecialWorker) {
if (agent.get() == null ) {
agent.set(worker);
logger.info("hire a special worker[id=" +worker.getId()+ "] as backup." );
return true ;
}
}
return false ;
}
public void notifyWorkerEvent(Worker worker, WorkerEvent event) {
boolean isReturned = false ;
switch (event) {
case CANCEL_WORK:
isReturned = returnBack(worker);
break ;
case OVERDUE:
isReturned = returnBack(worker);
break ;
case SUBMIT_TASK:
isReturned = returnBack(worker);
break ;
default :
isReturned = true ;
break ;
}
if (!isReturned) {
logger.warn("return back worker[id=" +worker.getId()+ "] failed." );
}
chain.onEvent(worker, event);
}
/*
*
* @see com.oocllogistics.comp.workengine.impl.ControlSwitcher#postInitial()
*/
public void postInitial() {
int init = getConfiguration().getInitNumberofWorkers();
int total = getConfiguration().getMaxNumberofWorkers();
sema = new Semaphore(total);
queue = new ArrayBlockingQueue(total);
workingQueue = new ArrayBlockingQueue(total);
Collection workerList = factory.createWorkers(init, WorkType.STANDARD_WORKER);
for (Worker worker : workerList) {
worker.setWorkerEventNotifier(this );
queue.add(worker);
}
if (getConfiguration().useBackupWorker()) {
Worker worker = factory.createWorker(WorkType.AGENT_WORKER);
worker.setWorkerEventNotifier(this );
agent.set(worker);
}
logger = getConfiguration().getLog() ;
chain.setService(getEngine().getExecutorService());
}
void removeFromWorkingQueue(Worker worker) {
if (worker == null ) {
return ;
}
synchronized (worker) {
WorkerTracker tracker = new WorkerTracker(worker, 0L);
if (workingQueue.remove(tracker)) {
if (tracker != null ) {
firstAssign.set(tracker.getStartWorkTime());
} else {
firstAssign.set(0L);
}
if (logger.isDebugEnabled()) {
logger.info("remove the worker[id=" +worker.getId()+ "] from working queue." );
}
} else {
logger.warn("failed to remove the worker[id=" +worker.getId()+ "] from working queue." );
}
}
}
/*
*
* @see com.oocllogistics.comp.workengine.worker.WorkerBroker#require(boolean)
*/
public Worker require( boolean overdue) {
Worker worker = null ;
checkWhetherToAddWorker();
try {
if (overdue) {
worker = queue.poll(getConfiguration().getLatencyTimeForWorker(), TimeUnit.SECONDS);
} else {
worker = queue.take();
}
worker = checkWhetherToUseBackupWorker(worker);
sema.acquire() ;
WorkerTracker tracker = new WorkerTracker(worker, System.currentTimeMillis());
if (workingQueue.offer(tracker)) {
firstAssign.compareAndSet(0L, tracker.getStartWorkTime());
if (logger.isDebugEnabled()) {
logger.info("put worker[id=" +worker.getId()+ "] into working queue." );
}
} else {
String msg = "faile to put worker[id=" +worker.getId()+ "] into working queue. " +
"It might cause a worker missing." ;
logger.warn(msg);
chain.onEvent(worker, WorkerEvent.MISSED);
}
return worker ;
} catch (InterruptedException e) {
logger.warn("find interrupted exception when requiring a worker." , e);
return agent.get() ;
}
}
private void checkWhetherToAddWorker() {
synchronized (queue) {
if (queue.size() == 0 && sema.availablePermits() > 0 ) {
int size = sema.availablePermits() >= 2 ? 2 : sema.availablePermits() ;
logger.info("the worker queue is empty, will employ " +size+ " workers." );
Collection workerCol = factory.createWorkers(size, WorkType.STANDARD_WORKER);
for (Worker wk : workerCol) {
wk.setWorkerEventNotifier(this );
}
queue.addAll(workerCol);
}
}
}
private Worker checkWhetherToUseBackupWorker(Worker worker) {
if (worker == null ) {
if (getConfiguration().useBackupWorker()) {
logger.warn("can not find any avaliable worker in queue, will use backup worker." );
return agent.get() ;
}
return null ;
}
return worker ;
}
/*
* @see
* com.oocllogistics.comp.workengine.worker.WorkerBroker#returnBack(com.oocllogistics.comp.workengine.worker.Worker)
*/
public boolean returnBack(Worker worker) {
if (worker == null ) {
return false ;
}
//remove from working queue first.
removeFromWorkingQueue(worker);
boolean succeed = false ;
synchronized (worker) {
boolean exist = queue.contains(worker);
if (exist) {
logger.warn("the worker[id=" +worker.getId()+ "] is existing in worker queue." );
} else {
succeed = queue.offer(worker);
}
}
if (succeed) {
sema.release();
if (logger.isDebugEnabled()) {
logger.info("succeed to put worker[id=" +worker.getId()+ "] in queue." );
}
return true ;
}
logger.warn("return back the worker[id=" +worker.getId()+ "] failed." );
return false ;
}
public void setWorkerFactory(WorkerFactory factory) {
this .factory = factory;
}
public int getWorkingWorkers() {
return workingQueue.size();
}
}

public class WorkerBrokerImpl extends ControlSwitcher implements WorkerBroker, WorkerEventNotifier {

    private AtomicReference agent = new AtomicReference();

    /*
     * *
     * @uml.property name="chain"
     * @uml.associationEnd
     */
    private WorkerEventListenerChain chain = new WorkerEventListenerChain();

    /*
     * *
     * @uml.property name="factory"
     * @uml.associationEnd
     */
    private WorkerFactory factory;

    private AtomicReference firstAssign = new AtomicReference(0L);

    private Log logger ;

    private BlockingQueue queue;

    private Semaphore sema ;

    private BlockingQueue workingQueue ;

    public WorkerBrokerImpl() {
        super();
    }

    public void addEventListener(WorkerEventListener listener) {
        chain.addListener(listener);
    }

    /*
     *
     * @see com.oocllogistics.comp.workengine.worker.WorkerBroker#fireWorker()
     */
    public void fireWorker() {
        int balance = queue.size() ;
        int using = sema.getQueueLength();
        int initWorkers = getConfiguration().getInitNumberofWorkers();
        if (balance + using > initWorkers && using < initWorkers) {
            int fireSize = balance + using - initWorkers ;
            for (int i = 0; i < fireSize; i++) {
                Worker worker = queue.poll();
                if (worker == null) {
                    break;
                }
                if (logger.isDebugEnabled()) {
                    logger.info("fire a worker[id="+worker.getId()+"] from queue.");
                }
                if (worker.isStartForWork()) {
                    logger.info("stop work of worker[id="+worker.getId()+"].");
                    worker.stopWork();
                }
                chain.onEvent(worker, WorkerEvent.FIRE);
            }
        }
    }

    public void fireWorker(Worker worker) {
        if (worker == null) {
            return ;
        }
        queue.remove(worker);
        removeFromWorkingQueue(worker);
        if (logger.isDebugEnabled()) {
            logger.info("fire a worker[id="+worker.getId()+"] from queue.");
        }
        if (worker.isStartForWork()) {
            logger.info("stop work of worker[id="+worker.getId()+"].");
            worker.stopWork();
        }
        chain.onEvent(worker, WorkerEvent.FIRE);
    }

    /*
     *
     * @see com.oocllogistics.comp.workengine.worker.WorkerBroker#getIdleWorkers()
     */
    public int getIdleWorkers() {
        return queue.size();
    }

    @Override
    public Runnable getManagementThread(final WorkConfiguration config) {
        final long max = config.getTaskOverdue() * 1000 ;
        final int initial = getConfiguration().getInitNumberofWorkers() ;
        final AtomicReference firstAssign = this.firstAssign ;
        final BlockingQueue workingQueue = this.workingQueue ;
        final Log logger = this.logger ;
        final WorkerEventListenerChain chain = this.chain ;
        return new Runnable() {
            public void run() {
                long lastFlag = System.currentTimeMillis() ;
                while (isStartForWork()) {
                    try {
                        long current = System.currentTimeMillis() ;
                        if (current - lastFlag > max && getIdleWorkers() > initial) {
                            fireWorker();
                            lastFlag = System.currentTimeMillis() ;
                        }
                        long startTime = firstAssign.get() ;
                        while (startTime == 0L) {
                            Thread.sleep(max);
                            startTime = firstAssign.get() ;
                        }
                        final long interval = current - firstAssign.get();
                        if (interval >= max) {
                            WorkerTracker tracker = workingQueue.poll();
                            if (tracker != null) {
                                Worker worker = tracker.getWorker();
                                logger.warn("the worker["+worker.getId()+"] is overdue, remove from working queue.");
                                removeFromWorkingQueue(worker);
                                chain.onEvent(worker, WorkerEvent.OVERDUE);
                            }
                        }

                        if (max > interval) {
                            Thread.sleep(max - interval);
                        }
                    } catch (InterruptedException e) {
                        String msg = "the worker broker is interrupted, " +
                        		"engine is still start for work[" + isStartForWork() + "].";
                        logger.warn(msg);
                    }
                }
            }
        };
    }

    /*
     *
     * @see com.oocllogistics.comp.workengine.worker.WorkerBroker#getMaxWorkers()
     */
    public int getMaxWorkers() {
        return getConfiguration().getMaxNumberofWorkers() ;
    }

    /*
     * @see
     * com.oocllogistics.comp.workengine.worker.WorkerBroker#hireWorker(com.oocllogistics.comp.workengine.worker.Worker)
     */
    public boolean hireWorker(Worker worker) {
        if (worker == null || !worker.isAvailable() || worker.isStartForWork()) {
            return false;
        }
        if (worker instanceof StandardWorker) {
            logger.info("hire a new worker[id="+worker.getId()+"] into queue.");
            return returnBack(worker);
        }
        if (worker instanceof SpecialWorker) {
            if (agent.get() == null) {
                agent.set(worker);
                logger.info("hire a special worker[id="+worker.getId()+"] as backup.");
                return true ;
            }
        }
        return false ;
    }

    public void notifyWorkerEvent(Worker worker, WorkerEvent event) {
        boolean isReturned = false ;
        switch (event) {
            case CANCEL_WORK:
                isReturned = returnBack(worker);
                break;
            case OVERDUE:
                isReturned = returnBack(worker);
                break;
            case SUBMIT_TASK:
                isReturned = returnBack(worker);
                break;
            default:
                isReturned = true ;
                break;
        }
        if (!isReturned) {
            logger.warn("return back worker[id="+worker.getId()+"] failed.");
        }
        chain.onEvent(worker, event);
    }

    /*
     *
     * @see com.oocllogistics.comp.workengine.impl.ControlSwitcher#postInitial()
     */
    public void postInitial() {
        int init = getConfiguration().getInitNumberofWorkers();
        int total = getConfiguration().getMaxNumberofWorkers();
        sema = new Semaphore(total);
        queue = new ArrayBlockingQueue(total);
        workingQueue = new ArrayBlockingQueue(total);
        Collection workerList = factory.createWorkers(init, WorkType.STANDARD_WORKER);
        for (Worker worker : workerList) {
            worker.setWorkerEventNotifier(this);
            queue.add(worker);
        }
        if (getConfiguration().useBackupWorker()) {
            Worker worker = factory.createWorker(WorkType.AGENT_WORKER);
            worker.setWorkerEventNotifier(this);
            agent.set(worker);
        }
        logger = getConfiguration().getLog() ;
        chain.setService(getEngine().getExecutorService());
    }

    void removeFromWorkingQueue(Worker worker) {
        if (worker == null) {
            return ;
        }
        synchronized (worker) {
            WorkerTracker tracker = new WorkerTracker(worker, 0L);
            if (workingQueue.remove(tracker)) {
                if (tracker != null) {
                    firstAssign.set(tracker.getStartWorkTime());
                } else {
                    firstAssign.set(0L);
                }
                if (logger.isDebugEnabled()) {
                    logger.info("remove the worker[id="+worker.getId()+"] from working queue.");
                }
            } else {
                logger.warn("failed to remove the worker[id="+worker.getId()+"] from working queue.");
            }
        }
    }

    /*
     *
     * @see com.oocllogistics.comp.workengine.worker.WorkerBroker#require(boolean)
     */
    public Worker require(boolean overdue) {
        Worker worker = null ;
        checkWhetherToAddWorker();
        try {
            if (overdue) {
                worker = queue.poll(getConfiguration().getLatencyTimeForWorker(), TimeUnit.SECONDS);
            } else {
                worker = queue.take();
            }
            worker = checkWhetherToUseBackupWorker(worker);
            sema.acquire() ;
            WorkerTracker tracker = new WorkerTracker(worker, System.currentTimeMillis());
            if (workingQueue.offer(tracker)) {
                firstAssign.compareAndSet(0L, tracker.getStartWorkTime());
                if (logger.isDebugEnabled()) {
                    logger.info("put worker[id="+worker.getId()+"] into working queue.");
                }
            } else {
                String msg = "faile to put worker[id="+worker.getId()+"] into working queue. " +
                		"It might cause a worker missing.";
                logger.warn(msg);
                chain.onEvent(worker, WorkerEvent.MISSED);
            }
            return worker ;
        } catch (InterruptedException e) {
            logger.warn("find interrupted exception when requiring a worker.", e);
            return agent.get() ;
        }
    }

    private void checkWhetherToAddWorker() {
        synchronized (queue) {
            if (queue.size() == 0 && sema.availablePermits() > 0) {
                int size = sema.availablePermits() >= 2 ? 2 : sema.availablePermits() ;
                logger.info("the worker queue is empty, will employ "+size+" workers.");
                Collection workerCol = factory.createWorkers(size, WorkType.STANDARD_WORKER);
                for (Worker wk : workerCol) {
                    wk.setWorkerEventNotifier(this);
                }
                queue.addAll(workerCol);
            }
        }
    }

    private Worker checkWhetherToUseBackupWorker(Worker worker) {
        if (worker == null) {
            if (getConfiguration().useBackupWorker()) {
                logger.warn("can not find any avaliable worker in queue, will use backup worker.");
                return agent.get() ;
            }
            return null ;
        }
        return worker ;
    }

    /*
     * @see
     * com.oocllogistics.comp.workengine.worker.WorkerBroker#returnBack(com.oocllogistics.comp.workengine.worker.Worker)
     */
    public boolean returnBack(Worker worker) {
        if (worker == null) {
            return false;
        }
        //remove from working queue first.
        removeFromWorkingQueue(worker);
        boolean succeed = false ;
        synchronized (worker) {
            boolean exist = queue.contains(worker);
            if (exist) {
                logger.warn("the worker[id="+worker.getId()+"] is existing in worker queue.");
            } else {
                succeed = queue.offer(worker);
            }
        }
        if (succeed) {
            sema.release();
            if (logger.isDebugEnabled()) {
                logger.info("succeed to put worker[id="+worker.getId()+"] in queue.");
            }
            return true ;
        }
        logger.warn("return back the worker[id="+worker.getId()+"] failed.");
        return false ;
    }

    public void setWorkerFactory(WorkerFactory factory) {
        this.factory = factory;
    }

    public int getWorkingWorkers() {
        return workingQueue.size();
    }


}

最后是TaskReportQueueImpl, 在这里，其实就是使用Java自带的线程池来实现的

Java代码

public class TaskReportQueueImpl extends ControlSwitcher implements TaskReportQueue {
private Log logger ;
private BlockingQueue queue ;
private ExecutorService service ;
public TaskReportQueueImpl() {
super ();
}
@Override
public Runnable getManagementThread( final WorkConfiguration config) {
final Log logger = this .logger ;
final BlockingQueue queue = this .queue ;
final ExecutorService service = this .service ;
final TaskChainProcessor processor = new TaskChainProcessor();
processor.setEngine(getEngine());
return new Runnable(){
public void run() {
while (isStartForWork()) {
try {
final TaskExecutionReport report = queue.take();
final String category = report.getTask().getCategory();
report.getTask().setReportTime(DateFormatter.now());
Runnable handler = new Runnable(){
public void run() {
TaskProcessDescriptor desc = null ;
desc = getEngine().getTaskCategoryInformation(category);
if (desc == null ) {
logger.warn("the task category[" +category+ "] doesn't register." );
return ;
}
if (StringUtils.isNotEmpty(report.getTask().getGroup())) {
processor.process(report);
}
desc.getResultProcessor().process(report);
}
};
service.execute(handler);
} catch (InterruptedException e) {
String msg = "the task report queue is interrupted, " +
"engine is still start for work[" +isStartForWork()+ "]." ;
logger.warn(msg);
}
}
}
};
}
public void postInitial() {
WorkConfiguration config = getConfiguration() ;
queue = new ArrayBlockingQueue(config.getResultQueueCapacity());
service = getEngine().getExecutorService() ;
logger = getConfiguration().getLog() ;
}
/*
* @see
* com.oocllogistics.domestic.common.worktask.TaskReporter#submitReport(com.oocllogistics.domestic.common.worktask
* .TaskExecutionReport)
*/
public void submitReport(TaskExecutionReport report) {
if (!queue.offer(report)) {
Task task = report.getTask() ;
logger.warn("fail to submit the task report " + task);
}
}
public Iterator iterator() {
TaskExecutionReport[] reports = queue.toArray(new TaskExecutionReport[queue.size()]);
return Arrays.asList(reports).iterator();
}
public int capacity() {
return getConfiguration().getResultQueueCapacity();
}
public int size() {
return queue.size();
}
}

public class TaskReportQueueImpl extends ControlSwitcher implements TaskReportQueue {

    private Log logger ;

    private BlockingQueue queue ;

    private ExecutorService service ;

    public TaskReportQueueImpl() {
        super();
    }

    @Override
    public Runnable getManagementThread(final WorkConfiguration config) {
        final Log logger = this.logger ;
        final BlockingQueue queue = this.queue ;
        final ExecutorService service = this.service ;
        final TaskChainProcessor processor = new TaskChainProcessor();
        processor.setEngine(getEngine());
        return new Runnable(){
            public void run() {
                while(isStartForWork()) {
                    try {
                        final TaskExecutionReport report = queue.take();
                        final String category = report.getTask().getCategory();
                        report.getTask().setReportTime(DateFormatter.now());
                        Runnable handler = new Runnable(){
                            public void run() {
                                TaskProcessDescriptor desc = null ;
                                desc = getEngine().getTaskCategoryInformation(category);
                                if (desc == null) {
                                    logger.warn("the task category["+category+"] doesn't register.");
                                    return ;
                                }
                                if (StringUtils.isNotEmpty(report.getTask().getGroup())) {
                                    processor.process(report);
                                }
                                desc.getResultProcessor().process(report);
                            }
                        };
                        service.execute(handler);
                    } catch (InterruptedException e) {
                        String msg = "the task report queue is interrupted, " +
                        		"engine is still start for work["+isStartForWork()+"].";
                        logger.warn(msg);
                    }
                }
            }
        };
    }

    public void postInitial() {
        WorkConfiguration config = getConfiguration() ;
        queue = new ArrayBlockingQueue(config.getResultQueueCapacity());
        service = getEngine().getExecutorService() ;
        logger = getConfiguration().getLog() ;
    }

    /*
     * @see
     * com.oocllogistics.domestic.common.worktask.TaskReporter#submitReport(com.oocllogistics.domestic.common.worktask
     * .TaskExecutionReport)
     */
    public void submitReport(TaskExecutionReport report) {
        if (!queue.offer(report)) {
            Task task = report.getTask() ;
            logger.warn("fail to submit the task report " + task);
        }
    }

    public Iterator iterator() {
        TaskExecutionReport[] reports = queue.toArray(new TaskExecutionReport[queue.size()]);
        return Arrays.asList(reports).iterator();
    }

    public int capacity() {
        return getConfiguration().getResultQueueCapacity();
    }

    public int size() {
        return queue.size();
    }



}

核心的接口和实现贴出来了，希望对那些想学怎么写线程池的童鞋能有所帮助。

测试运行最多的时候是25个客户线程（负责提交任务），20个工作线程（负责处理任务），5个任务结果处理线程以及3个管理线程。

经过测试，下面这些测试用例是可通过的, CPU能保持在5%以下。并且Task在队列中等待和处理时间基本为0.

Java代码

//SMALLEST -- 500ms
//SMALLER -- 1000ms
//NORMAL -- 2000ms
//BIGGER -- 5000ms
//BIGGEST -- 5000ms
//test time unit is second
public void testStandardPerformanceInMinute() {
concurrentTaskThread = 10 ;
totalTasks.put(Category.SMALLEST, 400 );
totalTasks.put(Category.SMALLER, 350 );
totalTasks.put(Category.NORMAL, 250 );
testTime = 60 ;
testPerformance();
}
public void testAdvancePerformanceIn2Minute() {
concurrentTaskThread = 20 ;
totalTasks.put(Category.SMALLEST, 300 );
totalTasks.put(Category.SMALLER, 300 );
totalTasks.put(Category.NORMAL, 200 );
totalTasks.put(Category.BIGGER, 100 );
totalTasks.put(Category.BIGGEST, 100 );
testTime = 120 ;
testPerformance();
}
public void testPerformanceUnderHugeData() {
concurrentTaskThread = 25 ;
totalTasks.put(Category.SMALLEST, 1500 );
totalTasks.put(Category.SMALLER, 500 );
totalTasks.put(Category.NORMAL, 500 );
testTime = 120 ;
testPerformance();
}

    //SMALLEST -- 500ms
    //SMALLER -- 1000ms
    //NORMAL -- 2000ms
    //BIGGER -- 5000ms
    //BIGGEST -- 5000ms
    //test time unit is second

    public void testStandardPerformanceInMinute() {
        concurrentTaskThread = 10 ;
        totalTasks.put(Category.SMALLEST, 400);
        totalTasks.put(Category.SMALLER, 350);
        totalTasks.put(Category.NORMAL, 250);
        testTime = 60 ;
        testPerformance();
    }

    public void testAdvancePerformanceIn2Minute() {
        concurrentTaskThread = 20 ;
        totalTasks.put(Category.SMALLEST, 300);
        totalTasks.put(Category.SMALLER, 300);
        totalTasks.put(Category.NORMAL, 200);
        totalTasks.put(Category.BIGGER, 100);
        totalTasks.put(Category.BIGGEST, 100);
        testTime = 120 ;
        testPerformance();
    }

    public void testPerformanceUnderHugeData() {
        concurrentTaskThread = 25 ;
        totalTasks.put(Category.SMALLEST, 1500);
        totalTasks.put(Category.SMALLER, 500);
        totalTasks.put(Category.NORMAL, 500);
        testTime = 120 ;
        testPerformance();
    }

欢迎大家讨论....

2
顶

0
踩

14:18
浏览 (368)
评论 (11)
分类: Java
相关推荐

11 楼凤舞凰扬 2009-09-02 引用

方世玉写道

能否把组件提供试用一下？

因为现在做的是公司内部的组件，不能直接提供。我和几个朋友打算整理出一些东西做成开源的组件，有兴趣可以参考使用。

10 楼方世玉 2009-09-02 引用

能否把组件提供试用一下？

9 楼 fjlyxx 2009-08-31 引用

实不相瞒我们现在做的请求服务就是靠这个微内核（当然还有可以插拔的监控，逻辑内核服务等插件）可以达到每小时吞吐几千万请求。LF模型适合在网络通信中使用。

没错是响应,如果包括业务处理那是不可能的(这里的响应是指服务器接受请求并且返回一个任务令牌给客户端)
说实话也只有AIX的小型机能做到这点但是AIX的小型机器对BYTE的高低位读取和其他操作系统有区别所以在AIX下用字符(不传BYTE传字符) 这点可能对性能有一定的影响其他的操作系统很难做到吞吐几千万的如果用WIN 大概没秒最多也就3W(短连接情况下) 超过3W的时候一般WIN会拒绝连接信道回收严重不足在LINUX下可以改下配置达到每秒十几到几十W左右但是要改配置(2.6的内核才行)

关于数据库的批量操作确实是头疼的问题,要具体分析特别是在高并非的情况下.

8 楼凤舞凰扬 2009-08-31 引用

引用

实不相瞒我们现在做的请求服务就是靠这个微内核（当然还有可以插拔的监控，逻辑内核服务等插件）可以达到每小时吞吐几千万请求。LF模型适合在网络通信中使用。

关于你的第七楼的回复，我明天详细给你回复。不过没小时几千万的请求，平均每秒有将近3w的请求，如果一个请求在100ns，等于有3000个并发线程，理论上来说在单机上也是存在的，不过绝对保证不是不是完整的消息处理（只能说是响应）。（我们用TIBCO的EMS，在几百万的小型机上也就是跑能几百万的消息处理）

引用

1.说句实话要做到线程和业务的完全分离不太可能比如每个线程要进行1次数据库操作每次操作时间为1秒你同时并发100个线程你就要同时拥有100个连接这时候批量很重要实践证明我们把数据库操作进行委托后吞吐率是几何数的增长。

消息处理引擎也好，任务处理引擎也好，本身就是和具体业务分离的，否则又这么叫中间件啊！JMS的MQ也好，Spring的异步任务组件也好，都是此类。至于数据库操作，你完全可以在在任务的执行过程中把SQL放入batch，而在任务结果处理后，每隔一定数量和时间批量提交就是。只是这样的话，任务本身就不是独立的了。如果你的SQL本身就是任务的组成部分，那么等于就是一个任务与其他任务存在了关联（批量操作因为某个任务失败，其他任务本应产生的数据库操作均失败了。），这在业务系统中是不可取的。所以这个是需要在现实情况中具体考量的。

引用

2.如果业务有重试的操作那么是否考虑在队列中的任务有会被重复执行的情况，比如 A任务失败，业务把A放回队列 --》 A在队列中等待。以此类推如果队列中同时存在大于或等于2个以上A任务的时候是否存在A会被重复的正确执行。

怎么可能同时存在2个或以上的相同任务在queue中呢？除非客户端放入两个同样的任务。A任务放入队列后，只会被一个工作线程取走，当工作线程执行失败后，工作线程会返回该任务及错误信息，引擎根据配置确定是否需要将该任务重新放入。如果重新放入，队列中也只会有一个A任务。

引用

综上，个人认为线程池是死的，但是线程池的工作模式是活的。你可以让所有工人在包工头的控制下进行工作也可以让所以工人按照一定的规则进行存活。前者一切可控，后者灵活多变。前者可能要颁发一般宪法后者也许只要简单约定。

怎么你倒现在都任务工作线程是在工头的控制下工作呢？工头的作用只是以下几个作用：
1. 根据资源情况调节工作线程的数量，合理利用资源。这在业务系统中非常重要。
2. 管理超时或者异常的工作线程（当某个工作线程执行任务超过一段时间，可以异常处理甚至强制回收)，防止资源泄漏。
3. 工作线程池的代理，对于引擎来说，它所关心的是需要工人来处理任务，它丝毫不关心工人来自哪里，从何而来，执行完任务后又如何重新使用。

7 楼 fjlyxx 2009-08-28 引用

我的分歧根本在于以下这两种模型的争论。

就是包工头--》工人--》包工头和包工头--》包工头--》一直包工头模式的区别。

程池模式一般分为两种：L/F领导者与跟随者模式、HS/HA半同步/半异步模式。
HS/HA 半同步/ 半异步模式：分为三层，同步层、队列层、异步层，又称为生产者消费者模式，主线程处理I/O事件并解析然后再往队列丢数据，然后消费者读出数据进行应用逻辑处理；
优点：简化编程将低层的异步I/O和高层同步应用服务分离，且没有降低低层服务性能。集中层间通信。
缺点：需要线程间传输数据，因此而带来的动态内存分配，数据拷贝，语境切换带来开销。高层服务不可能从底层异步服务效率中获益。
L/F 领导者跟随者模式：在LF线程池中，线程可处在3种线程状态之一： leader、follower或processor。处于leader状态的线程负责监听网络端口，当有消息到达时，该线程负责消息分离，并从处于 follower状态中的线程中按照某种机制如FIFO或基于优先级等选出一个来当新的leader，然后将自己设置为processor状态去分配和处理该事件。处理完毕后线程将自身的状态设置为follower状态去等待重新成为leader。在整个线程池中同一时刻只有一个线程可以处于leader 状态，这保证了同一事件不会被多个线程重复处理。
缺点：实现复杂性和缺乏灵活性；
优点：增强了CPU高速缓存相似性，消除了动态内存分配和线程间的数据交换。
两种模式性能分析：
L/F 模式处理一个消息的时间为多路分离、分配、处理的时间，加上线程管理时间，LF中多个线程共享一个事件源，所以，需要协调它们间的行为，即有同步开销，L/F同步开销仅为申请/释放锁的开销，在LF处理请求过程中并不需要线程上下文切换，但是在线程由follower成为leader时需要进行线程上下文切换，所以当两个请求同时到达时，这种上下文切换会影响第二个请求的处理时间，也会带来一定的上下文开销。
T（L/F）=T（多路分离）+T（分配）+T（处理）+T（同步）+T（上下文）
HS/HA 模式监听线程和工作线程间通过一个消息队列来交换数据。这会带来数据传递开销，。同时，监听线程和工作线程都需要去访问消息队列，造成了资源的竞争，需要额外的同步机制来协调他们的行为，包括监听线程获取和释放资源锁，对应的工作线程获取和释放资源锁，以及监听线程在将一个请求放入队列后通知工作线程带来的开销，我们称此为同步开销，HS/HA模式的同步开销大于L/F的同步开销，。一个请求由监听线程负责放入消息队列，但是却由工作线程来处理，所以，每个请求都会造成一次线程上下文切
换，由此带来的开销我们称为上下文开销。
T （H/H）=T（多路分离）+T（分配）+T（处理）+T（同步）+T（数据传递）+T（上下文）
从上面分析可以看出没有并发情况下L/F模式线程池模式性能优于HS/HA模式。
并发性能分析：
T（多路分离）、T（分配）：LF和HH中把每一个消息的到来当作一个事件来处理。事件分配所做的工作是在一个事件处理器注册表中为一个事件查找事件处理器。这一步骤花费的时间随着当前注册的事件处理器的个数变化。当线程池接受用户连接请求后会为每一个连接注册一个事件处理器，所有通过该连接发来的请求都将由同一个事件处理器来处理。而事件处理器表采用一个平衡二叉树来实现。因此，事件分配的时间可以认为是随着并发用户数的增大而增大；
T（处理）处理消息和管理线程所需的时间都不受并发用户数的影响。
T（线程管理），多线程带来的线程管理开销只会随着线程池中线程数而变化，相对固定。
LF和HH的吞吐量会随着并发用户数的增加而增加。当并发用户数达到一定数量时，CPU成为系统瓶颈，此后增大并发用户数不仅不能增加并发处理的请求个数，反而会加大多路分离和分配的时间，从而使得系统吞吐量下降。
最佳性能时线程线：
随着线程数的增多吞吐量不断增大，当达到最大值后有一个短暂的保持阶段，此后继续增大线程数反而会使得吞吐量减小。而且当请求类型为计算密集型时线程数对
HH 的吞吐量的影响并不是很明显。原因是HH线程池在增加线程数时线程管理开销也有较大幅度的增加。因此，通过增大线程数来改善系统性能对HH来说并不是一种有效的方法。

6 楼 fjlyxx 2009-08-28 引用

实不相瞒我们现在做的请求服务就是靠这个微内核（当然还有可以插拔的监控，逻辑内核服务等插件）可以达到每小时吞吐几千万请求。LF模型适合在网络通信中使用。

1.说句实话要做到线程和业务的完全分离不太可能比如每个线程要进行1次数据库操作每次操作时间为1秒你同时并发100个线程你就要同时拥有100个连接这时候批量很重要实践证明我们把数据库操作进行委托后吞吐率是几何数的增长。

2.如果业务有重试的操作那么是否考虑在队列中的任务有会被重复执行的情况，比如 A任务失败，业务把A放回队列 --》 A在队列中等待。以此类推如果队列中同时存在大于或等于2个以上A任务的时候是否存在A会被重复的正确执行。

综上，个人认为线程池是死的，但是线程池的工作模式是活的。你可以让所有工人在包工头的控制下进行工作也可以让所以工人按照一定的规则进行存活。前者一切可控，后者灵活多变。前者可能要颁发一般宪法后者也许只要简单约定。

5 楼凤舞凰扬 2009-08-27 引用

   首先跟你解释一下WorkerBroker的几个作用吧：
1. 它是工作线程池的一个代理，它的存在可以隔离工作线程的实现方式。对于任务队列来说，它丝毫不关心工作线程的具体情况及维护。
2. 它本身就是一个线程池，它管理者一批工作线程。每个工作线程都是独立可重用的。正因为工作线程是独立，那么对于线程池本身来说，是需要一个管理线程来管理和维护的。管理线程与工作线程的分离，可以保证功能的专一性，也同时提高容错性。如果没有管理线程，又如何调度工作线程（包括回收、监听、根据情况创建调节）。
   至于你说有多个WorkerBroker，不清楚是否指Broker chain的概念，但如果那样，只是增加了对于任务队列或者WorkEngine来说的复杂度。对于他们来说，是丝毫不需要关心这种细节的。同时，这种关系其实丢弃了作为工作线程的独立性（它必须知道和关联其他的工作线程），这种设计非常容易出现资源泄漏。
   最后关于你说的并发，会有多个客户程序提交任务，而多个工作线程又是独立的收取、执行任务，并通知自己是否有效工作（一个工作线程是无法同时执行也不应该同时执行多个任务的，所以必须在任务执行完要反馈到线程池中），这些都是需要同步控制的。
   其实关于池的实现或者概念，在java本身的代码中或者commons-pool中都有不错的范例，可以好好看看。

4 楼 fjlyxx 2009-08-27 引用

凤舞凰扬：会有死锁问题么？

抱歉，我不是针对你的线程才这么说。

水位的保护我的意思是说线程池能够使用的资源应该有一个水位，其实你已经有了。

和业务松耦合好的线程模式可以解决这个问题，线程的借出和归还应该有统一的人操作不应该涉及要使用线程的业务所以你一定会提供一个业务的切入点

凤舞凰扬：实不相瞒，你提供的这个线程池只是自己写的练手Sample程序，存在的问题蛮大的，连最起码的并发控制都看不到。我还是建议你好好仔细看看我的代码吧，我想你应该看得到区别的。

好像不存在并发吧，这种线程模型干嘛要并发呢。。。

你的代码设计的不错但是就是包工头指定工作去跑这段我觉得还可以优化。。

如果每个人都可以做包工头，包工头只是指定下一个包工头那么我为什么又要去做并发控制不用我控制它自己就跑的很好了。。。

所以一堆的管理线程其实是带来麻烦的根源个人觉得最好的线程是不需要人管理的自己就能够管理自己每个线程平等只是元的一个集合而已你只要给它生存规则

3 楼 fjlyxx 2009-08-27 引用

凤舞凰扬：有了一个任务，然后是通过WorkerBroker去require一个Worker，现实的例子就像来了个任务，包工头分配一个工人去做一样。所以不会有任何争抢，当然了，WorkerBroker本身也是一个管理线程。

其实你能否考虑下由包工头去找一个工人做包工头然后包工头自己去做任务。

状态大概是包工头（A）--》找一个可用工作做包工头(B)--》包工头（A）跑业务

2 楼凤舞凰扬 2009-08-26 引用

我觉得结构还可以优美点把任务和线程池分开

凤舞凰扬：呵呵，任务队列和工作线程池本身就是分开的。
其实可以优化的是，应该由Engine去管理任务与工作线程的关系，而不是在TaskQueueImpl直接从Broker获取Worker
在我看来线程池几点是值得注意的
1.丢失问题是线程主动去跑业务还是业务去借线程

凤舞凰扬：不会有任何丢失，只是在最初的方案中始终有一个等待的工作线程(Worker)，其实可以稍微改动一下，也就是将取任务放在获取工作线程前。不过先后与否，都不会有任何任务或者工作线程的丢失（如果丢失了，那就是大事了，呵呵）。
2.竞争问题有了一个任务线程池是否能决定有谁去做而不会发生争抢着做的情况

凤舞凰扬：有了一个任务，然后是通过WorkerBroker去require一个Worker，现实的例子就像来了个任务，包工头分配一个工人去做一样。所以不会有任何争抢，当然了，WorkerBroker本身也是一个管理线程。

引用

3.死锁问题死信通知很重要监控这块

凤舞凰扬：会有死锁问题么？

引用

4.和业务松耦合

凤舞凰扬：你看到任何业务的东东了么？

引用

5.水位的保护

凤舞凰扬：不太清楚什么叫水位

引用

6.容错

凤舞凰扬：容错机制还算

引用

7.线程的异步和同步

凤舞凰扬：.......

引用

8.反馈机制

凤舞凰扬：所以设计了事件和监听机制

引用

9.中间结果等缓存。。例如数据库操作的批量日志的批量

凤舞凰扬：不清楚什么中间结果？理论上来说，有四个地方可以嵌入数据库的操作，任务的持久化、任务结果的处理，工作线程的事件监听、任务的事件监听。

引用

个人觉得任务队列可以放到MQ或EJB中放在中间件的组件中总比放在你包含线程池的应用中好

凤舞凰扬：使用MQ是个不错的主意，不过注意两点：1.在大企业的应用中，任何外购组件（商用的好，免费的好），都必须经过POC（概念验证）。2. 如果没有用EJB，MQ更多的是消息处理引擎，而不是任务处理（这也是MDB存在的价值）。其实我们的实践是系统间的集成通信包括了使用基于JMS的 TIBCO EMS，而这个任务组件只是系统内部。当然了，spring的batch也是个值得替代的东东。

引用

同时非即时性的东西如数据库日志可以考虑用缓存批量入库

凤舞凰扬：数据库的处理对于任务工作池来说是外部配属的东西，不应该在组件本身中考虑。

引用

个人总觉得线程池最好不要和数据库挂钩就算你用了数据库连接池但是数据库的使用会成为线程池处理性能的瓶颈是否可以考虑将线程池的处理结果缓存起来通过另外一个线程进行批量操作 [、quote]
凤舞凰扬：这个问题好像不是说我的，呵呵

引用

胡乱将几句见笑了。

这个线程池简单了点但是模型不错
http://www.javaeye.com/topic/451240

引用

凤舞凰扬：实不相瞒，你提供的这个线程池只是自己写的练手Sample程序，存在的问题蛮大的，连最起码的并发控制都看不到。我还是建议你好好仔细看看我的代码吧，我想你应该看得到区别的。

1 楼 fjlyxx 2009-08-26 引用

我觉得结构还可以优美点把任务和线程池分开
在我看来线程池几点是值得注意的
1.丢失问题是线程主动去跑业务还是业务去借线程
2.竞争问题有了一个任务线程池是否能决定有谁去做而不会发生争抢着做的情况
3.死锁问题死信通知很重要监控这块
4.和业务松耦合
5.水位的保护
6.容错
7.线程的异步和同步
8.反馈机制
9.中间结果等缓存。。例如数据库操作的批量日志的批量

个人觉得任务队列可以放到MQ或EJB中放在中间件的组件中总比放在你包含线程池的应用中好

同时非即时性的东西如数据库日志可以考虑用缓存批量入库

个人总觉得线程池最好不要和数据库挂钩就算你用了数据库连接池但是数据库的使用会成为线程池处理性能的瓶颈是否可以考虑将线程池的处理结果缓存起来通过另外一个线程进行批量操作

胡乱将几句见笑了。

这个线程池简单了点但是模型不错
http://www.javaeye.com/topic/451240

你可能感兴趣的:(线程)

ios GCD _Waiting_
1.GCD任务和队列学习GCD之前，先来了解GCD中两个核心概念：任务和队列。任务：就是执行操作的意思，换句话说就是你在线程中执行的那段代码。在GCD中是放在block中的。执行任务有两种方式：同步执行（sync）和异步执行（async）。两者的主要区别是：是否等待队列的任务执行结束，以及是否具备开启新线程的能力。同步执行（sync）：同步添加任务到指定的队列中，在添加的任务执行结束之前，会一直等
多线程之——ExecutorCompletionService 阿福德
在我们开发中，经常会遇到这种情况，我们起多个线程来执行，等所有的线程都执行完成后，我们需要得到个线程的执行结果来进行聚合处理。我在内部代码评审时，发现了不少这种情况。看很多同学都使用正确，但比较啰嗦，效率也不高。本文介绍一个简单处理这种情况的方法：直接上代码：publicclassExecutorCompletionServiceTest{@TestpublicvoidtestExecutorCo
python多线程程序设计之一 IT_Beijing_BIT #Python 程序设计语言 python
python多线程程序设计之一全局解释器锁线程APIsthreading.active_count()threading.current_thread()threading.excepthook(args,/)threading.get_native_id()threading.main_thread()threading.stack_size([size])线程对象成员函数构造器start/ru
SpringCloudAlibaba—Sentinel(限流) 菜鸟爪哇
前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
Python多线程实现大规模数据集高效转移 sand&wich 网络 python 服务器
背景在处理大规模数据集时，通常需要在不同存储设备、不同服务器或文件夹之间高效地传输数据。如果采用单线程传输方式，当数据量非常大时，整个过程会非常耗时。因此，通过多线程并行处理可以大幅提升数据传输效率。本文将分享一个基于Python多线程实现的高效数据传输工具，通过遍历源文件夹中的所有文件，将它们移动到目标文件夹。工具和库这个数据集转移工具主要依赖于以下Python标准库：os：用于文件系统操作，如
Python实现下载当前年份的谷歌影像 sand&wich python 开发语言
在GIS项目和地图应用中，获取最新的地理影像数据是非常重要的。本文将介绍如何使用Python代码从Google地图自动下载当前年份的影像数据，并将其保存为高分辨率的TIFF格式文件。这个过程涉及地理坐标转换、多线程下载和图像处理。关键功能该脚本的核心功能包括：坐标转换：支持WGS-84与WebMercator投影之间转换，以及处理中国GCJ-02偏移。自动化下载：多线程下载地图瓦片，提高效率。图像
WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Java java 爬虫开发语言
文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
经纬恒润二面&三七互娱一面&元象二面 Redstone Monstrosity 面试前端
1.请尽可能详细地说明，进程和线程的区别，分别有哪些应用场景？进程间如何通信？线程间如何通信？你的回答中不要写出示例代码。进程和线程是操作系统中的两个基本概念，它们在计算机系统中扮演着不同的角色，并且在不同的应用场景中发挥作用。进程和线程的区别定义：进程：进程是操作系统进行资源分配和调度的基本单位。每个进程都有独立的内存空间和系统资源。线程：线程是进程内的一个执行单元，是操作系统进行调度的最小单位
Redis Key的过期策略 ArchManual 分布式架构分布式 Java 后端微服务架构 redis
Redis的过期策略主要是指管理和删除那些设定了过期时间的键，以确保内存的有效使用和数据的及时清理。具体来说，Redis有三种主要的过期策略：定期删除（ScheduledDeletion）、惰性删除（LazyDeletion）和内存淘汰策略（EvictionPolicies）。1.定期删除Redis的定期删除策略（ScheduledDeletion）的步骤如下：设置定期任务：Redis会在后台线程
Redis:缓存击穿我的程序快快跑啊缓存 redis java
缓存击穿(热点key)：部分key(被高并发访问且缓存重建业务复杂的)失效,无数请求会直接到数据库，造成巨大压力1.互斥锁：可以保证强一致性线程一：未命中之后，获取互斥锁，再查询数据库重建缓存，写入缓存，释放锁线程二：查询未命中，未获得锁(已由线程一获得)，等待一会，缓存命中互斥锁实现方式：redis中setnxkeyvalue:改变对应key的value,仅当value不存在时执行，以此来实现互
【java】怎么理解不同对象实例的对象锁是互不干扰的晨春计 Android java
在Java中，synchronized关键字用于实现线程同步，它可以作用于实例方法、静态方法以及代码块。当synchronized应用于实例方法或实例变量时，它创建的是一个对象锁，这个锁是与特定的对象实例关联的。因此，每个对象实例都有其自己的锁。这里的关键点在于，对象锁是绑定到特定对象实例上的。这意味着对于不同的对象实例，即使它们属于同一个类，它们各自拥有独立的对象锁。当一个线程获取了一个对象实例
程序计数器的作用毕加涛 java
程序计数器的作用就是**用来记住下一条jvm指令的执行地址。**它的特点是**线程私有的**，也就是一人一个。然后cpu会给每个线程分配时间片，然后等待这个线程的时间片用完之后就会轮到下一个线程来执行。所以此时就需要计数器来记录线程运行的下一行指令的地址，等到下次轮到这个线程执行的时候来到上次执行的指令地址来继续执行指令。所以它的作用就是：为了保证程序的执行遵循自上而下有顺序的执行。
tcp线程进程多并发 @莫福瑞算法
tcp线程多并发#include#defineSERPORT8888#defineSERIP"192.168.0.118"#defineBACKLOG20typedefstruct{intnewfd;structsockaddr_incin;}BMH;void*fun1(void*sss){intnewfd=accept((BMH*)sss)->newfd;structsockaddr_incin
保证RTOS线程安全的常规操作 WittXie 单片机嵌入式硬件
线程安全定义原子操作：一种不可分割的操作，要么完全执行成功，要么完全不执行，不能被打断临界区：一段代码，这段代码需要在同一时间只允许一个线程执行互斥锁：一种用于保护共享资源的机制，确保同一时间只有一个线程可以访问特定资源应用裸机原子操作/临界区可以通过暂时关闭中断响应实现一般用不到互斥锁RTOS原子操作：暂时关闭中断响应+挂起所有应用（不建议，RTOS尽量不要开启中断，改为线程监听）临界区：挂起所
单线程执行器（`SingleThreadedExecutor`）来处理节点的任务课堂随想 moveit2 机器人
intmain(intargc,char**argv){rclcpp::init(argc,argv);rclcpp::NodeOptionsnode_options;node_options.automatically_declare_parameters_from_overrides(true);automove_group_node=rclcpp::Node::make_shared("mo
golang学习笔记--MPG模型 xxzed golang #学习笔记学习笔记 golang
MPG模式：M（Machine）：操作系统的主线程P（Processor）：协程执行需要的资源（上下文context），可以看作一个局部的调度器，使go代码在一个线程上跑，他是实现从N：1到N：M映射的关键G（Goroutine）：协程，有自己的栈。包含指令指针（instructionpointer）和其它信息（正在等待的channel等等），用于调度。一个P下面可以有多个G1、当前程序有三个M,
C# 开发教程-入门基础天马3798 教程系列整理 c#开发语言
1.C#简介、环境，程序结构2.C#基本语法，变量，控制局域，数据类型，类型转换3.C#数组、循环，Linq4.C#类，封装，方法5.C#枚举、字符串6.C#面相对象，继承，封装，多态7.C#特性、属性、反射、索引器8.C#委托，事件，集合，泛型9.C#匿名方法10.C#多线程更多：JQuery开发教程入门基础Vue开发基础入门教程Vue开发高级学习教程
【C#Mutex】 initiallyOwned错误引起的缺陷闻缺陷则喜何志丹 c#互斥量进程同步 WaitOne initiallyOwned 临界区
临界区只能对同一个进程的不同线程同步，互斥量可以跨进程同步。典型应用场景：两个exe会操作同一个注册表项。错误代码封装类publicclassCMutexHelp:IDisposable{publicCMutexHelp(){s_mutex.WaitOne();}privatestaticMutexs_mutex=newMutex(true,"Time202409091406ab");public
[面试高频问题]关于多线程的单例模式朱玥玥要每天学习 java 单例模式开发语言
单例模式什么是设计模式?设计模式可以看做为框架或者是围棋中的”棋谱”,红方当头炮,黑方马来跳.根据一些固定的套路下,能保证局势不会吃亏.在日常的程序设计中,往往有许多业务场景,根据这些场景,大佬们总结出了一些固定的套路.按照这个套路来实现代码,也不会吃亏.什么是单例模式,保证某类在程序中只有一个实例,而不会创建多份实例.单例模式具体的实现方式:可分为”懒汉模式”,”饿汉模式”.饿汉模式类加载的同时
[Golang] goroutine 沉着冷静2024 Golang golang 后端
[Golang]goroutine文章目录[Golang]goroutine并发进程和线程协程goroutine概述如何使用goroutine并发进程和线程谈到并发，大多都离不开进程和线程，什么是进程、什么是线程？进程可以这样理解：进程就是运行着的程序，它是程序在操作系统的一次执行过程，是一个程序的动态概念，进程是操作系统分配资源的基本单位。线程可以这样理解：线程是一个进程的执行实体，它是比进程粒
Spring @Async 深度解读：默认线程池执行器的配置与优化小码快撩 spring java 前端
在Spring中，@Async注解用于异步执行方法。默认情况下，@Async注解的任务是由一个线程池执行的。然而，这个默认的线程池是如何初始化的呢？本文将深入探讨这一过程，帮助你理解Spring异步任务背后的线程池执行器的初始化原理。1.@Async的基本使用首先，让我们快速回顾一下@Async的基本用法。@Async通常用于标注在需要异步执行的方法上，比如：@Servicepublicclass
Rides实现分布式锁，保障数据一致性,Redisson分布式事务处理朱杰jjj 缓存分布式
分布式环境下分布式锁有三种方式：基于数据库分布式锁基于Redis分布式锁基于zk分布式锁本帖只介绍Redis分布式锁为什么需要用到分布式锁？在单机环境下一个服务中多个线程对同一个事物或数据资源进行操作时，可以通过添加加锁方式（synchronized和lock）来解决数据一致性的问题。但是如果出现多个服务的情况下，这时候我们在通过synchronized和lock的方式来加锁会出现问题，因为多个服
连接池的性能如何优化？蜡笔小新星 MySQL 经验分享学习 python mysql 数据库
连接池的性能优化是提高数据库访问效率和应用程序响应速度的关键。以下是一些优化连接池性能的策略：1.选择合适的连接池大小连接池的大小应根据应用程序的并发需求和数据库服务器的处理能力来确定。如果连接池太小，可能会导致线程等待连接；如果连接池太大，可能会消耗过多的系统资源。通常，连接池的大小应该设置为应用程序的并发用户数加上一些额外的连接以处理突发请求。2.设置合理的最小和最大连接数最小连接数（mins
基于flask做大模型SSE输出 Mark_Aussie nlp flask python 后端
默认情况下，Fask以多线程模式运行，每个请求都落在一个新线程上。SSE：基于HTTP的协议，用于实现服务器向客户端推送实时数据。使用长轮询机制，客户端通过HTTP连接向服务器发送请求，并保持该连接打开，服务器可以随时向客户端推送新的数据。SSE协议使用简单的文本格式，数据通过纯文本的消息流进行传输，每个消息以"data:"开头，以两个换行符"\n\n"结尾，如果传递的数据中有字典要使用变量传递。
Vector与Stack简述 Sun_Jingjing Java 集合
Vector：线程安全，默认容量为10，容量增长量默认为0，每次进行扩容是旧的容量乘以2。支持null的添加。基于数组实现。Stack：Stack继承Vector的栈结构。
为什么Node.js不适合CPU密集型应用？ weixin_54503231 node.js
Node.js不适合CPU密集型应用的原因主要基于其设计理念和核心特性，具体可以归纳为以下几点：单线程模型Node.js采用单线程模型来处理用户请求和异步I/O操作。虽然这种模型在处理高并发I/O密集型任务时非常高效，因为它避免了传统多线程模型中的线程上下文切换开销，但这也意味着它不能充分利用现代多核CPU的计算能力。对于需要大量计算资源的CPU密集型应用，单线程模型会成为瓶颈，导致应用性能受限。
Java内存模型基础 2401_84002271 程序员 java 学习经验分享
1.2Java内存模型的抽象结构Java中所有的实例域、静态域和数组元素都存储在堆内存中，堆内存在线程之间共享（文章中用“共享变量”指代）。局部变量(LocalVariables)、方法定义参数(FormalMethodParameters)和异常处理器参数(ExceptionHandlerParameters)不会在线程之间共享，它们不会存在内存可见性问题，因此也不受内存模型的影响。Java线程
Spring Cloud: Hystrix请求队列线程不足 MeazZa
在SpringCloud中，Feign可以实现本地化的微服务API调用，Hystrix可以实现调用失败时的fallback处理。问题描述：在实际生产环境中使用时，我们遇到了这样一个错误："...,stacktrace:[com.netflix.hystrix.exception.HystrixRuntimeException:QueryNodeImpalaBdService#getQueryRes
【编程底层原理】HashMap Hashtable ConcurrentHashMap Dylanioucn 开发语言后端 java
在Java的不同版本中，集合的实现原理有所变化，尤其是在HashMap、Hashtable和ConcurrentHashMap这三种实现中。以下是它们的一些关键区别和实现原理：一、HashMapJDK1.7：HashMap使用数组和链表的组合来解决冲突。当一个桶（数组的每个位置）中的元素超过一定数量时，会使用链表来存储这些元素。HashMap在JDK1.7中不是线程安全的。JDK1.8：进行了优化
PCL 点云视窗类CloudViewer LeonDL168 PCL 算法计算机视觉人工智能视觉检测图像处理
点云视窗类CloudViewer是简单显示点云的可视化工具类，可以让用户用尽可能少的代码查看点云。注意：点云视窗类不能应用于多线程应用程序中。简单点云可视化如果用户想用几行代码可视化程序中所对应的地物，可以使用下面的代码：#include//...voidfoo(){pcl::PointCloud::Ptrcloud;//...为cloud添加对应的场景pcl::visualization::Cl
Java常用排序算法/程序员必须掌握的8大排序算法 cugfy java
分类： 1）插入排序（直接插入排序、希尔排序） 2）交换排序（冒泡排序、快速排序） 3）选择排序（直接选择排序、堆排序） 4）归并排序 5）分配排序（基数排序）所需辅助空间最多：归并排序所需辅助空间最少：堆排序平均速度最快：快速排序不稳定：快速排序，希尔排序，堆排序。先来看看8种排序之间的关系： 1.直接插入排序（1
【Spark102】Spark存储模块BlockManager剖析 bit1129 manager
Spark围绕着BlockManager构建了存储模块，包括RDD，Shuffle，Broadcast的存储都使用了BlockManager。而BlockManager在实现上是一个针对每个应用的Master/Executor结构，即Driver上BlockManager充当了Master角色，而各个Slave上(具体到应用范围，就是Executor)的BlockManager充当了Slave角色
linux 查看端口被占用情况详解 daizj linux 端口占用 netstat lsof
经常在启动一个程序会碰到端口被占用，这里讲一下怎么查看端口是否被占用，及哪个程序占用，怎么Kill掉已占用端口的程序 1、lsof -i:port port为端口号 [root@slave /data/spark-1.4.0-bin-cdh4]# lsof -i:8080 COMMAND PID USER FD TY
Hosts文件使用周凡杨 hosts locahost
一切都要从localhost说起，经常在tomcat容器起动后，访问页面时输入http://localhost:8088/index.jsp，大家都知道localhost代表本机地址，如果本机IP是10.10.134.21，那就相当于http://10.10.134.21:8088/index.jsp，有时候也会看到http: 127.0.0.1:
java excel工具 g21121 Java excel
直接上代码，一看就懂，利用的是jxl： import java.io.File; import java.io.IOException; import jxl.Cell; import jxl.Sheet; import jxl.Workbook; import jxl.read.biff.BiffException; import jxl.write.Label; import
web报表工具finereport常用函数的用法总结（数组函数）老A不折腾 finereport web报表函数总结
ADD2ARRAY ADDARRAY(array,insertArray, start):在数组第start个位置插入insertArray中的所有元素，再返回该数组。示例： ADDARRAY([3,4, 1, 5, 7], [23, 43, 22], 3)返回[3, 4, 23, 43, 22, 1, 5, 7]. ADDARRAY([3,4, 1, 5, 7], "测试&q
游戏服务器网络带宽负载计算墙头上一根草服务器
家庭所安装的4M，8M宽带。其中M是指，Mbits/S 其中要提前说明的是： 8bits = 1Byte 即8位等于1字节。我们硬盘大小50G。意思是50*1024M字节，约为 50000多字节。但是网宽是以“位”为单位的，所以，8Mbits就是1M字节。是容积体积的单位。 8Mbits/s后面的S是秒。8Mbits/s意思是每秒8M位，即每秒1M字节。我是在计算我们网络流量时想到的
我的spring学习笔记2-IoC（反向控制依赖注入） aijuans Spring 3 系列
IoC（反向控制依赖注入）这是Spring提出来了，这也是Spring一大特色。这里我不用多说，我们看Spring教程就可以了解。当然我们不用Spring也可以用IoC，下面我将介绍不用Spring的IoC。 IoC不是框架，她是java的技术，如今大多数轻量级的容器都会用到IoC技术。这里我就用一个例子来说明：如：程序中有 Mysql.calss 、Oracle.class 、SqlSe
高性能mysql 之选择存储引擎(一) annan211 mysql InnoDB MySQL引擎存储引擎
1 没有特殊情况，应尽可能使用InnoDB存储引擎。原因：InnoDB 和 MYIsAM 是mysql 最常用、使用最普遍的存储引擎。其中InnoDB是最重要、最广泛的存储引擎。她被设计用来处理大量的短期事务。短期事务大部分情况下是正常提交的，很少有回滚的情况。InnoDB的性能和自动崩溃恢复特性使得她在非事务型存储的需求中也非常流行，除非有非常
UDP网络编程百合不是茶 UDP编程局域网组播
UDP是基于无连接的,不可靠的传输与TCP/IP相反 UDP实现私聊,发送方式客户端,接受方式服务器 package netUDP_sc; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.Ine
JQuery对象的val()方法执行结果分析 bijian1013 JavaScript js jquery
JavaScript中，如果id对应的标签不存在（同理JAVA中，如果对象不存在），则调用它的方法会报错或抛异常。在实际开发中，发现JQuery在id对应的标签不存在时，调其val()方法不会报错，结果是undefined。
http请求测试实例（采用json-lib解析） bijian1013 json http
由于fastjson只支持JDK1.5版本，因些对于JDK1.4的项目，可以采用json-lib来解析JSON数据。如下是http请求的另外一种写法，仅供参考。 package com; import java.util.HashMap; import java.util.Map; import
【RPC框架Hessian四】Hessian与Spring集成 bit1129 hessian
在【RPC框架Hessian二】Hessian 对象序列化和反序列化一文中介绍了基于Hessian的RPC服务的实现步骤，在那里使用Hessian提供的API完成基于Hessian的RPC服务开发和客户端调用，本文使用Spring对Hessian的集成来实现Hessian的RPC调用。定义模型、接口和服务器端代码 |---Model &nb
【Mahout三】基于Mahout CBayes算法的20newsgroup流程分析 bit1129 Mahout
1.Mahout环境搭建 1.下载Mahout http://mirror.bit.edu.cn/apache/mahout/0.10.0/mahout-distribution-0.10.0.tar.gz 2.解压Mahout 3. 配置环境变量 vim /etc/profile export HADOOP_HOME=/home
nginx负载tomcat遇非80时的转发问题 ronin47
　　nginx负载后端容器是tomcat（其它容器如WAS,JBOSS暂没发现这个问题）非８０端口，遇到跳转异常问题。解决的思路是：$host:port 详细如下：　　该问题是最先发现的，由于之前对nginx不是特别的熟悉所以该问题是个入门级别的： ? 1 2 3 4 5
java-17-在一个字符串中找到第一个只出现一次的字符 bylijinnan java
public class FirstShowOnlyOnceElement { /**Q17.在一个字符串中找到第一个只出现一次的字符。如输入abaccdeff，则输出b * 1.int[] count:count[i]表示i对应字符出现的次数 * 2.将26个英文字母映射：a-z <--> 0-25 * 3.假设全部字母都是小写 */ pu
mongoDB 复制集开窍的石头 mongodb
mongo的复制集就像mysql的主从数据库，当你往其中的主复制集(primary)写数据的时候，副复制集(secondary)会自动同步主复制集(Primary)的数据,当主复制集挂掉以后其中的一个副复制集会自动成为主复制集。提供服务器的可用性。和防止当机问题 mo
[宇宙与天文]宇宙时代的经济学 comsci 经济
宇宙尺度的交通工具一般都体型巨大，造价高昂。。。。。在宇宙中进行航行，近程采用反作用力类型的发动机，需要消耗少量矿石燃料，中远程航行要采用量子或者聚变反应堆发动机，进行超空间跳跃，要消耗大量高纯度水晶体能源以目前地球上国家的经济发展水平来讲，
Git忽略文件 Cwind git
有很多文件不必使用git管理。例如Eclipse或其他IDE生成的项目文件，编译生成的各种目标或临时文件等。使用git status时，会在Untracked files里面看到这些文件列表，在一次需要添加的文件比较多时（使用git add . / git add -u），会把这些所有的未跟踪文件添加进索引。 ==== ==== ==== 一些牢骚
MySQL连接数据库的必须配置 dashuaifu mysql 连接数据库配置
MySQL连接数据库的必须配置 1.driverClass：com.mysql.jdbc.Driver 2.jdbcUrl：jdbc:mysql://localhost:3306/dbname 3.user：username 4.password：password 其中1是驱动名；2是url，这里的‘dbna
一生要养成的60个习惯 dcj3sjt126com 习惯
一生要养成的60个习惯第1篇让你更受大家欢迎的习惯 1 守时，不准时赴约,让别人等,会失去很多机会。如何做到： ①该起床时就起床， ②养成任何事情都提前15分钟的习惯。 ③带本可以随时阅读的书，如果早了就拿出来读读。 ④有条理，生活没条理最容易耽误时间。 ⑤提前计划：将重要和不重要的事情岔开。 ⑥今天就准备好明天要穿的衣服。 ⑦按时睡觉，这会让按时起床更容易。 2 注重
[介绍]Yii 是什么 dcj3sjt126com PHP yii2
Yii 是一个高性能，基于组件的 PHP 框架，用于快速开发现代 Web 应用程序。名字 Yii （读作易）在中文里有“极致简单与不断演变”两重含义，也可看作 Yes It Is! 的缩写。 Yii 最适合做什么？ Yii 是一个通用的 Web 编程框架，即可以用于开发各种用 PHP 构建的 Web 应用。因为基于组件的框架结构和设计精巧的缓存支持，它特别适合开发大型应
Linux SSH常用总结 eksliang linux ssh SSHD
转载请出自出处：http://eksliang.iteye.com/blog/2186931 一、连接到远程主机格式： ssh name@remoteserver 例如： ssh [email protected] 二、连接到远程主机指定的端口格式： ssh name@remoteserver -p 22 例如： ssh i
快速上传头像到服务端工具类FaceUtil gundumw100 android
快速迭代用 import java.io.DataOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOExceptio
jQuery入门之怎么使用 ini JavaScript html jquery Web css
jQuery的强大我何问起（个人主页：hovertree.com）就不用多说了，那么怎么使用jQuery呢？首先，下载jquery。下载地址：http://hovertree.com/hvtart/bjae/b8627323101a4994.htm，一个是压缩版本，一个是未压缩版本，如果在开发测试阶段，可以使用未压缩版本，实际应用一般使用压缩版本(min)。然后就在页面上引用。
带filter的hbase查询优化 kane_xie 查询优化 hbase RandomRowFilter
问题描述 hbase scan数据缓慢，server端出现LeaseException。hbase写入缓慢。问题原因直接原因是： hbase client端每次和regionserver交互的时候，都会在服务器端生成一个Lease,Lease的有效期由参数hbase.regionserver.lease.period确定。如果hbase scan需
java设计模式-单例模式 men4661273 java 单例枚举反射 IOC
单例模式1，饿汉模式 //饿汉式单例类.在类初始化时，已经自行实例化 public class Singleton1 { //私有的默认构造函数 private Singleton1() {} //已经自行实例化 private static final Singleton1 singl
mongodb 查询某一天所有信息的3种方法，根据日期查询 qiaolevip 每天进步一点点学习永无止境 mongodb 纵观千象
// mongodb的查询真让人难以琢磨，就查询单天信息，都需要花费一番功夫才行。 // 第一种方式： coll.aggregate([ {$project:{sendDate: {$substr: ['$sendTime', 0, 10]}, sendTime: 1, content:1}}, {$match:{sendDate: '2015-
二维数组转换成JSON tangqi609567707 java 二维数组 json
原文出处：http://blog.csdn.net/springsen/article/details/7833596 public class Demo { public static void main(String[] args) { String[][] blogL
erlang supervisor wudixiaotie erlang
定义supervisor时，如果是监控celuesimple_one_for_one则删除children的时候就用supervisor:terminate_child (SupModuleName, ChildPid)，如果shutdown策略选择的是brutal_kill，那么supervisor会调用exit(ChildPid, kill)，这样的话如果Child的behavior是gen_

基于生产-消费者模式的任务异步线程池设计与实现

评论

你可能感兴趣的:(线程)