Java--线程池

package util;

public abstract class Runnable implements java.lang.Runnable
{
    private int priority;

    public Runnable()
    {
        this.priority = 0;
    }

    public int getPriority()
    {
        return priority;
    }

    public void setPriority(int priority)
    {
        this.priority = priority;
    }

    public static void main(String[] args)
    {
        String libname = System.mapLibraryName("");
    }
}

import java.util.Timer;
import java.util.TimerTask;

/**
 * 被观察者，每秒钟通知观察者检查任务
 * 
 * @author guoxiaoming
 * 
 */
public class TimerObserver extends java.util.Observable
{
    public static TimerObserver instance = new TimerObserver();

    public static long now = System.currentTimeMillis();

    public static Timer timer;

    // 每秒钟都会通知观察者检查自己的任务是否可以开始执行
    public TimerObserver()
    {
        timer = new Timer("schedule-task");
        timer.schedule(new TimerTask()
        {
            public void run()
            {
                now = scheduledExecutionTime();
                instance.setChanged();
                instance.notifyObservers();
            }
        }, 0, 1000);
    }
}

import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;
import java.util.Observable;
import java.util.Observer;
import java.util.Set;
import java.util.SortedMap;
import java.util.TreeMap;

import util.Runnable;

/**
 * 观察者对象，保存着任务集合，被观察者每1s钟通知观察者检查任务 确实也可能出现后添加的任务可能比先添加的任务先执行
 * 
 * @author guoxiaoming
 * 
 */
public class TimerTask implements Observer
{
    private class TaskPair
    {
        private Runnable runnable;

        private long waitSeconds;

        public TaskPair(Runnable runnable, long waitSeconds)
        {
            this.runnable = runnable;
            this.waitSeconds = waitSeconds;
        }
    }

    public long elapse = 0;

    public static SortedMap<Long, LinkedList<TaskPair>> taskList = Collections
            .synchronizedSortedMap(new TreeMap<Long, LinkedList<TaskPair>>());

    public TimerTask()
    {
        TimerObserver.instance.addObserver(this);
    }

    @Override
    public synchronized void update(Observable o, Object arg)
    {
        Set<Map.Entry<Long, LinkedList<TaskPair>>> entrySet = taskList
                .entrySet();
        Iterator<Map.Entry<Long, LinkedList<TaskPair>>> iter = entrySet
                .iterator();
        elapse++;
        while (iter.hasNext())
        {
            Map.Entry<Long, LinkedList<TaskPair>> entry = iter.next();
            LinkedList<TaskPair> linkedTask = entry.getValue();

            Iterator<TaskPair> itertask = linkedTask.iterator();
            while (itertask.hasNext())
            {
                TaskPair task = itertask.next();
                if (task.waitSeconds > elapse)
                {
                    break;
                }
                ThreadPool.addTask(task.runnable);
                itertask.remove();
            }
            if (linkedTask.size() == 0)// linkedTask.isEmpty()
            {
                iter.remove();
            }
        }
    }

    // 其实两个方法可以合并成一个方法的 每个LinkedList当中的任务都是后添加的在前面
    public synchronized  void addTask(Runnable runnable, long waitSeconds)
    {
        LinkedList<TaskPair> ll = taskList.get(waitSeconds);
        if (ll == null)
        {   
            ll = new LinkedList<TaskPair>();
            taskList.put(waitSeconds,ll);
            
        }
        synchronized (ll)
        {
            // 此处应该使用addLast而不是addFirst
            ll.addLast(new TaskPair(runnable, waitSeconds + elapse));
        }
    }
}

import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap;
import java.util.Map.Entry;

import util.Runnable;

//线程池
public class ThreadPool implements java.lang.Runnable
{
    // key 优先级 value 线程列表
    private static SortedMap<Integer, LinkedList<Runnable>> tasks = Collections.synchronizedSortedMap(new TreeMap<Integer, LinkedList<Runnable>>());

    private int priority;

    private static int task_count;

    private static Object task_count_locker = new Object();

    private static long time_lastAdd;

