Thread sample code

1. create a tread pool manager provide a thread pool.

package com.tian.jack.test;

import java.util.Vector;

public class ThreadPoolManager {
   
    @SuppressWarnings("unused")
    private int maxThread;
    @SuppressWarnings("unchecked")
    public Vector vector;

    public void setMaxThread(int threadCount) {
        maxThread = threadCount;
    }
   
    public ThreadPoolManager() {}

    @SuppressWarnings("unchecked")
    public ThreadPoolManager(int threadCount) {
        setMaxThread(threadCount);
        System.out.println("Starting thread pool...");
        vector = new Vector();
        for (int i = 1; i <= 10; i++) {
            SimpleThread thread = new SimpleThread(i);
            vector.addElement(thread);
            thread.start();
        }
    }

    public void process(String argument) {
        int i;
        for (i = 0; i < vector.size(); i++) {
            SimpleThread currentThread = (SimpleThread) vector.elementAt(i);
            if (!currentThread.isRunning()) {
                System.out.println("Thread " + (i + 1) + " is processing:"
                        + argument);
                currentThread.setArgument(argument);
                currentThread.setRunning(true);
                return;
            }
        }
        if (i == vector.size()) {
            System.out.println("pool is full, try in another time.");
        }
    }
}

 

Test this pool:

package com.tian.jack.test;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class TestThreadPool {
    public static void main(String[] args) {
        try {
            BufferedReader br = new BufferedReader(new InputStreamReader(
                    System.in));
            String input;
            ThreadPoolManager manager = new ThreadPoolManager(10);
            while ((input = br.readLine()) != null) {
                manager.process(input);
            }
        } catch (IOException e) {
        }
    }
}

 

run this test, and input some string, the pool will provide thread from thread pool for you.

 

2. a retry queue test sample

 

package com.tian.jack.test;

public class _Doing {

    /**
     * @param args
     */
    private boolean isSuccess = false;

    public void _execute() throws Exception {
        isSuccess = false;
        _doSomething(isSuccess);
    }

    public void _doSomething(boolean isSuccess) throws Exception {
        if (isSuccess) {
            System.out.println("Done...");
        } else {
            throw new Exception("do something failure...");
        }
    }

    public boolean isSuccess() {
        return isSuccess;
    }

    public void setSuccess(boolean isSuccess) {
        this.isSuccess = isSuccess;
    }

}

----------------------------------------------------------------------
package com.tian.jack.test;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class _RetryQueue extends Thread{
   
    private static final Logger logger = LoggerFactory.getLogger(_RetryQueue.class);
   
    private boolean terminal = false;
    //5s
    private int retryInterval = 5000;
   
    private int retries = 3;
   
    private static final Map<String, Integer> queue = new ConcurrentHashMap<String, Integer>();
   
    @Override
    public void run() {
        while(!terminal){
           
            System.out.println("");
            logger.debug("Thread START...");
            if(queue.size() <= 0){
                logger.debug("Thread STOP...");
                throw new RuntimeException("retry time is over, Thread STOPPED!");
            }
           
            try{
                Thread.sleep(retryInterval);
            }catch(InterruptedException e){   
            }
           
            for(String str : queue.keySet()){
                int numberRetries = queue.get(str);
                if(numberRetries < retries){
                   
                    try{
                        logger.debug("retry times {} ", numberRetries);
                        _Doing _doing = new _Doing();
                        _doing._execute();
                        queue.remove(str);
                        logger.debug("retry successfully....!!!");
                    }catch(Exception e){
                        queue.put(str, numberRetries+1);
                    }
                   
                }else{
                    logger.debug("retry times is over...force STOP it!!!!/n");
                    queue.remove(str);
                }
            }
        }
    }

    public static Map<String, Integer> getQueue() {
        return queue;
    }

}

-------------------------------------------------

package com.tian.jack.test;

public class _Test {

    /**
     * @param args
     */
    public static void main(String[] args) {
        _Doing _doing = new _Doing();
        try{
            _doing._execute();
        }catch(Exception e){
            _RetryQueue rq = new _RetryQueue();
            _RetryQueue.getQueue().put("sender1", 1);
            rq.start();
        }
       
    }

}

 

end...