多线程设计模式-流水线模式（Work-Thread）

Work-Thread设计模式

使用场景：流水线线程工作模式，产品零件经过几道工序，变成产品

请求任务

package com.ln.concurrent.chapter17;

/**
 * @ProjectName: java-concurrency
 * @Package: com.ln.concurrent.chapter17
 * @Name:Request
 * @Author:linianest
 * @CreateTime:2021/1/4 14:05
 * @version:1.0
 * @Description TODO: 请求任务
 */
public class Request {
    private final String name;
    private final int number;

    public Request(final String name,final int number) {
        this.name = name;
        this.number = number;
    }

    public void exeute(){
        System.out.println(Thread.currentThread().getName()+" executed "+this);
    }
    @Override
    public String toString() {
        return "Request=> NO. "+number+" Name. "+name;
    }
}

定义流水线(环形队列)

package com.ln.concurrent.chapter17;

import java.util.Arrays;

/**
 * @ProjectName: java-concurrency
 * @Package: com.ln.concurrent.chapter17
 * @Name:Channel
 * @Author:linianest
 * @CreateTime:2021/1/4 14:05
 * @version:1.0
 * @Description TODO: 定义流水线(环形队列)
 */
public class Channel {
    // 队列大小
    private final static int MAX_REQUEST = 100;
    // 请求队列
    private final Request[] requestQueue;
    // 队列头
    private int head;
    // 队列尾
    private int tail;
    // 计数器
    private int count;

    private final WorkerThread[] workerPool;

    public Channel(int workers) {
        this.requestQueue = new Request[MAX_REQUEST];
        this.head = 0;
        this.tail = 0;
        this.count = 0;
        this.workerPool = new WorkerThread[workers];
        this.init();
    }

    private void init() {
        for (int i = 0; i < workerPool.length; i++) {
            workerPool[i] = new WorkerThread("Worker-" + i, this);
        }
    }

    /**
     * push switch to start all of worker to worker
     */
    public void startWorker() {
        Arrays.asList(workerPool).forEach(WorkerThread::start);
    }

    public synchronized void put(Request request) {
        while (count >= requestQueue.length) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.requestQueue[tail] = request;
        this.tail = (tail + 1) % requestQueue.length;
        this.count++;
        this.notifyAll();
    }

    public synchronized Request take() {
        while (count <= 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        final Request request = this.requestQueue[head];
        this.head = (this.head + 1) % this.requestQueue.length;
        this.count--;
        this.notifyAll();
        return request;
    }

}

装配工人

package com.ln.concurrent.chapter17;

import java.util.Random;

/**
 * @ProjectName: java-concurrency
 * @Package: com.ln.concurrent.chapter17
 * @Name:TransportThread
 * @Author:linianest
 * @CreateTime:2021/1/4 14:27
 * @version:1.0
 * @Description TODO: 装配工人
 */
public class TransportThread extends Thread{
    private final Channel channel;
    private static final Random random = new Random(System.currentTimeMillis());

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

    @Override
    public void run() {
        try {
            for (int i = 0; true ; i++) {
                Request request = new Request(getName(),i);
                this.channel.put(request);
                Thread.sleep(random.nextInt(1_000));
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

工作线程，从流水线取出工人装配的产品

package com.ln.concurrent.chapter17;

import java.util.Random;

/**
 * @ProjectName: java-concurrency
 * @Package: com.ln.concurrent.chapter17
 * @Name:WorkerThread
 * @Author:linianest
 * @CreateTime:2021/1/4 14:08
 * @version:1.0
 * @Description TODO: 工作线程，从流水线取出工人装配的产品
 */
public class WorkerThread extends Thread {
    private final Channel channel;
    private static final Random random = new Random(System.currentTimeMillis());
    public WorkerThread(String name, Channel channel) {
        super(name);
        this.channel = channel;
    }

    @Override
    public void run() {
        while (true){
            channel.take().exeute();
            try {
                Thread.sleep(random.nextInt(1_000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

客户端

package com.ln.concurrent.chapter17;

/**
 * @ProjectName: java-concurrency
 * @Package: com.ln.concurrent.chapter17
 * @Name:WorkerClient
 * @Author:linianest
 * @CreateTime:2021/1/4 14:36
 * @version:1.0
 * @Description TODO: 客户端
 */
public class WorkerClient {
    public static void main(String[] args) {
        final Channel channel = new Channel(5);
        channel.startWorker();

        new TransportThread("Alex",channel).start();
        new TransportThread("Jack",channel).start();
        new TransportThread("William",channel).start();
    }
}