[code="java"]
import java.util.ArrayList;
import java.util.Vector;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
/**
/**
本例子为实现一个可
*/
public class CyclicBarrierTest {
public static void main(String[] args) {
int allcount = 0;
Vector al = new Vector();
for (int i = 0; i < 101; i++) {
al.add(i);
allcount += i;
}
System.out.println("all=" + allcount);
int size = al.size();
//将al分成4段，分别让4个线程计算每段之和
CyclicBarrier cb = new CyclicBarrier(4, new Runnable() {
public void run() {
System.out.println("------------------");
}
});
Share s = new Share(al, cb);
//第一个线程
jisuan js1 = new jisuan(0, (size / 4), s);
System.out.println("size/4=" + (size - (size / 4)));
//第2个线程
jisuan js2 = new jisuan((size / 4), (size / 2), s);
//第3线程 除不尽部分根据(size-(size/4)) 包含在第3线程计算
jisuan js3 = new jisuan((size / 2), (size - (size / 4)), s);
//第4线程
jisuan js4 = new jisuan((size - (size / 4)), size, s);
Thread t1 = new Thread(js1);
Thread t2 = new Thread(js2);
Thread t3 = new Thread(js3);
Thread t4 = new Thread(js4);
t1.start();
t2.start();
t3.start();
t4.start();
try {
t1.join();
t2.join();
t3.join();
t4.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("计算结果：" + s.count);
System.out.println("======end=======");
}
}
class jisuan implements Runnable {
int start = 0;
int end = 0;
Share s = null;
public jisuan(int start, int end, Share s) {
this.s = s;
this.start = start;
this.end = end;
}
public void run() {
try {
System.out.println("等待线程名字：" + Thread.currentThread().getName());
s.cyclicBarrier.await();
System.out.println("线程启动：" + Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "start=" + this.start + " end=" + this.end);
System.out.println(this.end - this.start);
for (int i = start; i < (end-start); i++) {
try {
System.out.println(Thread.currentThread().getName() + " @ start=" + start + "///" + end + " i=" + i);
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
s.count += (Integer) (s.al.get(i));
}
System.out.println(Thread.currentThread().getName() + " @ start=" + start + "///" + end);
System.out.println(Thread.currentThread().getName() + "*****" + s.count);
}
}
class Share {
public Vector al = null;
public int count = 0;
public CyclicBarrier cyclicBarrier = null;
public Share(Vector al, CyclicBarrier cyclicBarrier) {
this.al = al;
this.count = 0;
this.cyclicBarrier = cyclicBarrier;
}
}
//运行结果：
all=5050
size/4=76
等待线程名字：Thread-0
等待线程名字：Thread-2
等待线程名字：Thread-3
线程启动：Thread-1
线程启动：Thread-0
Thread-1start=25 end=50
线程启动：Thread-2
线程启动：Thread-3
Thread-0start=0 end=25
25
Thread-2start=50 end=76
Thread-3start=76 end=101
25
Thread-1 @ start=25///50
26
25
Thread-0 @ start=0///25 i=0
Thread-1*****0
Thread-2 @ start=50///76
Thread-3 @ start=76///101
Thread-2*****0
Thread-3*****0
Thread-0 @ start=0///25 i=1
Thread-0 @ start=0///25 i=2
Thread-0 @ start=0///25 i=3
Thread-0 @ start=0///25 i=4
Thread-0 @ start=0///25 i=5
Thread-0 @ start=0///25 i=6
Thread-0 @ start=0///25 i=7
Thread-0 @ start=0///25 i=8
Thread-0 @ start=0///25 i=9
Thread-0 @ start=0///25 i=10
Thread-0 @ start=0///25 i=11
Thread-0 @ start=0///25 i=12
Thread-0 @ start=0///25 i=13
Thread-0 @ start=0///25 i=14
Thread-0 @ start=0///25 i=15
Thread-0 @ start=0///25 i=16
Thread-0 @ start=0///25 i=17
Thread-0 @ start=0///25 i=18
Thread-0 @ start=0///25 i=19
Thread-0 @ start=0///25 i=20
Thread-0 @ start=0///25 i=21
Thread-0 @ start=0///25 i=22
Thread-0 @ start=0///25 i=23
Thread-0 @ start=0///25 i=24
Thread-0 @ start=0///25
Thread-0*****300
计算结果：300
======end=======
[/code]
将Vector平均分成4段，
上面的例子是想让4个线程分别计算vector4个部分，在将这4个部分之和相加 得到最终结果。
问题是 老是Thread-0线程进入循环体，其他线程压根都不进去？不是很明白，往牛人指点下！
以上是你你打印出来的
请问start=50 end=76
for (int i = start; i < (end-start); i++) {
是不是等同于
for (int i = 50; i < 26; i++) {
你觉得这个for循环进的去??
Vector是有做同步的，所以一个线程在使用，其它线程都在等待，所以造成只有一个线程能进行循环。
这我的理解，供参。