实现简单的线程池

public class Pthread extends Thread {

	private ThreadPool pool;  
    private volatile boolean isShutdown;  
    private Runnable target;  
  
    public Pthread(Runnable task, ThreadPool pool) {  
        this.target = task;  
        this.pool = pool;  
        isShutdown = false;  
    }  
  
    @Override  
    public void run() {  
        while (!isShutdown) {  
            if (target != null) {  
                target.run();  
            }  
            try {  
            	//空闲线程对象放入池中
            	
                pool.putThread(this); 
                //System.out.println(pool.getThreadCount());
                // 线程执行完任务，会在wait处阻塞，直到 setTarget或者 shutdown 调用notifyAll  
                synchronized (this) {  
                    wait();  
                }  
            } catch (InterruptedException e) {  
  
            }  
        }  
    }  
  
    // 每当设置任务或关闭时会唤醒run方法  
    synchronized public void setTarget(Runnable r) {  
        this.target = r;  
        notifyAll();  
    }  
  
    synchronized public void shutdown() {  
        isShutdown = true;  
        notifyAll();  
    }  
 
}

public class ThreadPool {

	//使用单例模式创建线程池  
    private static ThreadPool pool;  
  
    private final List<Pthread> threads;  
    private volatile boolean isShutdown; 
  
    // 在线程中调用，用来将自己加入线程池中  
    synchronized public void putThread(Pthread t) {  
        if (!isShutdown) {  
            threads.add(t);  
        } else {  
            t.shutdown();  
        }  
    }  
  
    // 客户端用来执行自己的一项任务  
    synchronized public void start(Runnable task) {  
        if (!isShutdown) { 
        	//只有闲置的线程才被放入threadpool中
            if (threads.size() < 1) {  
                new Pthread(task, pool).start();  
            } else { 
            	//从池中取出闲置线程,赋予其任务,任务执行结束后再次放入threadpool中
                Pthread p = threads.remove(0);  
                p.setTarget(task);  
            }  
        }  
    }  
  
    //初始化一个大小为5的线程池数组  
    synchronized public static ThreadPool getThreadPool() {  
        if (pool == null) {  
            pool = new ThreadPool(5);  
        }  
        return pool;  
    }  
  
    public ThreadPool(int poolSize) {  
        threads = new Vector<Pthread>(poolSize);  
        isShutdown = false;
    }  
  
    //如果关闭线程池，需要将所有线程也关闭  
    synchronized public void shutdown() {  
        for(Pthread p : threads)  
            p.shutdown();  
        threads.clear();  
        isShutdown = true;  
    }  
      
    public int getThreadCount(){  
        return threads.size();  
    }  
}  

public class TestMain {

	public static void main(String[] args) throws InterruptedException {  
        ThreadPool pool = ThreadPool.getThreadPool();
        Thread.sleep(1500);
        Runnable r = new Runnable() {  
            public void run() {  
                System.out.println(Thread.currentThread().getName());  
//                try {  
//                    Thread.sleep(1000);  
//                } catch (InterruptedException e) {  
//                    e.printStackTrace();  
//                }  
            }  
        };  
        for (int i = 0; i < 1000; i++)  
            pool.start(r);  
        Thread.sleep(1500);  
        System.out.println(pool.getThreadCount());  
//        pool.shutdown();  
//        Thread.sleep(1000);  
//        System.out.println(pool.getThreadCount());  
    }  
}

1.线程本身就是一个对象, 上述代码中有一步先在自己的线程中获取自身线程的对象锁, 然后执行wait方法, 注意理解

2.继承自thread的线程实例化后执行start方法, 启动线程

实现runnable接口的线程实例化后在实例化一个thread对象并作为其参数, 执行start方法, 启动线程

3 线程池

1) 实现一个普通的对象池

2) 实现一个永不退出的线程, 实现方式:在润run方法中使用while进行死循环

3) 永不退出的线程在执行完当前任务后, 将自身放入到线程池中等到有新任务时被取出

4) 永不退出线程 执行wait方法, 释放资源占用, 等待新的任务加入, 然后再被唤醒继续执行新的任务

5) 新的任务加入到线程池时, 从线程池中获取一个限制的永不退出线程, 把新的任务交给取出的永不退出线程, 当有新的任务加入到永不退出线程时, 永不退出线程被唤醒, 然后来执行新的任务

4. 池化技术的原理: 对象使用结束后把对象内存地址保存, 保证不被gc回收, 下次调用该对象时能正确寻址