    // 记录各个优先级线程管理的任务数，本身管理线程也算是一个任务
    private static SortedMap<Integer, Integer> count = new TreeMap<Integer, Integer>();

    private ThreadPool(int priority)
    {
        this.priority = priority;
        synchronized (count)
        {
            Integer c = count.get(priority);
            count.put(priority, c == null ? 1 : c.intValue() + 1);
        }
    }

    @Override
    public void run()
    {
        for (;;)
        {
            try
            {
                Runnable r = null;
                LinkedList<Runnable> ll = tasks.get(priority);
                synchronized (ll)
                {
                    if (ll.isEmpty())
                    {
                        ll.wait();
                    }
                    r = ll.removeLast();
                    synchronized (task_count_locker)
                    {
                        task_count--;
                    }
                }
                r.run();
            }
            catch(Exception ex)
            {
                ex.printStackTrace();
            }

        }
    }

    // 添加新的线程
    public static void addThread(int priority)
    {
        if (tasks.get(priority) == null)
        {
            tasks.put(priority, new LinkedList<Runnable>());
            new Thread(new ThreadPool(priority), "thread---" + priority).start();

        }
    }

    // 添加新的任务 静态方法中只能使用静态变量 非静态方法中可以使用静态变量
    public static void addTask(Runnable runnable)
    {
        int prior = runnable.getPriority();
        LinkedList<Runnable> ll = tasks.get(prior);
        if (ll == null)
        {
            System.out.println("no match priority thread");
            return;
        }
        synchronized (ll)
        {
            synchronized (task_count_locker)
            {
                task_count++;
            }
            ll.add(runnable);// 其实addFirst还是add区别不大
            time_lastAdd = System.currentTimeMillis();
            ll.notify();
        }
    }

    // 得到一个映射拷贝
    public static Map<Integer, Integer> getTaskCounts()
    {
        SortedMap<Integer, Integer> map = new TreeMap<Integer, Integer>();
        synchronized (count)
        {
            for (Iterator<Integer> iter = tasks.keySet().iterator(); iter.hasNext();)
            {
                Integer prior = iter.next();
                map.put(prior, tasks.get(prior).size());
            }
            // 或者
            for (Entry<Integer, LinkedList<Runnable>> iter : tasks.entrySet())
            {
                map.put(iter.getKey(), iter.getValue().size());
            }
            // 再或者使用繁琐的while循环
            // Set<Map.Entry<Integer,LinkedList<Runnable>>>
        }
        return map;
    }

    public static long getTaskTotal()
    {
        synchronized (task_count_locker)
        {
            return task_count;
        }
    }

}

import util.Runnable;

public class MainTest
{
    public static void main(String[] args) throws InterruptedException
    {
        // 添加1-10 10个优先级的管理线程
        for (int i = 1; i <= 10; i++)
        {
            ThreadPool.addThread(i);
        }
        TimerTask timerTask = new TimerTask();
        for (int i = 1; i <= 10; i++)
        {
            timerTask.addTask(new RunnableTask(i), i);
        }
    }

    static class RunnableTask extends Runnable
    {

        public RunnableTask(int priority)
        {
            super.setPriority(priority);
        }

        @Override
        public void run()
        {
            int begin = (super.getPriority() - 1) * 10;
            int end = super.getPriority() * 10;
            for (int i = begin; i <= end; i++)
            {
                System.out.print(i + " ");
            }
            System.out.println();
        }
    }
}

0 1 2 3 4 5 6 7 8 9 10 
10 11 12 13 14 15 16 17 18 19 20 
20 21 22 23 24 25 26 27 28 29 30 
30 31 32 33 34 35 36 37 38 39 40 
40 41 42 43 44 45 46 47 48 49 50 
50 51 52 53 54 55 56 57 58 59 60 
60 61 62 63 64 65 66 67 68 69 70 
70 71 72 73 74 75 76 77 78 79 80 
80 81 82 83 84 85 86 87 88 89 90 
90 91 92 93 94 95 96 97 98 99 100