jdk5.0 多线程学习笔记（五）-优快云博客

今天，我们来学学worker模式，大家也好对jdk5.0的线程池有一个更好的理解。

先来看看代码：

public class Main {
    public static void main(String[] args) {
        Channel channel = new Channel(5);   // 工人线程的數量,即线程池内的线程数目
        channel.startWorkers();//启动线程池内的线程
        new ClientThread("Alice", channel).start();//发送请求的线程，相当于向队列加入请求
        new ClientThread("Bobby", channel).start();
        new ClientThread("Chris", channel).start();
    }
}

再来看看发送请求的client代码：

public class ClientThread extends Thread {
	private final Channel channel;//相当于线程池

	private static final Random random = new Random();

	public ClientThread(String name, Channel channel) {
		super(name);
		this.channel = channel;
	}

	public void run() {
		try {
			int i = 0;
			Request request = new Request(getName(), i);//生成请求
			channel.putRequest(request);//向队列中放入请求，也即把请求传给线程池
			Thread.sleep(random.nextInt(1000));
		} catch (InterruptedException e) {
		}
	}
}

clientthread建立请求，并把请求传给了channel，下面来看看channel类（相当于线程池类）

public class Channel {
    private static final int MAX_REQUEST = 100;
    private final Request[] requestQueue;//存放请求的队列
    private int tail;  // 下一个putRequest的地方
    private int head;  // 下一个takeRequest的地方
    private int count; // Request的数量

    private final WorkerThread[] threadPool;

    public Channel(int threads) {
        this.requestQueue = new Request[MAX_REQUEST];
        this.head = 0;
        this.tail = 0;
        this.count = 0;

        threadPool = new WorkerThread[threads];
        for (int i = 0; i < threadPool.length; i++) {
            threadPool[i] = new WorkerThread("Worker-" + i, this);//生成线程池中的线程
        }
    }
    public void startWorkers() {
        for (int i = 0; i < threadPool.length; i++) {
            threadPool[i].start();//启动线程池中的线程
        }
    }
    public synchronized void putRequest(Request request) {//向队列中存入请求
        while (count >= requestQueue.length) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
        requestQueue[tail] = request;
        tail = (tail + 1) % requestQueue.length;
        count++;
        notifyAll();
    }
    public synchronized Request takeRequest() {//从队列取出请求
        while (count <= 0) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
        Request request = requestQueue[head];
        head = (head + 1) % requestQueue.length;
        count--;
        notifyAll();
        return request;
    }
}

channel类把传给他的请求放入队列中，等待worker去取请求，下面看看worker（即工作线程，线程池中已经初始话好的线程）

public class WorkerThread extends Thread {
    private final Channel channel;
    public WorkerThread(String name, Channel channel) {
        super(name);
        this.channel = channel;
    }
    public void run() {
        while (true) {
            Request request = channel.takeRequest();//取出请求
            request.execute();//处理请求
        }
    }
}

在工作线程中会从线程池的队列里取出请求，并对请求进行处理。这里的workerthread相当于背景线程，他一直都在运行，当有请求的时候，他就会进行处理，这里处理请求的线程是已经存在在channel（线程池里的线程），他不会因为请求的增加而增加（这是本例中的情况），不会来一个请求就新建立一个线程，节省了资源。

再看看请求的代码：

public class Request {
    private final String name; //  委托者
    private final int number;  // 请求编号
    private static final Random random = new Random();
    public Request(String name, int number) {
        this.name = name;
        this.number = number;
    }
    public void execute() {//执行请求
        System.out.println(Thread.currentThread().getName() + " executes " + this);
        try {
            Thread.sleep(random.nextInt(1000));
        } catch (InterruptedException e) {
        }
    }
    public String toString() {
        return "[ Request from " + name + " No." + number + " ]";
    }
}

参考（多线程四）中所写的 ExecutorService，其就相当于channel，即线程池。至于其实现当然要比channel复杂多了，channel只是举个例子。而WorkerThread可不是工作线程，他相当于发送到channel的请求，也就是request，当执行代码：tpes.execute(workers[i]);时，相当于向线程池加入一个请求，而WorkerThread中的run则相当于request中的execute，这也是当执行tpes.execute(workers[i]);时，并不会产生新的线程的原因。（多线程四）中的写法是让人有些迷糊的。ExecutorService中产生的背景线程（相当于本篇的WorkerThread ）我们是看不到的。

jdk5中的多线程还有很多需要进一步学习，其实现也反应了多线程的设计模式。本篇的worker模式只是其中的一种。