import java.util.concurrent.BlockingQueue;
public class Consumer implements Runnable{
private final BlockingQueue queue;
public Consumer(BlockingQueue q) {
queue = q;
}
public void run() {
try {
for(int i=0;i<100;i++){
consume(queue.take());
}
} catch (InterruptedException ex) {}
}
void consume(Object x) {
System.out.println("cousume"+x.toString());
}
}
import java.util.concurrent.BlockingQueue;
public class Producer implements Runnable{
private final BlockingQueue queue;
public Producer(BlockingQueue q)
{
queue = q;
}
public void run() {
try {
for(int i=0;i<100;i++){
queue.put(produce());
}
} catch (InterruptedException ex) {}
}
String produce() {
String temp=""+(char)('A'+(int)(Math.random()*26));
System.out.println("produce"+temp);
return temp;
}
}
//生产者 消费者 模式 ArrayBlockingQueue LinkedBlockingQueue 阻塞队列
BlockingQueue<String> queue1=new LinkedBlockingQueue<String>(5);
//
Producer p=new Producer(queue1);
Consumer c1=new Consumer(queue1);
Consumer c2=new Consumer(queue1);
new Thread(p).start();
new Thread(c1).start();
new Thread(c2).start();
List<Callable<Long>> callList = new ArrayList<Callable<Long>>();add一些Callable的实现类,多线程求和计算。
int threadCounts = 19;// 使用的线程数
long sum = 0;
ExecutorService exec1 = Executors.newFixedThreadPool(threadCounts);
List<Callable<Long>> callList = new ArrayList<Callable<Long>>();
// 生成很大的List
List<Integer> list = new ArrayList<Integer>();
for (int i = 0; i <= 1000000; i++) {
list.add(i);
}
int len = list.size() / threadCounts;// 平均分割List
// List中的数量没有线程数多(很少存在)
if (len == 0) {
threadCounts = list.size();// 采用一个线程处理List中的一个元素
len = list.size() / threadCounts;// 重新平均分割List
}
for (int i = 0; i < threadCounts; i++) {
final List<Integer> subList;
if (i == threadCounts - 1) {
subList = list.subList(i * len, list.size());
} else {
subList = list.subList(i * len,
len * (i + 1) > list.size() ? list.size() : len
* (i + 1));
}
// 采用匿名内部类实现
callList.add(new Callable<Long>() {
public Long call() throws Exception {
long subSum = 0L;
for (Integer i : subList) {
subSum += i;
}
System.out.println("分配给线程:"
+ Thread.currentThread().getName()
+ "那一部分List的整数和为:\tSubSum:" + subSum);
return subSum;
}
});
}
List<Future<Long>> futureList = exec1.invokeAll(callList);
for (Future<Long> future : futureList) {
sum += future.get();
}
exec1.shutdown();
System.out.println(sum);
AtomicInteger的简单举例
// 阻塞队列,能容纳100个文件
final BlockingQueue<File> queue = new LinkedBlockingQueue<File>(100);
// 线程池
final ExecutorService exec = Executors.newFixedThreadPool(5);
final File root = new File("D:\\jpg");
// 完成标志
final File exitFile = new File("");
// 原子整型,读个数
// AtomicInteger可以在并发情况下达到原子化更新,避免使用了synchronized,而且性能非常高。
final AtomicInteger rc = new AtomicInteger();
// 原子整型,写个数
final AtomicInteger wc = new AtomicInteger();
// 读线程
Runnable read = new Runnable() {
public void run() {
scanFile(root);
scanFile(exitFile);
}
public void scanFile(File file) {
if (file.isDirectory()) {
File[] files = file.listFiles(new FileFilter() {
public boolean accept(File pathname) {
return pathname.isDirectory() || pathname.getPath().endsWith(".jpg");
}
});
for (File one : files)
scanFile(one);
} else {
try {
// 原子整型的incrementAndGet方法,以原子方式将当前值加 1,返回更新的值
int index = rc.incrementAndGet();
System.out.println("Read0: " + index + " " + file.getPath());
// 添加到阻塞队列中
queue.put(file);
} catch (InterruptedException e) {
}
}
}
};
// submit方法提交一个 Runnable 任务用于执行,并返回一个表示该任务的 Future。
exec.submit(read);
// 四个写线程
for (int index = 0; index < 4; index++) {
// write thread
final int num = index;
Runnable write = new Runnable() {
String threadName = "Write" + num;
public void run() {
while (true) {
try {
Thread.sleep(randomTime());
// 原子整型的incrementAndGet方法,以原子方式将当前值加 1,返回更新的值
int index = wc.incrementAndGet();
// 获取并移除此队列的头部,在元素变得可用之前一直等待(如果有必要)。
File file = queue.take();
// 队列已经无对象
if (file == exitFile) {
// 再次添加"标志",以让其他线程正常退出
queue.put(exitFile);
break;
}
System.out.println(threadName + ": " + index + " " + file.getPath());
} catch (InterruptedException e) {
}
}
}
};
exec.submit(write);
}
exec.shutdown();
}