Java 使用新参数在循环中创建新线程

我想在循环中创建新的

Runnable

。但是，不可能在内部类中使用变量。我不能使用全局/实例变量，因为它生成错误的结果。我的程序类似于下面的简化代码：

public class RunManager {
    public void runManager(int delay, final Context context) {
        for (int dim = 7; dim < 227; dim++) {
            Runnable r = new Runnable() {
                @Override
                public void run() {
                    RandomKernels randomKernels = new RandomKernels();
                    try {
                        randomKernels.foo(context, dim);
                    } catch (InterruptedException e) {
                        Log.e(tag, e.getMessage());
                    }
                }
            };
            Thread cnnThread = new Thread(r);
            cnnThread.start();
            try {
                Thread.sleep(delay);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

公共类运行管理器{
公共void运行管理器（int延迟，最终上下文）{
用于（内部尺寸=7；尺寸<227；尺寸++）{
Runnable r=新的Runnable（）{
@凌驾
公开募捐{
随机核随机核=新的随机核（）；
试一试{
foo（上下文，dim）；
}捕捉（中断异常e）{
Log.e（标记，e.getMessage（））；
}
}
};
螺纹cnnThread=新螺纹（r）；
cnnThread.start（）；
试一试{
睡眠（延迟）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
}
}
}

---

错误是：

变量“dim”是从内部类中访问的，需要声明为final。

您的问题是试图从新线程访问非final变量。若要从新线程访问变量，需要将其声明为final。在cas中，您只需将dim int复制到大小为1的最终int数组中，然后从线程访问该数组。

最清晰的方法可能是为您的

可运行

创建一个构造函数，该构造函数接受int作为参数。例如：

public class MyRunnable implements Runnable {

   public MyRunnable(Context context, int dim) {
       // save parameters as class variables
   }

   public void run() {
       // do the work
   }
}

那就叫它：

Runnable r = new MyRunnable(context, dim);
new Thread(r).start();

---

如果您想访问内部类中的值，应该使用

final int[]dim

public class RunManager {

    public void runManager(int delay, final Context context) {
        for (final int dim[] = {7}; dim[1] < 227; dim[1]++) {
            Runnable r = new Runnable() {
                @Override
                public void run() {
                    RandomKernels randomKernels = new RandomKernels();
                    try {
                        randomKernels.foo(context, dim[1]);
                    } catch (InterruptedException e) {
                        Log.e(tag, e.getMessage());
                    }
                }
            };
            Thread cnnThread = new Thread(r);
            cnnThread.start();
            try {
                Thread.sleep(delay);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class RunManager {

    public void runManager(int delay, final Context context) {
        for (int dim = 7; dim < 227; dim++) {
            CustomRunnable r = new CustomRunnable() {
                private int _dim;

                @Override
                public void run() {
                    RandomKernels randomKernels = new RandomKernels();
                    try {
                        randomKernels.foo(context, _dim);
                    } catch (InterruptedException e) {
                        Log.e(tag, e.getMessage());
                    }
                }

                public void setDim(int dim) {
                    _dim = dim;
                }
            };

            r.setDim(dim);

            Thread cnnThread = new Thread(r);
            cnnThread.start();
            try {
                Thread.sleep(delay);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    abstract class CustomRunnable implements Runnable {
        public abstract void setDim(int dim);
    }
}

选项4-使用自定义runnable。您可以按照@BMacedo的建议实现类，也可以创建抽象类并在内部类中实现逻辑

public class RunManager {

    public void runManager(int delay, final Context context) {
        for (final int dim[] = {7}; dim[1] < 227; dim[1]++) {
            Runnable r = new Runnable() {
                @Override
                public void run() {
                    RandomKernels randomKernels = new RandomKernels();
                    try {
                        randomKernels.foo(context, dim[1]);
                    } catch (InterruptedException e) {
                        Log.e(tag, e.getMessage());
                    }
                }
            };
            Thread cnnThread = new Thread(r);
            cnnThread.start();
            try {
                Thread.sleep(delay);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class RunManager {

    public void runManager(int delay, final Context context) {
        for (int dim = 7; dim < 227; dim++) {
            CustomRunnable r = new CustomRunnable() {
                private int _dim;

                @Override
                public void run() {
                    RandomKernels randomKernels = new RandomKernels();
                    try {
                        randomKernels.foo(context, _dim);
                    } catch (InterruptedException e) {
                        Log.e(tag, e.getMessage());
                    }
                }

                public void setDim(int dim) {
                    _dim = dim;
                }
            };

            r.setDim(dim);

            Thread cnnThread = new Thread(r);
            cnnThread.start();
            try {
                Thread.sleep(delay);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    abstract class CustomRunnable implements Runnable {
        public abstract void setDim(int dim);
    }
}

公共类运行管理器{
公共void运行管理器（int延迟，最终上下文）{
用于（内部尺寸=7；尺寸<227；尺寸++）{
CustomRunnable r=新的CustomRunnable（）{
私人互联网；
@凌驾
公开募捐{
随机核随机核=新的随机核（）；
试一试{
foo（上下文，_dim）；
}捕捉（中断异常e）{
Log.e（标记，e.getMessage（））；
}
}
公共无效设置dim（整数dim）{
_dim=dim；
}
};
r、 setDim（dim）；
螺纹cnnThread=新螺纹（r）；
cnnThread.start（）；
试一试{
睡眠（延迟）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
}
}
抽象类CustomRunnable实现Runnable{
公共摘要无效集dim（int dim）；
}
}

您真的想创建220个不同的线程吗？@BMacedo感谢您的快速响应。是的，每个线程在5毫秒后完成其计算。我正在尝试执行模拟工作负载以监视硬件特性。