Java 为什么要让ArrayIndexOutOfBoundsException?
给我正确的输出,但有时得到IndexOutOFBound异常…无法获得编译器所做的重新排序Java 为什么要让ArrayIndexOutOfBoundsException?,java,multithreading,Java,Multithreading,给我正确的输出,但有时得到IndexOutOFBound异常…无法获得编译器所做的重新排序 package com.array.thread; import java.util.concurrent.*; public class EvenOddProcessor { public static void main(String[] args) { CyclicBarrier barrier = new CyclicBarrier(6, new Runnable()
package com.array.thread;
import java.util.concurrent.*;
public class EvenOddProcessor {
public static void main(String[] args) {
CyclicBarrier barrier = new CyclicBarrier(6, new Runnable() {
@Override
public void run() {
System.out.println("BARRIER BROKEN!!!");
}
});
int[] array = new int[10];
for (int i = 0; i < array.length; i++)
array[i] = i;
ArrayIndexProcessor evenIndexProcessor = new ArrayIndexProcessor(array,
0, barrier);
ArrayIndexProcessor oddIndexProcessor = new ArrayIndexProcessor(array,
1, barrier);
Thread t1 = new Thread(evenIndexProcessor, "Even_1");
Thread t2 = new Thread(evenIndexProcessor, "Even_2");
Thread t3 = new Thread(evenIndexProcessor, "Even_3");
t1.start();
t2.start();
t3.start();
Thread t4 = new Thread(oddIndexProcessor, "Odd_1");
Thread t5 = new Thread(oddIndexProcessor, "Odd_2");
Thread t6 = new Thread(oddIndexProcessor, "Odd_3");
t4.start();
t5.start();
t6.start();
System.out.println(">>>>> Main thread is done");
}
}
class ArrayIndexProcessor implements Runnable {
private final CyclicBarrier barrier;
private final int[] array;
private volatile int currentPtr = 0;
private Lock lock = new ReentrantLock();
public ArrayIndexProcessor(int[] array, int startIndex,
CyclicBarrier barrier) {
this.array = array;
this.currentPtr = startIndex;
this.barrier = barrier;
}
public void run() {
try {
barrier.await();
} catch (InterruptedException | BrokenBarrierException e) {
e.printStackTrace();
}
while (!(array.length == 0) && (currentPtr < array.length)) {
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + "="
+ array[currentPtr]);
currentPtr = currentPtr + 2;
} finally {
lock.unlock();
}
}
}
}
package com.array.thread;
导入java.util.concurrent.*;
公共类处理器{
公共静态void main(字符串[]args){
CyclicBarrier屏障=新的CyclicBarrier(6,新的可运行(){
@凌驾
公开募捐{
System.out.println(“屏障破裂!!!”;
}
});
int[]数组=新的int[10];
for(int i=0;i>>>主线程完成”);
}
}
类ArrayIndexProcessor实现可运行{
私人自行车终点障碍;
私有final int[]数组;
私有易失性int currentPtr=0;
private Lock=new ReentrantLock();
公共ArrayIndex处理器(int[]数组,int startIndex,
自行车运载障碍物){
this.array=数组;
this.currentPtr=startIndex;
这个障碍=障碍;
}
公开募捐{
试一试{
障碍。等待();
}catch(中断异常|断开异常){
e、 printStackTrace();
}
而(!(array.length==0)和&(currentPtr而(!(array.length==0)和&(currentPtr
首先对currentPtr
进行边界检查,然后锁定,然后使用currentPtr
作为数组索引。由于在三个线程中重用相同的Runnable
实例,currentPtr
可能同时被修改,从而导致一个越界索引。while(!(array.length==0)&&(当前ptr
首先对currentPtr
进行边界检查,然后锁定,然后使用currentPtr
作为数组索引。由于您在三个线程中重用相同的Runnable
实例,currentPtr
可能同时被修改,导致一个越界索引。一个完整的堆栈跟踪,指针指向l非常感谢其中提到的INE(并防止您的问题即将结束)。在请求有关异常的帮助时,请引用异常的全文,并告诉我们异常所指的代码块中的哪一行。非常感谢完整的堆栈跟踪,以及指向其中提到的行的指针(并防止问题即将结束)。在请求异常帮助时,请引用异常的全文,并告诉我们异常所指的代码块中的哪一行。
while (!(array.length == 0) && (currentPtr < array.length)) {
lock.lock();