开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 搜索引擎 > 查看源码
WorkerThread.java
资源名称：jspider-src-0.5.0-dev.zip　[点击查看]
上传用户：qing5858
上传日期：2015-10-27
资源大小：6056k
文件大小：4k
源码类别：

搜索引擎

开发平台：

Java

WorkerThread.java：源码内容
  1. package net.javacoding.jspider.core.threading;
  4. import net.javacoding.jspider.core.logging.LogFactory;
  5. import net.javacoding.jspider.core.logging.Log;
  6. import net.javacoding.jspider.core.task.WorkerTask;
  9. /**
  10.  * Implementation of  a Worker Thread.
  11.  * This thread will accept WorkerTasks and execute them.
  12.  *
  13.  * $Id: WorkerThread.java,v 1.11 2003/04/02 20:55:26 vanrogu Exp $
  14.  *
  15.  * @author G黱ther Van Roey
  16.  */
  17. class WorkerThread extends Thread {
  19.     public static final int WORKERTHREAD_IDLE = 0;
  20.     public static final int WORKERTHREAD_BLOCKED = 1;
  21.     public static final int WORKERTHREAD_BUSY = 2;
  24.     /** the current state of this thread - idle, blocked, or busy. */
  25.     protected int state;
  27.     /** Whether this instance is assigned a task. */
  28.     protected boolean assigned;
  30.     /** Whether we should keep alive this thread. */
  31.     protected boolean running;
  33.     /** Threadpool this worker is part of. */
  34.     protected WorkerThreadPool stp;
  36.     /** Task this worker is assigned to. */
  37.     protected WorkerTask task;
  39.     /**
  40.      * Public constructor.
  41.      * @param stp thread pool this worker is part of
  42.      * @param name name of the thread
  43.      * @param i index in the pool
  44.      */
  45.     public WorkerThread(WorkerThreadPool stp, String name, int i) {
  46.         super(stp, name + " " + i);
  47.         this.stp = stp;
  48.         running = false;
  49.         assigned = false;
  50.         state = WORKERTHREAD_IDLE;
  51.     }
  53.     /**
  54.      * Tests whether this worker thread instance can be assigned a task.
  55.      * @return whether we're capable of handling a task.
  56.      */
  57.     public boolean isAvailable() {
  58.         return (!assigned) && running;
  59.     }
  61.     /**
  62.      * Determines whether we're occupied.
  63.      * @return boolean value representing our occupation
  64.      */
  65.     public boolean isOccupied() {
  66.         return assigned;
  67.     }
  69.     /**
  70.      * Method that allows the threadPool to assign the worker a Task.
  71.      * @param task WorkerTask to be executed.
  72.      */
  73.     public synchronized void assign(WorkerTask task) {
  74.         if ( !running ) {
  75.             //SHOULDN'T HAPPEN WITHOUT BUGS
  76.             throw new RuntimeException("THREAD NOT RUNNING, CANNOT ASSIGN TASK !!!");
  77.         }
  78.         if (assigned) {
  79.             //SHOULDN'T HAPPEN WITHOUT BUGS
  80.             throw new RuntimeException("THREAD ALREADY ASSIGNED !!!");
  81.         }
  82.         this.task = task;
  83.         assigned = true;
  84.         notify();
  85.     }
  87.     /**
  88.      * Tells this thread not to accept any new tasks.
  89.      */
  90.     public synchronized void stopRunning() {
  91.         if ( ! running ) {
  92.             throw new RuntimeException ("THREAD NOT RUNNING - CANNOT STOP !");
  93.         }
  94.         if ( assigned ) {
  95.             try {
  96.                 this.wait();
  97.             } catch (InterruptedException e) {
  98.                 Thread.currentThread().interrupt();
  99.             }
  100.         }
  101.         running = false;
  102.         notify();
  103.     }
  105.     /**
  106.      * Returns the state of this worker thread (idle, blocked or busy).
  107.      * @return
  108.      */
  109.     public int getState ( ) {
  110.         return state;
  111.     }
  113.     /**
  114.      * Thread's overridden run method.
  115.      */
  116.     public synchronized void run() {
  117.         running = true;
  119.         Log log = LogFactory.getLog(WorkerThread.class);
  120.         log.debug("Worker thread (" + this.getName() + ") born");
  122.         synchronized (stp) {
  123.             stp.notify();
  124.         }
  126.         while (running) {
  127.             if (assigned) {
  128.                 state = WORKERTHREAD_BLOCKED;
  129.                 task.prepare();
  130.                 state = WORKERTHREAD_BUSY;
  131.                 try {
  132.                     task.execute();
  133.                     task.tearDown();
  134.                 } catch (Exception e) {
  135.                     log.fatal("PANIC! Task " + task + " threw an excpetion!", e);
  136.                     System.exit(1);
  137.                 }
  139.                 synchronized (stp) {
  140.                     assigned = false;
  141.                     task = null;
  142.                     state = WORKERTHREAD_IDLE;
  143.                     stp.notify();
  144.                     this.notify(); // if some thread is blocked in stopRunning();
  145.                 }
  147.             }
  148.             try {
  149.                 wait();
  150.             } catch (InterruptedException e) {
  151.                 Thread.currentThread().interrupt();
  152.             }
  153.         }
  155.         /* notify the thread pool that we died. */
  156.         log.debug("Worker thread (" + this.getName() + ") dying");
  157.     }
  158. }