import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.function.Consumer;
public class MutilProcessor<E> {
LinkedBlockingQueue<E> QUEUE = new LinkedBlockingQueue<E>(100);
List<Thread> THREAD_LIST = new ArrayList<>();
volatile boolean isReading = true;
volatile boolean isEnd = false;
volatile CountDownLatch countDown;
public MutilProcessor<E> read(Collection<E> collection) {
isReading = true;
collection.stream().forEach(e -> {
try {
QUEUE.put(e);
} catch (InterruptedException e1) {
}
});
isReading = false;
return this;
}
public <X> MutilProcessor<E> addThreadNum(int threadNum, Consumer<E> consumer) {
if (THREAD_LIST.size() < threadNum) {
int add = threadNum - THREAD_LIST.size();
for (int i = 0; i < add; i++) {
Thread thread = new Thread(() -> doing(consumer));
thread.start();
THREAD_LIST.add(thread);
}
}
countDown = new CountDownLatch(threadNum);
return this;
}
private <X> void doing(Consumer<E> consumer) {
while (true) {
E take = QUEUE.poll();
if (take != null) {
try {
consumer.accept(take);
} catch (Exception e) {
e.printStackTrace();
}
} else {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (QUEUE.isEmpty() && !isEnd) {
break;
}
}
}
countDown.countDown();
}
public void end() {
while (isReading) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
}
}
isEnd = false;
try {
countDown.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static <E> MutilProcessor<E> getInstance() {
return new MutilProcessor<E>();
}
}
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class MutiString extends MutilProcessor<String> {
@SuppressWarnings("unchecked")
public static MutiString getInstance() {
return new MutiString();
}
public MutiString readFile(File filePath) {
new Thread(() -> {
try {
isReading = true;
BufferedReader csvReader = new BufferedReader(new InputStreamReader(new FileInputStream(filePath), "utf-8"));
String records = csvReader.readLine();
while (records != null) {
try {
QUEUE.put(records);
} catch (InterruptedException e) {
e.printStackTrace();
}
records = csvReader.readLine();
}
csvReader.close();
isReading = false;
} catch (IOException e) {
e.printStackTrace();
}
}).start();
return this;
}
public MutiString readFile(String filePath) {
readFile(new File(filePath));
return this;
}
}
import java.util.Arrays;
public class ThreadTest {
public static void main(String[] args) {
new MutilProcessor<Integer>().read(Arrays.asList(1, 2, 3, 4, 5)).addThreadNum(1, ThreadTest::print).end();
}
public static void print(Integer i) {
System.out.println(i);
}
}
实现思路:
一个线程将数据填入对列中,另外几个线程取对列中的数据,对于具体执行的方法,如果有返回值使用Function(没有用到,所以未实现),没有返回值用Consumer,这样通过一行代码就可以实现了。
应用场景,
1.for循环里面执行的速度很慢,数据很多的情况。
2.读取很大的文件,每一行为一条数据,需要多线程处理的情况。